omnius 1.0.871 → 1.0.873

package/dist/tui/native/worker.js

@@ -2,18 +2,18 @@
 import { createWriteStream } from "node:fs";
 import { createInterface } from "node:readline";
 import { PassThrough } from "node:stream";
-import { CliRenderEvents as CliRenderEvents7, NativeSession, RGBA as RGBA3, createCliRenderer } from "@opentui/core";
+import { CliRenderEvents as CliRenderEvents9, NativeSession, RGBA as RGBA3, createCliRenderer } from "@opentui/core";
 
 // packages/cli/src/tui/native/components/frontend.ts
 import {
-  BoxRenderable as BoxRenderable8,
-  CliRenderEvents as CliRenderEvents5,
+  BoxRenderable as BoxRenderable10,
+  CliRenderEvents as CliRenderEvents7,
   EmbeddedTerminalRenderable as EmbeddedTerminalRenderable2,
-  ScrollBoxRenderable as ScrollBoxRenderable5,
+  ScrollBoxRenderable as ScrollBoxRenderable7,
   SyntaxStyle as SyntaxStyle2,
   TextareaRenderable as TextareaRenderable2,
-  TextRenderable as TextRenderable7,
-  TextAttributes as TextAttributes8,
+  TextRenderable as TextRenderable9,
+  TextAttributes as TextAttributes10,
   createClipboard,
   createHostClipboard,
   createRendererClipboardAdapter
@@ -35,6 +35,16 @@ function sanitizeNativeInterfaceState(value) {
     Object.defineProperty(views, key, { value: { top: offset(entry.top), live: entry.live === true, disclosures }, enumerable: true, configurable: true, writable: true });
   }
   const layout = record(value.layout) ? value.layout : {}, instruments = record(value.instruments) ? value.instruments : {}, tabs = record(value.tabs) ? value.tabs : {};
+  const taskNotes = record(instruments.taskNotes) ? instruments.taskNotes : void 0;
+  const workQueue = record(instruments.workQueue) ? instruments.workQueue : void 0;
+  const workDisclosures = {};
+  if (workQueue && record(workQueue.disclosures)) for (const [id, open] of Object.entries(workQueue.disclosures).slice(0, 2048)) {
+    if (id.length <= 1024 && typeof open === "boolean") Object.defineProperty(workDisclosures, id, { value: open, enumerable: true, configurable: true, writable: true });
+  }
+  const taskDisclosures = {};
+  if (taskNotes && record(taskNotes.disclosures)) for (const [id, open] of Object.entries(taskNotes.disclosures).slice(0, 2048)) {
+    if (id.length <= 1024 && typeof open === "boolean") Object.defineProperty(taskDisclosures, id, { value: open, enumerable: true, configurable: true, writable: true });
+  }
   return {
     version: 1,
     ...typeof value.sessionId === "string" ? { sessionId: value.sessionId.slice(0, 1024) } : {},
@@ -55,7 +65,9 @@ function sanitizeNativeInterfaceState(value) {
       context: instruments.context === true,
       devices: instruments.devices === true,
       scrollTop: offset(instruments.scrollTop),
-      deviceScrollTop: offset(instruments.deviceScrollTop)
+      deviceScrollTop: offset(instruments.deviceScrollTop),
+      ...taskNotes ? { taskNotes: { open: taskNotes.open !== false, tasks: taskNotes.tasks !== false, notes: taskNotes.notes !== false, layers: taskNotes.layers !== false, disclosures: taskDisclosures } } : {},
+      ...workQueue ? { workQueue: { open: workQueue.open !== false, history: workQueue.history === true, disclosures: workDisclosures } } : {}
     },
     tabs: { sessions: offset(tabs.sessions), agents: offset(tabs.agents) }
   };
@@ -185,14 +197,14 @@ function installDefaultSelectionContrast(renderer2) {
   const foreground2 = RGBA.defaultForeground();
   const background2 = RGBA.defaultBackground();
   const paintSelection = (buffer) => {
-    const lines = buffer.getSpanLines();
+    const lines2 = buffer.getSpanLines();
     buffer.withBuffers((cells) => {
-      for (let y = 0; y < lines.length; y++) {
+      for (let y = 0; y < lines2.length; y++) {
         let x = 0;
-        for (const span of lines[y].spans) {
+        for (const span of lines2[y].spans) {
           if (span.fg.intent === "default" && span.bg.intent === "default" && !(span.attributes & TextAttributes.INVERSE) && span.fg.equals(background2) && span.bg.equals(foreground2)) {
-            for (let column = x; column < x + span.width; column++)
-              cells.attributes[y * cells.width + column] |= TextAttributes.INVERSE;
+            for (let column3 = x; column3 < x + span.width; column3++)
+              cells.attributes[y * cells.width + column3] |= TextAttributes.INVERSE;
           }
           x += span.width;
         }
@@ -296,7 +308,7 @@ var NativeMediaPlayback = class {
       });
       if (spec.kind === "video") {
         const bytes = width * height * 4;
-        let pending = Buffer.alloc(0), frames = 0;
+        let pending = Buffer.alloc(0), frames2 = 0;
         const offset2 = this.positionSec;
         for await (const chunk of child.stdout) {
           if (epoch !== this.epoch) break;
@@ -304,8 +316,8 @@ var NativeMediaPlayback = class {
           while (pending.length >= bytes && epoch === this.epoch) {
             frame(pending.subarray(0, bytes), width, height);
             pending = pending.subarray(bytes);
-            frames++;
-            if (!withAudio) this.positionSec = offset2 + frames / 8;
+            frames2++;
+            if (!withAudio) this.positionSec = offset2 + frames2 / 8;
             this.changed();
           }
         }
@@ -396,8 +408,8 @@ function mediaPreviewHeight(width, imageWidth, imageHeight, cellAspectRatio = 2)
 function audioWaveform(samples, width) {
   const cells = Math.max(1, Math.min(240, Math.floor(width)));
   const glyphs = "▁▂▃▄▅▆▇█";
-  return Array.from({ length: cells }, (_, column) => {
-    const begin = Math.floor(column * samples.length / cells), end = Math.max(begin + 1, Math.floor((column + 1) * samples.length / cells));
+  return Array.from({ length: cells }, (_, column3) => {
+    const begin = Math.floor(column3 * samples.length / cells), end = Math.max(begin + 1, Math.floor((column3 + 1) * samples.length / cells));
     let peak = 0;
     for (let index = begin; index < end && index < samples.length; index++) if (Number.isFinite(samples[index])) peak = Math.max(peak, Math.abs(samples[index]));
     return glyphs[Math.min(7, Math.floor(Math.min(1, peak) * 7))];
@@ -465,10 +477,10 @@ var NativeMediaView = class extends BoxRenderable {
   pausePlayback() {
     this.playback.pause();
   }
-  control(action, label, operation) {
+  control(action, label2, operation) {
     const control = new TextRenderable(this.renderer, {
       id: `media-control:${this.mediaId}:${action}`,
-      content: label,
+      content: label2,
       fg: this.colors.foreground,
       selectable: false,
       onMouseDown: (event) => {
@@ -615,14 +627,14 @@ var NativeMediaView = class extends BoxRenderable {
       active = ancestor.visible;
       ancestor = ancestor.parent;
     }
-    const visible = active && this.y + this.height > viewport.y && this.y < viewport.y + viewport.height;
-    if (!visible && this.playback.playing) this.playback.pause();
-    if (!visible && this.probeController && !this.samples) {
+    const visible2 = active && this.y + this.height > viewport.y && this.y < viewport.y + viewport.height;
+    if (!visible2 && this.playback.playing) this.playback.pause();
+    if (!visible2 && this.probeController && !this.samples) {
       this.probeController.abort();
       this.probeController = void 0;
       this.needsProbe = true;
     }
-    if (visible) this.startProbe();
+    if (visible2) this.startProbe();
     this.refreshGeometry();
   }
   refreshGeometry() {
@@ -642,8 +654,8 @@ var NativeMediaView = class extends BoxRenderable {
     if (this.isDestroyed) return;
     const text = `${this.hovered ? "Open ↗ · " : ""}${this.currentStatus}`;
     if (this.status.plainText !== text) this.status.content = text;
-    const label = this.playback?.playing ? "Pause" : this.playback?.positionSec ? "Resume" : "Play";
-    if (this.playControl.plainText !== label) this.playControl.content = label;
+    const label2 = this.playback?.playing ? "Pause" : this.playback?.positionSec ? "Resume" : "Play";
+    if (this.playControl.plainText !== label2) this.playControl.content = label2;
     if (this.waveformText) {
       const cursor = this.duration > 0 ? Math.min(this.waveformText.length - 1, Math.floor(this.playback.positionSec / this.duration * this.waveformText.length)) : 0;
       const waveform = this.playback.positionSec > 0 ? this.waveformText.slice(0, cursor) + "│" + this.waveformText.slice(cursor + 1) : this.waveformText;
@@ -925,7 +937,7 @@ function nativeProgressText(value, working = false) {
   if (value === void 0 || !Number.isFinite(value)) return `[············] ${working ? "working" : "pending"}`;
   const ratio = Math.max(0, Math.min(1, value));
   const filled = Math.round(ratio * 12);
-  return `[${"•".repeat(filled)}${"·".repeat(12 - filled)}] ${Math.round(ratio * 100)}%`;
+  return `[${"▮".repeat(filled)}${"░".repeat(12 - filled)}] ${Math.round(ratio * 100)}%`;
 }
 function nativeControlFocus(control, baseAttributes = 0) {
   const update = () => {
@@ -1511,10 +1523,10 @@ var NativeSelectRenderable = class extends SelectRenderable {
       this.seekRail(event);
       return;
     }
-    const lines = this.showDescription ? 2 : 1;
-    const count = Math.max(1, Math.floor(this.height / lines));
+    const lines2 = this.showDescription ? 2 : 1;
+    const count = Math.max(1, Math.floor(this.height / lines2));
     const start = Math.max(0, Math.min(this.getSelectedIndex() - Math.floor(count / 2), this.options.length - count));
-    const index = start + Math.floor((event.y - this.y) / lines);
+    const index = start + Math.floor((event.y - this.y) / lines2);
     if (index >= start && index < Math.min(start + count, this.options.length) && !this.disabled(index)) {
       this.setSelectedIndex(index);
       this.onActivate?.();
@@ -1528,7 +1540,7 @@ import { BoxRenderable as BoxRenderable3, CliRenderEvents as CliRenderEvents2, R
 function drawCornerFrame(buffer, panel, colors, progress = 1) {
   const { x, y, width, height } = panel;
   if (width <= 0 || height <= 0) return;
-  const draw = (text, column, row) => buffer.drawText(text, column, row, colors.foreground, colors.background, TextAttributes3.DIM);
+  const draw = (text, column3, row) => buffer.drawText(text, column3, row, colors.foreground, colors.background, TextAttributes3.DIM);
   draw(" ".repeat(width), x, y);
   if (height > 1) draw(" ".repeat(width), x, y + height - 1);
   for (let row = 1; row < height - 1; row++) {
@@ -1551,9 +1563,9 @@ function drawCornerFrame(buffer, panel, colors, progress = 1) {
   draw(`└${"─".repeat(horizontal)}`, x, y + height - 1);
   draw(`${"─".repeat(horizontal)}┘`, x + width - horizontal - 1, y + height - 1);
   for (let arm = 1; arm <= vertical; arm++) {
-    for (const column of [x, x + width - 1]) {
-      draw("│", column, y + arm);
-      draw("│", column, y + height - arm - 1);
+    for (const column3 of [x, x + width - 1]) {
+      draw("│", column3, y + arm);
+      draw("│", column3, y + height - arm - 1);
     }
   }
 }
@@ -2043,7 +2055,7 @@ var NativeModalView = class {
       return consume();
     }
     if (key.name === "tab") {
-      if (this.spec.deferSelection || this.spec.captureKeys) this.emitAction(key.shift ? "shift-tab" : "tab");
+      if (!this.spec.nativeTabNavigation && (this.spec.deferSelection || this.spec.captureKeys)) this.emitAction(key.shift ? "shift-tab" : "tab");
       else this.nextControl(key.shift ? -1 : 1);
       return consume();
     }
@@ -2195,9 +2207,9 @@ var NativeModalStack = class {
     if (!panel || panel.isDestroyed || !panel.visible) return;
     const { x, y, width, height } = this.active.frame.bounds;
     buffer.withBuffers((cells) => {
-      for (let row = 0; row < cells.height; row++) for (let column = 0; column < cells.width; column++) {
-        if (column < x || column >= x + width || row < y || row >= y + height)
-          cells.attributes[row * cells.width + column] |= TextAttributes4.DIM;
+      for (let row = 0; row < cells.height; row++) for (let column3 = 0; column3 < cells.width; column3++) {
+        if (column3 < x || column3 >= x + width || row < y || row >= y + height)
+          cells.attributes[row * cells.width + column3] |= TextAttributes4.DIM;
       }
     });
   };
@@ -2251,12 +2263,12 @@ var NativeModalStack = class {
 
 // packages/cli/src/tui/native/components/instruments.ts
 import {
-  BoxRenderable as BoxRenderable5,
+  BoxRenderable as BoxRenderable7,
   RGBA as RGBA2,
-  RenderableEvents as RenderableEvents3,
-  ScrollBoxRenderable as ScrollBoxRenderable3,
-  TextAttributes as TextAttributes5,
-  TextRenderable as TextRenderable4
+  RenderableEvents as RenderableEvents5,
+  ScrollBoxRenderable as ScrollBoxRenderable5,
+  TextAttributes as TextAttributes7,
+  TextRenderable as TextRenderable6
 } from "@opentui/core";
 
 // packages/cli/src/tui/native/components/device-history.ts
@@ -2311,6 +2323,16 @@ function deviceHistoryGraph(samples, field, width) {
   return cells.map((row, y) => labels[y] + row.map((bits, x) => bits ? String.fromCodePoint(10240 + bits) : x % 4 === 0 ? "·" : " ").join("")).join("\n");
 }
 
+// packages/cli/src/tui/native/components/task-notes.ts
+import {
+  BoxRenderable as BoxRenderable5,
+  CliRenderEvents as CliRenderEvents3,
+  RenderableEvents as RenderableEvents3,
+  ScrollBoxRenderable as ScrollBoxRenderable3,
+  TextAttributes as TextAttributes5,
+  TextRenderable as TextRenderable4
+} from "@opentui/core";
+
 // packages/cli/src/tui/terminal-cells.ts
 var graphemes = new Intl.Segmenter(void 0, { granularity: "grapheme" });
 var extendedPictographic = /\p{Extended_Pictographic}/u;
@@ -2392,9 +2414,9 @@ function terminalCellWidth(value) {
 var graphemes2 = new Intl.Segmenter(void 0, { granularity: "grapheme" });
 function formatSignalDivider(width, geometry = { direction: "top" }) {
   const cells = Math.max(0, Math.floor(width));
-  const column = Math.floor(geometry.sidebarColumn ?? -1);
-  if (!Number.isFinite(column) || column < 0 || column >= cells) return "─".repeat(cells);
-  return "─".repeat(column) + (geometry.direction === "top" ? "┬" : "┴") + "─".repeat(cells - column - 1);
+  const column3 = Math.floor(geometry.sidebarColumn ?? -1);
+  if (!Number.isFinite(column3) || column3 < 0 || column3 >= cells) return "─".repeat(cells);
+  return "─".repeat(column3) + (geometry.direction === "top" ? "┬" : "┴") + "─".repeat(cells - column3 - 1);
 }
 function fitInstrumentText(value, cells, marker = "~") {
   const text = stripTerminalSequences(normalizeTerminalLine(value));
@@ -2411,7 +2433,7 @@ function fitInstrumentText(value, cells, marker = "~") {
   }
   return result + suffix;
 }
-function formatTelemetryRow(label, value, width, reserved = 12) {
+function formatTelemetryRow(label2, value, width, reserved = 12) {
   const cells = Math.max(0, Math.floor(width));
   if (!cells) return "";
   const reading = stripTerminalSequences(normalizeTerminalLine(value));
@@ -2419,7 +2441,7 @@ function formatTelemetryRow(label, value, width, reserved = 12) {
   if (readingCells >= cells) return fitInstrumentText(reading, cells);
   const field = Math.min(cells, Math.max(readingCells, Math.floor(reserved)));
   const labelCells = Math.max(0, cells - field - 1);
-  const left = fitInstrumentText(label.toUpperCase(), labelCells);
+  const left = fitInstrumentText(label2.toUpperCase(), labelCells);
   const dots = ".".repeat(Math.max(0, cells - field - terminalCellWidth(left)));
   return left + dots + " ".repeat(Math.max(0, field - readingCells)) + reading;
 }
@@ -2432,15 +2454,15 @@ function formatSignalMeter(value, maximum, width = 8) {
     return `[${".".repeat(cells)}] --`;
   const ratio = Math.max(0, Math.min(1, value / maximum));
   const filled = Math.round(ratio * cells);
-  return `[${"●".repeat(filled)}${"○".repeat(cells - filled)}] ${Math.round(ratio * 100)}%`;
+  return `[${"▮".repeat(filled)}${"░".repeat(cells - filled)}] ${Math.round(ratio * 100)}%`;
 }
 function formatSectionBanner(title, width, expanded = true) {
   const cells = Math.max(0, Math.floor(width));
-  const label = fitInstrumentText(
+  const label2 = fitInstrumentText(
     `${expanded ? "-" : "+"} ${title.toUpperCase()} `,
     cells
   );
-  return label + "─".repeat(Math.max(0, cells - terminalCellWidth(label)));
+  return label2 + "─".repeat(Math.max(0, cells - terminalCellWidth(label2)));
 }
 function instrumentStatus(value) {
   const status = (value || "unknown").toLowerCase();
@@ -2453,10 +2475,994 @@ function instrumentStatus(value) {
   return status.toUpperCase();
 }
 
+// packages/cli/src/tui/native/components/task-notes.ts
+var marks = ["▨", "▧", "▥", "▦"];
+var reducedMotion = () => process.env["OMNIUS_TUI_REDUCE_MOTION"] === "1" || process.env["REDUCE_MOTION"] === "1";
+var safe = (value) => typeof value === "string" ? plainText(value) : "";
+var lines = (values) => Array.isArray(values) ? values.filter((value) => typeof value === "string").map(safe) : [];
+var column = (renderer2, id) => new BoxRenderable5(renderer2, { id, width: "100%", flexDirection: "column", flexShrink: 0, minWidth: 0 });
+function visible(node, renderer2) {
+  if (node.width < 1 || node.height < 1 || node.y >= renderer2.terminalHeight || node.y + node.height <= 0) return false;
+  for (let current = node; current; current = current.parent) {
+    if (!current.visible) return false;
+    if (current instanceof ScrollBoxRenderable3 && (node.y + node.height <= current.viewport.y || node.y >= current.viewport.y + current.viewport.height || node.x + node.width <= current.viewport.x || node.x >= current.viewport.x + current.viewport.width)) return false;
+  }
+  return true;
+}
+var ActiveBlocks = class {
+  constructor(renderer2, active, paint) {
+    this.renderer = renderer2;
+    this.active = active;
+    this.paint = paint;
+    renderer2.on(CliRenderEvents3.FRAME, this.sync);
+  }
+  renderer;
+  active;
+  paint;
+  timer;
+  frame = 0;
+  destroyed = false;
+  get running() {
+    return this.timer !== void 0;
+  }
+  sync = () => {
+    const animate = !this.destroyed && !reducedMotion() && this.active();
+    if (animate && !this.timer) {
+      this.timer = setInterval(() => {
+        if (!this.active() || reducedMotion()) {
+          this.sync();
+          return;
+        }
+        this.paint(marks[++this.frame % marks.length]);
+      }, 250);
+      this.timer.unref?.();
+    } else if (!animate && this.timer) {
+      clearInterval(this.timer);
+      this.timer = void 0;
+    }
+  };
+  destroy() {
+    this.destroyed = true;
+    if (this.timer) clearInterval(this.timer);
+    this.timer = void 0;
+    this.renderer.off(CliRenderEvents3.FRAME, this.sync);
+  }
+};
+var Disclosure = class extends TextRenderable4 {
+  constructor(renderer2, id, activate, colors, ruled = false) {
+    super(renderer2, {
+      id,
+      content: "",
+      width: "100%",
+      height: 1,
+      minWidth: 0,
+      flexShrink: 0,
+      wrapMode: "none",
+      truncate: true,
+      fg: colors.foreground,
+      bg: colors.background,
+      selectable: false,
+      onMouseDown: (event) => {
+        if (event.button === 0) {
+          this.focus();
+          activate();
+          event.preventDefault();
+          event.stopPropagation();
+        }
+      },
+      onKeyDown: (key) => {
+        if (key.eventType === "release") return;
+        if (key.name === "return" || key.sequence === " " || key.name === "right" && !this.open || key.name === "left" && this.open) {
+          activate();
+          key.preventDefault();
+          key.stopPropagation();
+        }
+      }
+    });
+    this.activate = activate;
+    this.colors = colors;
+    this.ruled = ruled;
+    this.focusable = true;
+    this.on(RenderableEvents3.FOCUSED, this.style);
+    this.on(RenderableEvents3.BLURRED, this.style);
+  }
+  activate;
+  colors;
+  ruled;
+  open = true;
+  label = "";
+  base = TextAttributes5.BOLD;
+  update(label2, open, attributes = TextAttributes5.BOLD) {
+    this.label = label2;
+    this.open = open;
+    this.base = attributes;
+    this.refresh();
+    this.style();
+  }
+  applyTheme(colors) {
+    this.colors = colors;
+    this.fg = colors.foreground;
+    this.bg = colors.background;
+  }
+  style = () => {
+    this.attributes = this.base | (this.focused ? TextAttributes5.INVERSE : 0);
+  };
+  onResize(width, height) {
+    super.onResize(width, height);
+    this.refresh();
+  }
+  refresh() {
+    const text = this.ruled ? formatSectionBanner(this.label, this.width, this.open) : fitInstrumentText(`${this.open ? "−" : "+"} ${this.label}`, this.width);
+    if (this.plainText !== text) this.content = text;
+  }
+};
+function metadata(item) {
+  const rows = [item.workKind ? `KIND ${safe(item.workKind)}` : "", item.owner ? `OWNER ${safe(item.owner)}` : "", item.blocker ? `BLOCKED ${safe(item.blocker)}` : ""];
+  for (const [label2, values] of [["DEPENDS ON", item.blockedBy], ["BLOCKS", item.blocks], ["REQUIREMENTS", item.requirementIds], ["ACCEPTANCE", item.acceptanceIds], ["SOURCES", item.sourceRefs]])
+    if (lines(values).length) rows.push(`${label2} ${lines(values).join(", ")}`);
+  for (const ref of item.targetRefs ?? []) if (ref && safe(ref.ref)) rows.push(`${safe(ref.kind).toUpperCase()} ${safe(ref.ref)}`);
+  const contract = item.actionContract;
+  if (contract) {
+    for (const [label2, values] of [["PRECONDITIONS", contract.preconditions], ["MUTATIONS", contract.mutations], ["SIDE EFFECTS", contract.sideEffects]])
+      if (lines(values).length) rows.push(`${label2} ${lines(values).join("; ")}`);
+    for (const key of ["authority", "approval", "risk"]) if (safe(contract[key])) rows.push(`${key.toUpperCase()} ${safe(contract[key])}`);
+  }
+  return rows.filter(Boolean).join("\n");
+}
+function taskMark(item, frame = marks[0]) {
+  return item.status === "in_progress" ? frame : item.status === "completed" ? "■" : item.status === "blocked" ? "▣" : "□";
+}
+function layerStatus(layer) {
+  const status = safe(layer.status).toLowerCase();
+  if (["verified", "integrated"].includes(status)) return `REPORTED ${status.toUpperCase()} · AUTHORITY NOT ATTESTED`;
+  return ["bound", "recorded", "tool complete", "tool failed", "compact", "hold", "accepted", "requested", "held", "incomplete verification", "incomplete_verification", "incomplete", "awaiting_input", "not attached", "proposed", "specified", "ready", "pending", "waiting", "leased", "running", "candidate", "verifying", "blocked", "retryable", "completed", "failed", "rejected", "cancelled", "superseded", "received", "queued", "acknowledged", "visible_in_request", "reconciliation_required", "reconciled", "first_affected_action", "consumed"].includes(status) ? status.replace(/_/g, " ").toUpperCase() : "UNKNOWN";
+}
+var NativeTaskNotesView = class extends BoxRenderable5 {
+  constructor(renderer2, colors, reveal) {
+    super(renderer2, { id: "omnius-task-notes", width: "100%", minWidth: 0, flexShrink: 0, flexDirection: "column", visible: false });
+    this.renderer = renderer2;
+    this.colors = colors;
+    this.reveal = reveal;
+    const text = (id, attributes = 0) => new TextRenderable4(renderer2, { id, content: "", width: "100%", minWidth: 0, flexShrink: 0, fg: colors.foreground, bg: colors.background, attributes, wrapMode: "word" });
+    const heading = (id, label2, key) => {
+      const node = new Disclosure(renderer2, id, () => {
+        this.presentation[key] = !this.presentation[key];
+        this.applyPresentation();
+      }, colors, true);
+      node.update(label2, this.presentation[key]);
+      node.on(RenderableEvents3.FOCUSED, () => this.reveal?.(node));
+      return node;
+    };
+    this.header = heading("omnius-task-notes:heading", "TASKS / NOTES", "open");
+    this.add(this.header);
+    this.body = column(renderer2, "omnius-task-notes:body");
+    this.add(this.body);
+    this.scope = text("omnius-task-notes:scope", TextAttributes5.DIM);
+    this.body.add(this.scope);
+    this.warning = text("omnius-task-notes:warning", TextAttributes5.BOLD);
+    this.body.add(this.warning);
+    this.taskHeader = heading("omnius-task-notes:tasks", "TASKS", "tasks");
+    this.body.add(this.taskHeader);
+    this.taskBody = column(renderer2, "omnius-task-notes:task-body");
+    this.body.add(this.taskBody);
+    this.noteHeader = heading("omnius-task-notes:notes", "NOTES", "notes");
+    this.body.add(this.noteHeader);
+    this.noteBody = column(renderer2, "omnius-task-notes:note-body");
+    this.body.add(this.noteBody);
+    this.layerHeader = heading("omnius-task-notes:layers", "RECORDED ORCHESTRATION", "layers");
+    this.body.add(this.layerHeader);
+    this.layerBody = column(renderer2, "omnius-task-notes:layer-body");
+    this.body.add(this.layerBody);
+    this.omitted = text("omnius-task-notes:omitted", TextAttributes5.DIM);
+    this.body.add(this.omitted);
+    this.animation = new ActiveBlocks(renderer2, () => [...this.rows.values()].some((row) => row.item.status === "in_progress" && visible(row.title, renderer2)), (mark) => {
+      this.frame = mark;
+      for (const row of this.rows.values()) if (row.item.status === "in_progress" && visible(row.title, renderer2)) this.refreshRow(row);
+    });
+    renderer2.on(CliRenderEvents3.FRAME, this.finishInspect);
+  }
+  renderer;
+  colors;
+  reveal;
+  header;
+  body;
+  scope;
+  warning;
+  taskHeader;
+  taskBody;
+  noteHeader;
+  noteBody;
+  layerHeader;
+  layerBody;
+  omitted;
+  rows = /* @__PURE__ */ new Map();
+  noteRows = /* @__PURE__ */ new Map();
+  layerRows = /* @__PURE__ */ new Map();
+  disclosures = /* @__PURE__ */ new Map();
+  sessions = /* @__PURE__ */ new Map();
+  state;
+  signature = "";
+  animation;
+  frame = marks[0];
+  taskLabel = "TASKS";
+  pendingInspect;
+  presentation = { open: true, tasks: true, notes: true, layers: true };
+  get animating() {
+    return this.animation.running;
+  }
+  update(state) {
+    const signature = JSON.stringify(state);
+    if (signature === this.signature) return;
+    this.signature = signature;
+    if (this.state?.sessionId !== state?.sessionId) {
+      if (this.state?.sessionId) this.sessions.set(this.state.sessionId, this.capturePresentation());
+      while (this.sessions.size > 64) this.sessions.delete(this.sessions.keys().next().value);
+      const saved = state?.sessionId ? this.sessions.get(state.sessionId) : void 0;
+      this.presentation = saved ? { open: saved.open, tasks: saved.tasks, notes: saved.notes, layers: saved.layers } : { open: true, tasks: true, notes: true, layers: true };
+      this.disclosures.clear();
+      if (saved) for (const [id, open] of Object.entries(saved.disclosures)) this.disclosures.set(id, open);
+    }
+    this.state = state;
+    this.visible = !!state;
+    const items = Array.isArray(state?.todos) ? state.todos.filter((item) => item && typeof item.id === "string" && typeof item.content === "string").slice(0, 512) : [];
+    const byId = new Map(items.map((item) => [item.id, item]));
+    const parents = /* @__PURE__ */ new Map();
+    for (const item of items) if (item.parentId && byId.has(item.parentId) && item.parentId !== item.id) {
+      let cursor = item.parentId;
+      const seen = /* @__PURE__ */ new Set([item.id]);
+      while (cursor && !seen.has(cursor)) {
+        seen.add(cursor);
+        cursor = byId.get(cursor)?.parentId;
+      }
+      if (!cursor) parents.set(item.id, item.parentId);
+    }
+    const ids = new Set(byId.keys());
+    for (const [id, row] of this.rows) if (ids.has(id) && row.root.parent !== this.taskBody) this.taskBody.add(row.root);
+    for (const [id, row] of this.rows) if (!ids.has(id)) {
+      row.root.destroyRecursively();
+      this.rows.delete(id);
+    }
+    for (const item of items) {
+      let row = this.rows.get(item.id);
+      if (!row) {
+        const root = column(this.renderer, `task:${item.id}`), children = column(this.renderer, `task:${item.id}:children`);
+        children.paddingLeft = 2;
+        const title = new Disclosure(this.renderer, `task:${item.id}:title`, () => {
+          const key = `task:${item.id}`;
+          this.disclosures.set(key, !(this.disclosures.get(key) ?? row.hasChildren));
+          this.refreshRow(row);
+        }, this.colors);
+        title.on(RenderableEvents3.FOCUSED, () => this.reveal?.(title));
+        const details = new TextRenderable4(this.renderer, { id: `task:${item.id}:metadata`, content: "", width: "100%", minWidth: 0, wrapMode: "word", flexShrink: 0, fg: this.colors.foreground, bg: this.colors.background, attributes: TextAttributes5.DIM });
+        const detailButton = new Disclosure(this.renderer, `task:${item.id}:details`, () => {
+          const key = `meta:${item.id}`;
+          this.disclosures.set(key, !this.disclosures.get(key));
+          this.refreshRow(row);
+        }, this.colors);
+        detailButton.on(RenderableEvents3.FOCUSED, () => this.reveal?.(detailButton));
+        root.add(title);
+        root.add(detailButton);
+        root.add(details);
+        root.add(children);
+        row = { item, root, title, detailButton, details, children, hasChildren: false };
+        this.rows.set(item.id, row);
+      }
+      row.item = item;
+      row.hasChildren = [...parents.values()].includes(item.id);
+      const parent = parents.get(item.id);
+      const target = parent ? this.rows.get(parent)?.children : this.taskBody;
+      (target ?? this.taskBody).add(row.root);
+      this.refreshRow(row);
+    }
+    for (const item of items) {
+      const parent = parents.get(item.id);
+      if (parent) this.rows.get(parent).children.add(this.rows.get(item.id).root);
+    }
+    const leaves = items.filter((item) => ![...parents.values()].includes(item.id));
+    this.taskLabel = `TASKS ${leaves.filter((item) => item.status === "completed").length}/${leaves.length}`;
+    this.scope.content = state ? `SESSION ${safe(state.sessionLabel || state.sessionId)}` : "";
+    this.warning.content = safe(state?.unavailable);
+    this.warning.visible = !!state?.unavailable;
+    this.updateNotes(Array.isArray(state?.notes) ? state.notes.slice(0, 256) : []);
+    this.updateLayers(Array.isArray(state?.layers) ? state.layers.slice(0, 64) : []);
+    const missingTasks = Math.max(0, (state?.omittedTasks || 0) + (Array.isArray(state?.todos) ? state.todos.length - items.length : 0));
+    const missingNotes = Math.max(0, (state?.omittedNotes || 0) + Math.max(0, (state?.notes?.length || 0) - 256));
+    this.omitted.content = [missingTasks ? `${missingTasks} more tasks omitted` : "", missingNotes ? `${missingNotes} more notes omitted` : ""].filter(Boolean).join("\n");
+    this.omitted.visible = missingTasks > 0 || missingNotes > 0;
+    this.applyPresentation();
+  }
+  refreshRow(row) {
+    const item = row.item, expanded = this.disclosures.get(`task:${item.id}`) ?? row.hasChildren;
+    const state = item.status === "blocked" ? " BLOCKED" : !["pending", "in_progress", "completed"].includes(item.status) ? " UNKNOWN" : "";
+    row.title.update(
+      `${taskMark(item, this.frame)} ${safe(item.status === "in_progress" && item.activeForm ? item.activeForm : item.content)}${state}`,
+      expanded,
+      item.status === "in_progress" || item.status === "blocked" ? TextAttributes5.BOLD : item.status === "pending" || item.status === "completed" ? TextAttributes5.DIM : 0
+    );
+    const detail = metadata(item), metaOpen = row.hasChildren ? this.disclosures.get(`meta:${item.id}`) === true : expanded;
+    row.details.content = detail;
+    row.details.visible = !!detail && metaOpen;
+    row.detailButton.visible = row.hasChildren && !!detail && expanded;
+    row.detailButton.update("DETAILS", metaOpen, TextAttributes5.DIM);
+    row.children.visible = expanded;
+    this.animation?.sync();
+  }
+  updateNotes(notes) {
+    const ids = new Set(notes.map((note) => String(note.id)));
+    for (const [id, row] of this.noteRows) if (!ids.has(id)) {
+      row.destroy();
+      this.noteRows.delete(id);
+    }
+    for (const [index, note] of notes.entries()) {
+      const id = String(note.id);
+      let row = this.noteRows.get(id);
+      if (!row) {
+        row = new TextRenderable4(this.renderer, { id: `note:${id}`, content: "", width: "100%", minWidth: 0, wrapMode: "word", flexShrink: 0, fg: this.colors.foreground, bg: this.colors.background });
+        this.noteRows.set(id, row);
+      }
+      const text = `□ ${safe(note.category).toUpperCase()} · ${safe(note.content)}${note.file ? `
+  ${safe(note.file)}${note.line ? `:${note.line}` : ""}` : ""}`;
+      if (row.plainText !== text) row.content = text;
+      if (this.noteBody.getChildren()[index] !== row) this.noteBody.add(row, index);
+    }
+    this.noteHeader.update(`NOTES ${notes.length} · ADVISORY`, this.presentation.notes);
+    this.noteHeader.visible = notes.length > 0;
+  }
+  updateLayers(layers) {
+    const ids = new Set(layers.map((layer) => safe(layer.id)));
+    for (const [id, row] of this.layerRows) if (!ids.has(id)) {
+      row.destroy();
+      this.layerRows.delete(id);
+    }
+    for (const [index, layer] of layers.entries()) {
+      const id = safe(layer.id);
+      let row = this.layerRows.get(id);
+      if (!row) {
+        row = new TextRenderable4(this.renderer, { id: `work-layer:${id}`, content: "", width: "100%", minWidth: 0, wrapMode: "word", flexShrink: 0, fg: this.colors.foreground, bg: this.colors.background });
+        this.layerRows.set(id, row);
+      }
+      const progress = typeof layer.progress === "number" && Number.isFinite(layer.progress) && layer.progress >= 0 && layer.progress <= 1 ? ` · ${Math.round(layer.progress * 100)}%` : "";
+      const text = `□ ${safe(layer.label)} · ${layerStatus(layer)}${progress}${layer.detail ? `
+  ${safe(layer.detail)}` : ""}${lines(layer.references).length ? `
+  REF ${lines(layer.references).join(", ")}` : ""}`;
+      if (row.plainText !== text) row.content = text;
+      if (this.layerBody.getChildren()[index] !== row) this.layerBody.add(row, index);
+    }
+    this.layerHeader.visible = layers.length > 0;
+  }
+  applyPresentation() {
+    this.header.update("TASKS / NOTES", this.presentation.open);
+    this.body.visible = this.presentation.open;
+    this.taskBody.visible = this.presentation.tasks;
+    this.taskHeader.update(this.taskLabel, this.presentation.tasks);
+    this.noteBody.visible = this.presentation.notes;
+    this.noteHeader.update(`NOTES ${this.noteRows.size} · ADVISORY`, this.presentation.notes);
+    this.layerBody.visible = this.presentation.layers;
+    this.layerHeader.update("RECORDED ORCHESTRATION", this.presentation.layers);
+    this.animation.sync();
+  }
+  inspect(id) {
+    this.presentation.open = this.presentation.tasks = true;
+    if (id) {
+      const row = this.rows.get(id);
+      let parent = row?.item.parentId;
+      const seen = /* @__PURE__ */ new Set();
+      while (parent && !seen.has(parent)) {
+        seen.add(parent);
+        this.disclosures.set(`task:${parent}`, true);
+        const ancestor = this.rows.get(parent);
+        if (ancestor) this.refreshRow(ancestor);
+        parent = ancestor?.item.parentId;
+      }
+    }
+    this.applyPresentation();
+    const target = id ? this.rows.get(id)?.title : this.header;
+    target?.focus();
+    this.pendingInspect = id ?? "";
+    this.renderer.requestRender();
+  }
+  finishInspect = () => {
+    if (this.pendingInspect === void 0) return;
+    const target = this.pendingInspect ? this.rows.get(this.pendingInspect)?.title : this.header;
+    this.pendingInspect = void 0;
+    if (target) {
+      this.reveal?.(target);
+      this.renderer.requestRender();
+    }
+  };
+  capturePresentation() {
+    return { ...this.presentation, disclosures: Object.fromEntries([...this.disclosures].slice(-2048)) };
+  }
+  restorePresentation(state) {
+    if (!state) return;
+    this.presentation = { open: state.open, tasks: state.tasks, notes: state.notes, layers: state.layers };
+    this.disclosures.clear();
+    for (const [id, open] of Object.entries(state.disclosures)) this.disclosures.set(id, open);
+    for (const row of this.rows.values()) this.refreshRow(row);
+    this.applyPresentation();
+  }
+  focusTargets() {
+    const targets = [];
+    const visit = (node) => {
+      if (!node.visible) return;
+      if (node instanceof TextRenderable4 && node.focusable) targets.push(node);
+      for (const child of node.getChildren()) visit(child);
+    };
+    if (this.visible) visit(this);
+    return targets;
+  }
+  applyTheme(colors) {
+    this.colors = colors;
+    const visit = (node) => {
+      if (node instanceof TextRenderable4) {
+        node.fg = colors.foreground;
+        node.bg = colors.background;
+      }
+      for (const child of node.getChildren()) visit(child);
+    };
+    visit(this);
+  }
+  destroySelf() {
+    this.animation.destroy();
+    this.renderer.off(CliRenderEvents3.FRAME, this.finishInspect);
+    super.destroySelf();
+  }
+};
+var NativeTaskStrip = class extends BoxRenderable5 {
+  constructor(renderer2, colors, inspect) {
+    super(renderer2, {
+      id: "omnius-task-strip",
+      width: "100%",
+      minWidth: 0,
+      height: 3,
+      minHeight: 3,
+      maxHeight: 3,
+      flexShrink: 0,
+      border: true,
+      borderStyle: "single",
+      borderColor: colors.border,
+      flexDirection: "row",
+      visible: false
+    });
+    this.renderer = renderer2;
+    this.colors = colors;
+    this.inspect = inspect;
+    this.label = new TextRenderable4(renderer2, {
+      id: "omnius-task-strip:heading",
+      content: "TASKS ",
+      height: 1,
+      width: 6,
+      flexShrink: 0,
+      selectable: false,
+      fg: colors.foreground,
+      bg: colors.background,
+      attributes: TextAttributes5.BOLD,
+      onMouseDown: (event) => {
+        if (event.button === 0) {
+          inspect();
+          event.preventDefault();
+          event.stopPropagation();
+        }
+      },
+      onKeyDown: (key) => {
+        if (key.eventType !== "release" && (key.name === "return" || key.sequence === " ")) {
+          inspect();
+          key.preventDefault();
+          key.stopPropagation();
+        }
+      }
+    });
+    this.label.focusable = true;
+    this.add(this.label);
+    this.scroll = new ScrollBoxRenderable3(renderer2, {
+      id: "omnius-task-strip:scroll",
+      height: 1,
+      minHeight: 1,
+      maxHeight: 1,
+      minWidth: 0,
+      flexGrow: 1,
+      scrollX: true,
+      scrollY: false,
+      viewportOptions: { height: 1, minHeight: 1, maxHeight: 1, flexGrow: 0, flexShrink: 0 },
+      contentOptions: { flexDirection: "row", gap: 3 },
+      horizontalScrollbarOptions: { visible: false },
+      verticalScrollbarOptions: { visible: false }
+    });
+    this.scroll.horizontalScrollBar.visible = this.scroll.verticalScrollBar.visible = false;
+    this.add(this.scroll);
+    styleNativeScrollbars(this.scroll, colors);
+    this.animation = new ActiveBlocks(renderer2, () => [...this.chips.values()].some((chip) => chip.item.status === "in_progress" && visible(chip.label, renderer2)), (mark) => {
+      this.frame = mark;
+      for (const chip of this.chips.values()) if (chip.item.status === "in_progress" && visible(chip.label, renderer2)) this.refreshChip(chip);
+    });
+  }
+  renderer;
+  colors;
+  inspect;
+  scroll;
+  label;
+  chips = /* @__PURE__ */ new Map();
+  animation;
+  frame = marks[0];
+  sessionId;
+  signature = "";
+  hasItems = false;
+  get animating() {
+    return this.animation.running;
+  }
+  update(state) {
+    const signature = JSON.stringify(state);
+    if (signature === this.signature) return;
+    this.signature = signature;
+    const source = Array.isArray(state?.todos) ? state.todos.filter((item) => item && typeof item.id === "string" && typeof item.content === "string").slice(0, 512) : [];
+    const parents = new Set(source.map((item) => item.parentId).filter(Boolean));
+    const children = /* @__PURE__ */ new Map();
+    for (const item of source) if (item.parentId) {
+      const list = children.get(item.parentId) ?? [];
+      list.push(item);
+      children.set(item.parentId, list);
+    }
+    const busy = (item) => item.status === "in_progress" || item.status === "blocked";
+    const activeDescendant = (id) => {
+      const seen = /* @__PURE__ */ new Set([id]), stack = [...children.get(id) ?? []];
+      while (stack.length) {
+        const item = stack.pop();
+        if (seen.has(item.id)) continue;
+        seen.add(item.id);
+        if (busy(item)) return true;
+        stack.push(...children.get(item.id) ?? []);
+      }
+      return false;
+    };
+    let leaves = source.filter((item) => item.status !== "completed" && (!parents.has(item.id) || busy(item) && !activeDescendant(item.id)));
+    if (!leaves.length) leaves = source.filter((item) => item.status !== "completed");
+    const items = [leaves.filter((item) => item.status === "in_progress"), leaves.filter((item) => item.status === "blocked"), leaves.filter((item) => item.status !== "in_progress" && item.status !== "blocked")].flat();
+    const ids = new Set(items.map((item) => item.id));
+    const wasFirst = this.scroll.getChildren()[0]?.id;
+    for (const [id, chip] of this.chips) if (!ids.has(id)) {
+      chip.label.destroy();
+      this.chips.delete(id);
+    }
+    for (const [index, item] of items.entries()) {
+      let chip = this.chips.get(item.id);
+      if (!chip) {
+        const label2 = new TextRenderable4(this.renderer, {
+          id: `task-strip:${item.id}`,
+          content: "",
+          height: 1,
+          flexShrink: 0,
+          wrapMode: "none",
+          selectable: false,
+          fg: this.colors.foreground,
+          bg: this.colors.background,
+          onMouseDown: (event) => {
+            if (event.button === 0) {
+              label2.focus();
+              this.inspect(item.id);
+              event.preventDefault();
+              event.stopPropagation();
+            }
+          },
+          onKeyDown: (key) => {
+            if (key.eventType === "release") return;
+            if (key.name === "return" || key.sequence === " ") this.inspect(item.id);
+            else if (["left", "right", "home", "end"].includes(key.name)) {
+              const targets = this.scroll.getChildren();
+              const index2 = targets.indexOf(label2);
+              const next = key.name === "home" ? 0 : key.name === "end" ? targets.length - 1 : Math.max(0, Math.min(targets.length - 1, index2 + (key.name === "left" ? -1 : 1)));
+              targets[next]?.focus();
+              if (targets[next]) this.scroll.scrollChildIntoView(targets[next].id);
+            } else return;
+            key.preventDefault();
+            key.stopPropagation();
+          }
+        });
+        label2.focusable = true;
+        chip = { item, label: label2 };
+        this.chips.set(item.id, chip);
+        label2.on(RenderableEvents3.FOCUSED, () => {
+          this.refreshChip(chip);
+          this.scroll.scrollChildIntoView(label2.id);
+        });
+        label2.on(RenderableEvents3.BLURRED, () => this.refreshChip(chip));
+      }
+      chip.item = item;
+      this.refreshChip(chip);
+      if (this.scroll.getChildren()[index] !== chip.label) this.scroll.add(chip.label, index);
+    }
+    this.label.content = state ? fitInstrumentText(safe(state.sessionLabel || state.sessionId).toUpperCase(), 12) + " TASKS " : "TASKS ";
+    this.label.width = terminalCellWidth(this.label.plainText);
+    if (this.sessionId !== state?.sessionId || wasFirst !== this.scroll.getChildren()[0]?.id) this.scroll.scrollTo({ x: 0, y: 0 });
+    this.sessionId = state?.sessionId;
+    this.visible = this.hasItems = items.length > 0;
+    this.animation.sync();
+  }
+  refreshChip(chip) {
+    const item = chip.item;
+    const title = safe(item.status === "in_progress" && item.activeForm ? item.activeForm : item.content).replace(/\s+/g, " ");
+    const content = `${taskMark(item, this.frame)} ${fitInstrumentText(title, 34)}${item.status === "blocked" ? " BLOCKED" : ""}`;
+    if (chip.label.plainText !== content) chip.label.content = content;
+    chip.label.attributes = (item.status === "in_progress" || item.status === "blocked" ? TextAttributes5.BOLD : TextAttributes5.DIM) | (chip.label.focused ? TextAttributes5.INVERSE : 0);
+  }
+  applyTheme(colors) {
+    this.colors = colors;
+    this.borderColor = colors.border;
+    this.label.fg = colors.foreground;
+    this.label.bg = colors.background;
+    for (const chip of this.chips.values()) {
+      chip.label.fg = colors.foreground;
+      chip.label.bg = colors.background;
+    }
+    styleNativeScrollbars(this.scroll, colors);
+  }
+  reconcile() {
+    this.animation.sync();
+  }
+  destroySelf() {
+    this.animation.destroy();
+    super.destroySelf();
+  }
+};
+
+// packages/cli/src/tui/native/components/work-queue.ts
+import {
+  BoxRenderable as BoxRenderable6,
+  CliRenderEvents as CliRenderEvents4,
+  RenderableEvents as RenderableEvents4,
+  ScrollBoxRenderable as ScrollBoxRenderable4,
+  TextAttributes as TextAttributes6,
+  TextRenderable as TextRenderable5
+} from "@opentui/core";
+var frames = ["▨", "▧", "▥", "▦"];
+var actionLabels = { queue: "QUEUE", apply: "APPLY", override: "OVERRIDE", cancel: "CANCEL", retry: "RETRY", up: "UP", down: "DOWN" };
+var safe2 = (value) => typeof value === "string" ? plainText(value) : "";
+var label = (value) => safe2(value).replace(/[\r\n\t]+/g, " ");
+var reducedMotion2 = () => process.env["OMNIUS_TUI_REDUCE_MOTION"] === "1" || process.env["REDUCE_MOTION"] === "1";
+var column2 = (renderer2, id) => new BoxRenderable6(renderer2, { id, width: "100%", minWidth: 0, flexDirection: "column", flexShrink: 0 });
+var historyStates = /* @__PURE__ */ new Set(["completed", "applied", "failed", "cancelled"]);
+var activeStates = /* @__PURE__ */ new Set(["claiming", "running", "admitted"]);
+var receiptTime = (at) => {
+  const date = new Date(typeof at === "number" ? at : NaN);
+  return Number.isFinite(date.getTime()) ? date.toISOString() : "";
+};
+var WorkControl = class extends TextRenderable5 {
+  constructor(renderer2, id, activate, colors, disclosure = false, ruled = false, fixedWidth) {
+    super(renderer2, {
+      id,
+      content: "",
+      width: fixedWidth ?? "100%",
+      minWidth: 0,
+      height: 1,
+      flexShrink: 0,
+      wrapMode: "none",
+      truncate: true,
+      fg: colors.foreground,
+      bg: colors.background,
+      selectable: false,
+      onMouseDown: (event) => {
+        if (event.button === 0) {
+          this.focus();
+          activate();
+          event.preventDefault();
+          event.stopPropagation();
+        }
+      },
+      onKeyDown: (key) => {
+        if (key.eventType !== "release" && (key.name === "return" || key.sequence === " " || disclosure && (key.name === "right" && !this.open || key.name === "left" && this.open))) {
+          activate();
+          key.preventDefault();
+          key.stopPropagation();
+        }
+      }
+    });
+    this.activate = activate;
+    this.disclosure = disclosure;
+    this.ruled = ruled;
+    this.focusable = true;
+    this.on(RenderableEvents4.FOCUSED, this.style);
+    this.on(RenderableEvents4.BLURRED, this.style);
+  }
+  activate;
+  disclosure;
+  ruled;
+  open = false;
+  caption = "";
+  base = 0;
+  update(caption, open = false, attributes = 0) {
+    this.caption = caption;
+    this.open = open;
+    this.base = attributes;
+    this.refresh();
+    this.style();
+  }
+  style = () => {
+    this.attributes = this.base | (this.focused ? TextAttributes6.INVERSE : 0);
+  };
+  onResize(width, height) {
+    super.onResize(width, height);
+    this.refresh();
+  }
+  refresh() {
+    const value = this.ruled ? formatSectionBanner(this.caption, this.width, this.open) : fitInstrumentText(`${this.disclosure ? this.open ? "− " : "+ " : ""}${this.caption}`, this.width);
+    if (this.plainText !== value) this.content = value;
+  }
+};
+var NativeWorkQueueView = class extends BoxRenderable6 {
+  constructor(renderer2, colors, onAction, reveal) {
+    super(renderer2, { id: "omnius-work-queue", width: "100%", minWidth: 0, flexDirection: "column", flexShrink: 0, visible: false });
+    this.renderer = renderer2;
+    this.colors = colors;
+    this.onAction = onAction;
+    this.reveal = reveal;
+    this.header = this.control("omnius-work-queue:heading", () => {
+      this.presentation.open = !this.presentation.open;
+      this.applyPresentation();
+    }, true, true);
+    this.add(this.header);
+    this.body = column2(renderer2, "omnius-work-queue:body");
+    this.add(this.body);
+    this.scope = this.text("omnius-work-queue:scope", TextAttributes6.DIM);
+    this.body.add(this.scope);
+    this.warning = this.text("omnius-work-queue:warning", TextAttributes6.BOLD);
+    this.body.add(this.warning);
+    for (const group of ["current", "intake", "upcoming", "held"]) {
+      const heading = this.text(`omnius-work-queue:${group}:heading`, TextAttributes6.DIM | TextAttributes6.BOLD);
+      const body = column2(renderer2, `omnius-work-queue:${group}`);
+      this.groups.set(group, { heading, body });
+      this.body.add(heading);
+      this.body.add(body);
+    }
+    this.historyHeader = this.control("omnius-work-queue:history:heading", () => {
+      this.presentation.history = !this.presentation.history;
+      this.applyPresentation();
+    }, true);
+    const history = column2(renderer2, "omnius-work-queue:history");
+    this.groups.set("history", { heading: this.historyHeader, body: history });
+    this.body.add(this.historyHeader);
+    this.body.add(history);
+    this.empty = this.text("omnius-work-queue:empty", TextAttributes6.DIM);
+    this.empty.content = "No pending work.";
+    this.body.add(this.empty);
+    this.omitted = this.text("omnius-work-queue:omitted", TextAttributes6.DIM);
+    this.body.add(this.omitted);
+    renderer2.on(CliRenderEvents4.FRAME, this.syncAnimation);
+  }
+  renderer;
+  colors;
+  onAction;
+  reveal;
+  header;
+  body;
+  historyHeader;
+  scope;
+  warning;
+  empty;
+  omitted;
+  groups = /* @__PURE__ */ new Map();
+  rows = /* @__PURE__ */ new Map();
+  sessions = /* @__PURE__ */ new Map();
+  state;
+  signature = "";
+  presentation = { open: true, history: false, disclosures: {} };
+  timer;
+  frame = 0;
+  disposed = false;
+  text(id, attributes = 0) {
+    return new TextRenderable5(this.renderer, { id, content: "", width: "100%", minWidth: 0, flexShrink: 0, wrapMode: "word", fg: this.colors.foreground, bg: this.colors.background, attributes });
+  }
+  control(id, activate, disclosure = false, ruled = false, width) {
+    const node = new WorkControl(this.renderer, id, activate, this.colors, disclosure, ruled, width);
+    node.on(RenderableEvents4.FOCUSED, () => this.reveal?.(node));
+    return node;
+  }
+  get animating() {
+    return this.timer !== void 0;
+  }
+  update(state) {
+    if (state && state === this.state) return;
+    const signature = JSON.stringify(state);
+    if (signature === this.signature) return;
+    this.signature = signature;
+    const scope = (value) => value ? `${value.projectRoot}\0${value.sessionId}` : "";
+    if (scope(state) !== scope(this.state)) {
+      if (this.state) this.sessions.set(scope(this.state), this.capturePresentation());
+      while (this.sessions.size > 64) this.sessions.delete(this.sessions.keys().next().value);
+      this.presentation = structuredClone(this.sessions.get(scope(state)) ?? { open: true, history: false, disclosures: {} });
+      for (const row of this.rows.values()) row.root.destroy();
+      this.rows.clear();
+    }
+    this.state = state;
+    this.visible = Boolean(state);
+    if (!state) {
+      this.syncAnimation();
+      return;
+    }
+    this.scope.content = `SESSION ${label(state.sessionLabel || state.sessionId)}`;
+    this.warning.content = safe2(state.unavailable);
+    this.warning.visible = Boolean(state.unavailable);
+    const items = state.items.filter((item) => item && typeof item.id === "string"), ids = new Set(items.map((item) => item.id));
+    for (const [id, row] of this.rows) if (!ids.has(id)) {
+      row.root.destroy();
+      this.rows.delete(id);
+      delete this.presentation.disclosures[id];
+    }
+    const order = (a, b) => a.order - b.order || a.id.localeCompare(b.id);
+    const groups = { current: [], intake: [], upcoming: [], held: [], history: [] };
+    for (const item of items) {
+      const group = item.id === state.activeId || activeStates.has(item.state) ? "current" : historyStates.has(item.state) ? "history" : item.state === "needs_review" || item.state === "interrupted" ? "held" : item.state === "reviewing" || item.state === "received" ? "intake" : "upcoming";
+      groups[group].push(item);
+    }
+    groups.current.sort((a, b) => Number(b.id === state.activeId) - Number(a.id === state.activeId) || order(a, b));
+    groups.intake.sort(order);
+    groups.upcoming.sort(order);
+    groups.held.sort(order);
+    groups.history.sort((a, b) => (b.receivedAt ?? 0) - (a.receivedAt ?? 0) || order(a, b));
+    const titles = { current: "CURRENT", intake: "INTAKE", upcoming: "QUEUED", held: "HELD / REVIEW", history: "HISTORY" };
+    for (const group of ["current", "intake", "upcoming", "held", "history"]) {
+      const target = this.groups.get(group);
+      target.heading.visible = groups[group].length > 0;
+      target.body.visible = groups[group].length > 0;
+      if (group !== "history") target.heading.content = `${titles[group]} ${groups[group].length}`;
+      for (const [index, item] of groups[group].entries()) {
+        const row = this.rows.get(item.id) ?? this.createRow(item);
+        row.item = item;
+        row.position = group === "upcoming" ? index + 1 : void 0;
+        this.refreshRow(row);
+        if (row.root.parent !== target.body || target.body.getChildren()[index] !== row.root) target.body.add(row.root, index);
+      }
+    }
+    this.empty.visible = items.length === 0 && !state.unavailable;
+    this.omitted.content = state.omitted ? `${state.omitted} more work items omitted` : "";
+    this.omitted.visible = Boolean(state.omitted);
+    this.applyPresentation();
+  }
+  createRow(item) {
+    const id = `work:${item.id}`, root = column2(this.renderer, id);
+    const title = this.control(`${id}:title`, () => {
+      this.presentation.disclosures[item.id] = !this.presentation.disclosures[item.id];
+      this.refreshRow(this.rows.get(item.id));
+      this.renderer.requestRender();
+    }, true);
+    root.add(title);
+    const details = column2(this.renderer, `${id}:details`);
+    details.paddingLeft = 2;
+    root.add(details);
+    const metadata2 = this.text(`${id}:metadata`, TextAttributes6.DIM), original = this.text(`${id}:original`);
+    details.add(original);
+    details.add(metadata2);
+    const controls = new BoxRenderable6(this.renderer, { id: `${id}:actions`, width: "100%", minWidth: 0, flexDirection: "row", flexWrap: "wrap", flexShrink: 0 });
+    details.add(controls);
+    const row = { item, root, title, details, original, metadata: metadata2, controls, actions: /* @__PURE__ */ new Map() };
+    this.rows.set(item.id, row);
+    return row;
+  }
+  refreshRow(row) {
+    const item = row.item, open = this.presentation.disclosures[item.id] === true;
+    const state = label(item.state).replace(/_/g, " ").toUpperCase();
+    const mark = item.state === "reviewing" || item.state === "claiming" ? frames[this.frame % frames.length] : item.state === "running" ? "▨" : item.state === "needs_review" || item.state === "interrupted" ? "▣" : historyStates.has(item.state) ? "■" : "□";
+    row.title.update(
+      `${mark} ${row.position === void 0 ? "" : `${row.position}. `}${state} · ${label(item.title) || "Untitled request"}`,
+      open,
+      item.state === "queued" ? TextAttributes6.DIM : item.state === "running" || item.state === "needs_review" ? TextAttributes6.BOLD : 0
+    );
+    row.details.visible = open;
+    const original = `ORIGINAL
+${safe2(item.originalText)}`;
+    if (row.original.plainText !== original) row.original.content = original;
+    const metadata2 = [
+      item.source ? `SOURCE ${label(item.source)}` : "",
+      `PROJECT ${safe2(this.state?.projectRoot)}`,
+      item.parentWorkId ? `PARENT ${label(item.parentWorkId)}` : "",
+      item.runId ? `RUN ${label(item.runId)}` : "",
+      ...(item.attachments ?? []).map((attachment) => [`ATTACHMENT ${label(attachment.kind)} · ${label(attachment.label)}`, attachment.path ? `PATH ${safe2(attachment.path)}` : "", attachment.reference ? `REFERENCE ${safe2(attachment.reference)}` : "", attachment.mimeType ? `MIME ${label(attachment.mimeType)}` : ""].filter(Boolean).join("\n")),
+      ...item.review ? [`RECOMMENDATION ${label(item.review.disposition).replace(/_/g, " ")}`, item.review.summary ? `SUMMARY ${safe2(item.review.summary)}` : "", item.review.rationale ? `RATIONALE ${safe2(item.review.rationale)}` : "", item.review.relationship ? `RELATIONSHIP ${safe2(item.review.relationship)}` : "", ...(item.review.questions ?? []).map((question) => `QUESTION ${safe2(question)}`)] : [],
+      ...(item.receipts ?? []).map((receipt) => `RECEIPT ${label(receipt.kind).replace(/_/g, " ")}${receiptTime(receipt.at) ? ` · ${receiptTime(receipt.at)}` : ""}${receipt.message ? `
+${safe2(receipt.message)}` : ""}${receipt.runId ? `
+RUN ${label(receipt.runId)}` : ""}`)
+    ].filter(Boolean).join("\n");
+    if (row.metadata.plainText !== metadata2) row.metadata.content = metadata2;
+    const allowed = [...new Set(item.actions ?? [])].filter((action) => Object.hasOwn(actionLabels, action));
+    for (const [action, button] of row.actions) if (!allowed.includes(action)) {
+      button.destroy();
+      row.actions.delete(action);
+    }
+    for (const [index, action] of allowed.entries()) {
+      let button = row.actions.get(action);
+      if (!button) {
+        button = this.control(`work:${item.id}:action:${action}`, () => this.dispatch(item.id, action), false, false, terminalCellWidth(actionLabels[action]) + 2);
+        button.update(`[${actionLabels[action]}]`);
+        row.actions.set(action, button);
+      }
+      if (row.controls.getChildren()[index] !== button) row.controls.add(button, index);
+    }
+    row.controls.visible = allowed.length > 0;
+  }
+  dispatch(id, action) {
+    const item = this.rows.get(id)?.item, state = this.state;
+    if (!state || !item?.actions?.includes(action)) return;
+    this.onAction?.({ type: "work-action", action, id, expectedRevision: item.revision, expectedQueueRevision: state.revision, sessionId: state.sessionId, projectRoot: state.projectRoot });
+  }
+  applyPresentation() {
+    const count = this.state?.items.filter((item) => !historyStates.has(item.state)).length ?? 0;
+    this.header.update(`WORK / QUEUE ${count}`, this.presentation.open, TextAttributes6.BOLD);
+    this.body.visible = this.presentation.open;
+    const history = this.groups.get("history");
+    this.historyHeader.update(`HISTORY ${history.body.getChildren().length}`, this.presentation.history, TextAttributes6.DIM);
+    history.body.visible = history.body.getChildren().length > 0 && this.presentation.history;
+    this.syncAnimation();
+    this.renderer.requestRender();
+  }
+  isVisible(node) {
+    if (node.width < 1 || node.height < 1 || node.y >= this.renderer.terminalHeight || node.y + node.height <= 0) return false;
+    for (let ancestor = node; ancestor; ancestor = ancestor.parent) {
+      if (!ancestor.visible) return false;
+      if (ancestor instanceof ScrollBoxRenderable4 && (node.y + node.height <= ancestor.viewport.y || node.y >= ancestor.viewport.y + ancestor.viewport.height)) return false;
+    }
+    return true;
+  }
+  syncAnimation = () => {
+    const active = !this.disposed && !reducedMotion2() && [...this.rows.values()].some((row) => ["reviewing", "claiming"].includes(row.item.state) && this.isVisible(row.title));
+    if (active && !this.timer) {
+      this.timer = setInterval(() => {
+        if (reducedMotion2() || ![...this.rows.values()].some((row) => ["reviewing", "claiming"].includes(row.item.state) && this.isVisible(row.title))) {
+          this.syncAnimation();
+          return;
+        }
+        this.frame++;
+        for (const row of this.rows.values()) if (["reviewing", "claiming"].includes(row.item.state) && this.isVisible(row.title)) this.refreshTitle(row);
+      }, 250);
+      this.timer.unref?.();
+    } else if (!active && this.timer) {
+      clearInterval(this.timer);
+      this.timer = void 0;
+    }
+  };
+  refreshTitle(row) {
+    row.title.update(`${frames[this.frame % frames.length]} ${row.position === void 0 ? "" : `${row.position}. `}${label(row.item.state).toUpperCase()} · ${label(row.item.title) || "Untitled request"}`, this.presentation.disclosures[row.item.id] === true);
+  }
+  capturePresentation() {
+    return { open: this.presentation.open, history: this.presentation.history, disclosures: Object.fromEntries(Object.entries(this.presentation.disclosures).slice(-2048)) };
+  }
+  restorePresentation(state) {
+    if (!state) return;
+    this.presentation = { open: state.open, history: state.history, disclosures: { ...state.disclosures } };
+    for (const row of this.rows.values()) this.refreshRow(row);
+    this.applyPresentation();
+  }
+  focusTargets() {
+    const targets = [];
+    const visit = (node) => {
+      if (!node.visible) return;
+      if (node instanceof TextRenderable5 && node.focusable) targets.push(node);
+      for (const child of node.getChildren()) visit(child);
+    };
+    if (this.visible) visit(this);
+    return targets;
+  }
+  applyTheme(colors) {
+    this.colors = colors;
+    const visit = (node) => {
+      if (node instanceof TextRenderable5) {
+        node.fg = colors.foreground;
+        node.bg = colors.background;
+      }
+      for (const child of node.getChildren()) visit(child);
+    };
+    visit(this);
+  }
+  destroySelf() {
+    this.disposed = true;
+    if (this.timer) clearInterval(this.timer);
+    this.timer = void 0;
+    this.renderer.off(CliRenderEvents4.FRAME, this.syncAnimation);
+    super.destroySelf();
+  }
+};
+
 // packages/cli/src/tui/native/components/instruments.ts
 var foreground = RGBA2.defaultForeground();
 var background = RGBA2.defaultBackground();
-var SectionBanner = class extends TextRenderable4 {
+var SectionBanner = class extends TextRenderable6 {
   constructor(renderer2, title, id, activate) {
     super(renderer2, {
       id,
@@ -2466,7 +3472,7 @@ var SectionBanner = class extends TextRenderable4 {
       flexShrink: 0,
       fg: foreground,
       bg: background,
-      attributes: TextAttributes5.BOLD,
+      attributes: TextAttributes7.BOLD,
       selectable: false,
       wrapMode: "none",
       truncate: true,
@@ -2487,11 +3493,11 @@ var SectionBanner = class extends TextRenderable4 {
     this.activate = activate;
     this.heading = title;
     this.focusable = true;
-    this.on(RenderableEvents3.FOCUSED, () => {
-      this.attributes = TextAttributes5.BOLD | TextAttributes5.INVERSE;
+    this.on(RenderableEvents5.FOCUSED, () => {
+      this.attributes = TextAttributes7.BOLD | TextAttributes7.INVERSE;
     });
-    this.on(RenderableEvents3.BLURRED, () => {
-      this.attributes = TextAttributes5.BOLD;
+    this.on(RenderableEvents5.BLURRED, () => {
+      this.attributes = TextAttributes7.BOLD;
     });
   }
   activate;
@@ -2511,8 +3517,8 @@ var SectionBanner = class extends TextRenderable4 {
     if (this.plainText !== next) this.content = next;
   }
 };
-var TelemetryRow = class extends TextRenderable4 {
-  constructor(renderer2, label, id, reserved = 12) {
+var TelemetryRow = class extends TextRenderable6 {
+  constructor(renderer2, label2, id, reserved = 12) {
     super(renderer2, {
       id,
       content: "",
@@ -2525,7 +3531,7 @@ var TelemetryRow = class extends TextRenderable4 {
       truncate: true
     });
     this.reserved = reserved;
-    this.label = label;
+    this.label = label2;
   }
   reserved;
   label;
@@ -2534,8 +3540,8 @@ var TelemetryRow = class extends TextRenderable4 {
     super.onResize(width, height);
     this.refresh();
   }
-  update(value, label = this.label) {
-    this.label = label;
+  update(value, label2 = this.label) {
+    this.label = label2;
     this.value = value;
     this.refresh();
   }
@@ -2550,14 +3556,14 @@ var TelemetryRow = class extends TextRenderable4 {
   }
 };
 var SignalMeter = class extends TelemetryRow {
-  constructor(renderer2, label, id) {
-    super(renderer2, label, id, 18);
+  constructor(renderer2, label2, id) {
+    super(renderer2, label2, id, 18);
   }
   updateReading(value, maximum) {
     this.update(formatSignalMeter(value, maximum));
   }
 };
-var InstrumentDivider = class extends TextRenderable4 {
+var InstrumentDivider = class extends TextRenderable6 {
   constructor(renderer2, actions) {
     super(renderer2, {
       id: "omnius-instrument-divider",
@@ -2571,14 +3577,14 @@ var InstrumentDivider = class extends TextRenderable4 {
       bg: background,
       selectable: false,
       wrapMode: "none",
-      attributes: TextAttributes5.DIM,
+      attributes: TextAttributes7.DIM,
       onMouseDown: (event) => {
         if (event.button !== 0) return;
         this.held = true;
         this.moved = false;
         this.startX = event.x;
         this.actions.start?.();
-        this.attributes = TextAttributes5.BOLD;
+        this.attributes = TextAttributes7.BOLD;
         event.preventDefault();
         event.stopPropagation();
       },
@@ -2592,10 +3598,10 @@ var InstrumentDivider = class extends TextRenderable4 {
         this.handleRelease(event);
       },
       onMouseOver: () => {
-        this.attributes = TextAttributes5.BOLD;
+        this.attributes = TextAttributes7.BOLD;
       },
       onMouseOut: () => {
-        if (!this.held) this.attributes = this.focused ? TextAttributes5.INVERSE : TextAttributes5.DIM;
+        if (!this.held) this.attributes = this.focused ? TextAttributes7.INVERSE : TextAttributes7.DIM;
       },
       onKeyDown: (key) => {
         if (key.eventType === "release") return;
@@ -2608,11 +3614,11 @@ var InstrumentDivider = class extends TextRenderable4 {
     });
     this.actions = actions;
     this.focusable = true;
-    this.on(RenderableEvents3.FOCUSED, () => {
-      this.attributes = TextAttributes5.INVERSE;
+    this.on(RenderableEvents5.FOCUSED, () => {
+      this.attributes = TextAttributes7.INVERSE;
     });
-    this.on(RenderableEvents3.BLURRED, () => {
-      this.attributes = TextAttributes5.DIM;
+    this.on(RenderableEvents5.BLURRED, () => {
+      this.attributes = TextAttributes7.DIM;
     });
   }
   actions;
@@ -2646,28 +3652,28 @@ var InstrumentDivider = class extends TextRenderable4 {
     const text = rows.join("\n");
     if (this.plainText !== text) this.content = text;
   }
-  release(column) {
-    if (this.moved) this.actions.resize(column);
+  release(column3) {
+    if (this.moved) this.actions.resize(column3);
     else this.actions.toggle();
     this.held = false;
     this.actions.finish?.();
-    this.attributes = this.focused ? TextAttributes5.INVERSE : TextAttributes5.DIM;
+    this.attributes = this.focused ? TextAttributes7.INVERSE : TextAttributes7.DIM;
   }
 };
-var DeviceMonitor = class extends BoxRenderable5 {
+var DeviceMonitor = class extends BoxRenderable7 {
   constructor(renderer2, action) {
     super(renderer2, { id: "omnius-devices", width: "100%", height: 5, minHeight: 5, maxHeight: "60%", flexShrink: 1, flexDirection: "column", visible: false });
     this.action = action;
     this.heading = new SectionBanner(renderer2, "DEVICES", "omnius-devices:heading", () => this.toggle());
     this.heading.update("DEVICES", false);
     this.add(this.heading);
-    this.summary = new TextRenderable4(renderer2, { id: "omnius-devices:summary", content: "--", width: "100%", height: 1, flexShrink: 0, fg: foreground, bg: background, wrapMode: "none", truncate: true });
+    this.summary = new TextRenderable6(renderer2, { id: "omnius-devices:summary", content: "--", width: "100%", height: 1, flexShrink: 0, fg: foreground, bg: background, wrapMode: "none", truncate: true });
     this.add(this.summary);
-    this.compactLoad = new TextRenderable4(renderer2, { id: "omnius-devices:load-history", content: "", width: "100%", height: 1, flexShrink: 0, fg: foreground, bg: background, wrapMode: "none", truncate: true });
-    this.compactMemory = new TextRenderable4(renderer2, { id: "omnius-devices:memory-history", content: "", width: "100%", height: 1, flexShrink: 0, fg: foreground, bg: background, wrapMode: "none", truncate: true });
+    this.compactLoad = new TextRenderable6(renderer2, { id: "omnius-devices:load-history", content: "", width: "100%", height: 1, flexShrink: 0, fg: foreground, bg: background, wrapMode: "none", truncate: true });
+    this.compactMemory = new TextRenderable6(renderer2, { id: "omnius-devices:memory-history", content: "", width: "100%", height: 1, flexShrink: 0, fg: foreground, bg: background, wrapMode: "none", truncate: true });
     this.add(this.compactLoad);
     this.add(this.compactMemory);
-    this.scroll = new ScrollBoxRenderable3(renderer2, {
+    this.scroll = new ScrollBoxRenderable5(renderer2, {
       id: "omnius-devices:scroll",
       width: "100%",
       flexGrow: 1,
@@ -2682,7 +3688,7 @@ var DeviceMonitor = class extends BoxRenderable5 {
       contentOptions: { flexDirection: "column" }
     });
     this.add(this.scroll);
-    this.notes = new TextRenderable4(renderer2, {
+    this.notes = new TextRenderable6(renderer2, {
       id: "omnius-devices:notes",
       content: "",
       width: "100%",
@@ -2694,7 +3700,7 @@ var DeviceMonitor = class extends BoxRenderable5 {
       truncate: true
     });
     this.scroll.add(this.notes);
-    const controls = new BoxRenderable5(renderer2, { id: "omnius-devices:controls", width: "100%", height: 1, flexShrink: 0, flexDirection: "row", gap: 2 });
+    const controls = new BoxRenderable7(renderer2, { id: "omnius-devices:controls", width: "100%", height: 1, flexShrink: 0, flexDirection: "row", gap: 2 });
     this.add(controls);
     this.policy = this.button(renderer2, "omnius-devices:policy", "GPU POLICY", () => {
       if (this.canSelect()) this.action?.("/gpu");
@@ -2717,10 +3723,10 @@ var DeviceMonitor = class extends BoxRenderable5 {
   snapshot;
   historySource = "";
   rows = /* @__PURE__ */ new Map();
-  button(renderer2, id, label, activate) {
-    const button = new TextRenderable4(renderer2, {
+  button(renderer2, id, label2, activate) {
+    const button = new TextRenderable6(renderer2, {
       id,
-      content: label,
+      content: label2,
       height: 1,
       flexShrink: 0,
       fg: foreground,
@@ -2745,11 +3751,11 @@ var DeviceMonitor = class extends BoxRenderable5 {
       }
     });
     button.focusable = Boolean(this.action);
-    button.on(RenderableEvents3.FOCUSED, () => {
-      button.attributes = TextAttributes5.INVERSE;
+    button.on(RenderableEvents5.FOCUSED, () => {
+      button.attributes = TextAttributes7.INVERSE;
     });
-    button.on(RenderableEvents3.BLURRED, () => {
-      button.attributes = button.focusable ? 0 : TextAttributes5.DIM;
+    button.on(RenderableEvents5.BLURRED, () => {
+      button.attributes = button.focusable ? 0 : TextAttributes7.DIM;
     });
     return button;
   }
@@ -2771,7 +3777,7 @@ var DeviceMonitor = class extends BoxRenderable5 {
     if (this.policy.focused && !allowed) this.heading.focus();
     this.policy.focusable = allowed;
     this.policy.content = snapshot?.selectionLocked ? "POLICY LOCKED" : "GPU POLICY";
-    this.policy.attributes = allowed ? this.policy.focused ? TextAttributes5.INVERSE : 0 : TextAttributes5.DIM;
+    this.policy.attributes = allowed ? this.policy.focused ? TextAttributes7.INVERSE : 0 : TextAttributes7.DIM;
     const keep = new Set(snapshot?.devices.map((device) => device.uuid) ?? []);
     for (const [uuid, row] of this.rows) if (!keep.has(uuid)) {
       if (row.title.focused) this.heading.focus();
@@ -2781,7 +3787,7 @@ var DeviceMonitor = class extends BoxRenderable5 {
     for (const device of snapshot?.devices ?? []) {
       let row = this.rows.get(device.uuid);
       if (!row) {
-        const root = new BoxRenderable5(this._ctx, {
+        const root = new BoxRenderable7(this._ctx, {
           id: `omnius-device:${device.uuid}`,
           width: "100%",
           flexDirection: "column",
@@ -2797,19 +3803,19 @@ var DeviceMonitor = class extends BoxRenderable5 {
           if (current && this.canSelectDevice(current)) this.action?.(`/gpu select ${current.uuid}`);
         });
         title.width = "100%";
-        title.on(RenderableEvents3.FOCUSED, () => this.scroll.scrollChildIntoView(root.id));
+        title.on(RenderableEvents5.FOCUSED, () => this.scroll.scrollChildIntoView(root.id));
         const load = new TelemetryRow(this._ctx, "LOAD", `${root.id}:load`, 16);
         const memory = new TelemetryRow(this._ctx, "VRAM", `${root.id}:memory`, 16);
-        const plot = (name) => new TextRenderable4(this._ctx, { id: `${root.id}:${name}-history`, content: "", width: "100%", height: 3, flexShrink: 0, fg: foreground, bg: background, wrapMode: "none", truncate: true, selectable: false });
+        const plot = (name) => new TextRenderable6(this._ctx, { id: `${root.id}:${name}-history`, content: "", width: "100%", height: 3, flexShrink: 0, fg: foreground, bg: background, wrapMode: "none", truncate: true, selectable: false });
         const loadGraph = plot("load"), memoryGraph = plot("memory"), history = new DeviceHistory();
-        const reason = new TextRenderable4(this._ctx, {
+        const reason = new TextRenderable6(this._ctx, {
           id: `${root.id}:reason`,
           content: "",
           width: "100%",
           height: 1,
           fg: foreground,
           bg: background,
-          attributes: TextAttributes5.DIM,
+          attributes: TextAttributes7.DIM,
           wrapMode: "none",
           truncate: true,
           visible: false
@@ -2832,7 +3838,7 @@ var DeviceMonitor = class extends BoxRenderable5 {
       const selectable = this.canSelectDevice(device);
       if (row.title.focused && !selectable) this.heading.focus();
       row.title.focusable = selectable;
-      row.title.attributes = row.title.focused ? TextAttributes5.INVERSE : device.preferred ? TextAttributes5.BOLD : selectable ? 0 : TextAttributes5.DIM;
+      row.title.attributes = row.title.focused ? TextAttributes7.INVERSE : device.preferred ? TextAttributes7.BOLD : selectable ? 0 : TextAttributes7.DIM;
       row.load.update(formatSignalMeter(device.utilization, 100, 6));
       const used = device.memoryUsedMB === void 0 ? "--" : instrumentNumber(device.memoryUsedMB / 1024, 1);
       const total = device.memoryTotalMB === void 0 || device.memoryTotalMB <= 0 ? "--" : instrumentNumber(device.memoryTotalMB / 1024, 1);
@@ -2885,10 +3891,10 @@ var DeviceMonitor = class extends BoxRenderable5 {
     ].filter(Boolean).join(" · ");
     const primary = devices.find((device) => device.preferred) ?? devices.find((device) => device.enabled) ?? devices[0];
     const compactHistory = primary ? this.rows.get(primary.uuid)?.history.samples ?? [] : [];
-    for (const [element, field, label] of [[this.compactLoad, "load", "UTIL"], [this.compactMemory, "memory", primary?.unifiedMemory ? "UMA" : "VRAM"]]) {
+    for (const [element, field, label2] of [[this.compactLoad, "load", "UTIL"], [this.compactMemory, "memory", primary?.unifiedMemory ? "UMA" : "VRAM"]]) {
       const current = primary ? field === "load" ? primary.utilization : primary.memoryUsedMB !== void 0 && primary.memoryTotalMB ? primary.memoryUsedMB / primary.memoryTotalMB * 100 : void 0 : void 0;
       const value = instrumentNumber(current, 0, "%");
-      const caption = `${label}${primary?.index ?? "-"}`;
+      const caption = `${label2}${primary?.index ?? "-"}`;
       const plotWidth = Math.max(0, this.width - caption.length - value.length - 2);
       const next = `${caption} ${deviceHistorySparkline(compactHistory, field, plotWidth)} ${value}`;
       if (element.plainText !== next) element.content = next;
@@ -2913,7 +3919,7 @@ var DeviceMonitor = class extends BoxRenderable5 {
     ];
   }
 };
-var ChannelMap = class extends BoxRenderable5 {
+var ChannelMap = class extends BoxRenderable7 {
   constructor(renderer2, id, inspect, reveal) {
     super(renderer2, {
       id,
@@ -2945,7 +3951,7 @@ var ChannelMap = class extends BoxRenderable5 {
       if (!this.channels.has(agent.id))
         this.channels.set(agent.id, this.channels.size + 1);
       if (!this.rows.has(agent.id)) {
-        const row = new TextRenderable4(this._ctx, {
+        const row = new TextRenderable6(this._ctx, {
           id: `${this.id}:channel:${agent.id}`,
           content: "",
           width: "100%",
@@ -2977,11 +3983,11 @@ var ChannelMap = class extends BoxRenderable5 {
           }
         });
         row.focusable = !!this.inspect;
-        row.on(RenderableEvents3.FOCUSED, () => {
-          row.attributes = TextAttributes5.INVERSE;
+        row.on(RenderableEvents5.FOCUSED, () => {
+          row.attributes = TextAttributes7.INVERSE;
           this.reveal?.(row);
         });
-        row.on(RenderableEvents3.BLURRED, () => {
+        row.on(RenderableEvents5.BLURRED, () => {
           row.attributes = 0;
         });
         this.rows.set(agent.id, row);
@@ -3011,7 +4017,9 @@ var ChannelMap = class extends BoxRenderable5 {
     }
   }
 };
-var InstrumentRail = class extends BoxRenderable5 {
+var InstrumentRail = class extends BoxRenderable7 {
+  workQueue;
+  taskNotes;
   scroll;
   inferenceHeader;
   sessionHeader;
@@ -3040,7 +4048,7 @@ var InstrumentRail = class extends BoxRenderable5 {
       flexGrow: 1,
       flexShrink: 1
     });
-    this.scroll = new ScrollBoxRenderable3(renderer2, {
+    this.scroll = new ScrollBoxRenderable5(renderer2, {
       id: `${id}:scroll`,
       width: "100%",
       flexGrow: 1,
@@ -3054,6 +4062,31 @@ var InstrumentRail = class extends BoxRenderable5 {
       contentOptions: { flexDirection: "column", paddingRight: 1 }
     });
     this.add(this.scroll);
+    const colors = options.colors ?? {
+      foreground,
+      background,
+      accent: foreground,
+      dim: foreground,
+      border: foreground,
+      warning: foreground,
+      error: foreground,
+      success: foreground,
+      selection: background
+    };
+    this.workQueue = new NativeWorkQueueView(renderer2, colors, options.onWorkQueueAction, (target) => this.reveal(target));
+    this.scroll.add(this.workQueue);
+    this.taskNotes = new NativeTaskNotesView(renderer2, options.colors ?? {
+      foreground,
+      background,
+      accent: foreground,
+      dim: foreground,
+      border: foreground,
+      warning: foreground,
+      error: foreground,
+      success: foreground,
+      selection: background
+    }, (target) => this.reveal(target));
+    this.scroll.add(this.taskNotes);
     this.inferenceHeader = new SectionBanner(
       renderer2,
       "INFERENCE",
@@ -3061,26 +4094,26 @@ var InstrumentRail = class extends BoxRenderable5 {
       () => this.toggleSection("inference")
     );
     this.inferenceHeader.on(
-      RenderableEvents3.FOCUSED,
+      RenderableEvents5.FOCUSED,
       () => this.reveal(this.inferenceHeader)
     );
     this.scroll.add(this.inferenceHeader);
-    this.inference = new BoxRenderable5(renderer2, {
+    this.inference = new BoxRenderable7(renderer2, {
       id: `${id}:inference-body`,
       width: "100%",
       flexDirection: "column",
       flexShrink: 0
     });
     this.scroll.add(this.inference);
-    const addRow = (parent, key, label, reserved = 12) => {
-      const row = new TelemetryRow(renderer2, label, `${id}:${key}`, reserved);
+    const addRow = (parent, key, label2, reserved = 12) => {
+      const row = new TelemetryRow(renderer2, label2, `${id}:${key}`, reserved);
       this.rows.set(key, row);
       parent.add(row);
       return row;
     };
     addRow(this.inference, "route", "ROUTE");
     addRow(this.inference, "backend", "BACKEND");
-    this.model = new TextRenderable4(renderer2, {
+    this.model = new TextRenderable6(renderer2, {
       id: `${id}:model`,
       content: "MODEL --",
       width: "100%",
@@ -3107,9 +4140,9 @@ var InstrumentRail = class extends BoxRenderable5 {
       this.contextDetails.visible = !this.contextDetails.visible;
       this.contextHeader.update("CONTEXT DETAILS", this.contextDetails.visible);
     });
-    this.contextHeader.on(RenderableEvents3.FOCUSED, () => this.reveal(this.contextHeader));
+    this.contextHeader.on(RenderableEvents5.FOCUSED, () => this.reveal(this.contextHeader));
     this.inference.add(this.contextHeader);
-    this.contextDetails = new BoxRenderable5(renderer2, { id: `${id}:context-detail-body`, width: "100%", flexDirection: "column", flexShrink: 0, visible: false });
+    this.contextDetails = new BoxRenderable7(renderer2, { id: `${id}:context-detail-body`, width: "100%", flexDirection: "column", flexShrink: 0, visible: false });
     this.inference.add(this.contextDetails);
     this.contextHeader.update("CONTEXT DETAILS", false);
     addRow(this.contextDetails, "messages", "MESSAGES");
@@ -3124,11 +4157,11 @@ var InstrumentRail = class extends BoxRenderable5 {
       () => this.toggleSection("session")
     );
     this.sessionHeader.on(
-      RenderableEvents3.FOCUSED,
+      RenderableEvents5.FOCUSED,
       () => this.reveal(this.sessionHeader)
     );
     this.scroll.add(this.sessionHeader);
-    this.session = new BoxRenderable5(renderer2, {
+    this.session = new BoxRenderable7(renderer2, {
       id: `${id}:session-body`,
       width: "100%",
       flexDirection: "column",
@@ -3155,6 +4188,8 @@ var InstrumentRail = class extends BoxRenderable5 {
     if (options.colors) this.applyTheme(options.colors);
   }
   update(state) {
+    this.workQueue.update(state.workQueue);
+    this.taskNotes.update(state.taskNotes);
     const data = state.instruments;
     const inference = data?.inference;
     const session = data?.session;
@@ -3211,13 +4246,15 @@ var InstrumentRail = class extends BoxRenderable5 {
   applyTheme(colors) {
     this.backgroundColor = colors.background;
     const visit = (node) => {
-      if (node instanceof TextRenderable4) {
+      if (node instanceof TextRenderable6) {
         node.fg = colors.foreground;
         node.bg = colors.background;
       }
       for (const child of node.getChildren()) visit(child);
     };
     visit(this);
+    this.workQueue.applyTheme(colors);
+    this.taskNotes.applyTheme(colors);
     styleNativeScrollbars(this.scroll, colors);
     styleNativeScrollbars(this.devices.scroll, colors);
   }
@@ -3237,10 +4274,14 @@ var InstrumentRail = class extends BoxRenderable5 {
       context: this.contextHeader.expanded,
       devices: this.devices.isExpanded,
       scrollTop: this.scroll.scrollTop,
-      deviceScrollTop: this.devices.scroll.scrollTop
+      deviceScrollTop: this.devices.scroll.scrollTop,
+      taskNotes: this.taskNotes.capturePresentation(),
+      workQueue: this.workQueue.capturePresentation()
     };
   }
   restorePresentation(state) {
+    this.workQueue.restorePresentation(state.workQueue);
+    this.taskNotes.restorePresentation(state.taskNotes);
     if (this.inference.visible !== state.inference) this.toggleSection("inference");
     if (this.session.visible !== state.session) this.toggleSection("session");
     this.contextHeader.update("CONTEXT DETAILS", state.context);
@@ -3252,6 +4293,8 @@ var InstrumentRail = class extends BoxRenderable5 {
   focusTargets() {
     if (!this.visible) return [];
     return [
+      ...this.workQueue.focusTargets(),
+      ...this.taskNotes.focusTargets(),
       this.inferenceHeader,
       ...this.inference.visible && this.contextHeader.visible ? [this.contextHeader] : [],
       this.sessionHeader,
@@ -4708,14 +5751,14 @@ var VimComposer = class {
 };
 
 // packages/cli/src/tui/native/components/selection-menu.ts
-import { BoxRenderable as BoxRenderable6, CliRenderEvents as CliRenderEvents3, TextAttributes as TextAttributes6, TextRenderable as TextRenderable5 } from "@opentui/core";
+import { BoxRenderable as BoxRenderable8, CliRenderEvents as CliRenderEvents5, TextAttributes as TextAttributes8, TextRenderable as TextRenderable7 } from "@opentui/core";
 var NativeSelectionMenu = class {
   constructor(renderer2, colors, copy, restoreFocus) {
     this.renderer = renderer2;
     this.colors = colors;
     this.copy = copy;
     this.restoreFocus = restoreFocus;
-    renderer2.on(CliRenderEvents3.RESIZE, this.position);
+    renderer2.on(CliRenderEvents5.RESIZE, this.position);
   }
   renderer;
   colors;
@@ -4736,7 +5779,7 @@ var NativeSelectionMenu = class {
     this.selectedText = text;
     this.anchor = { x, y };
     this.previousFocus = this.renderer.currentFocusedRenderable;
-    this.overlay = new BoxRenderable6(this.renderer, {
+    this.overlay = new BoxRenderable8(this.renderer, {
       id: "omnius-selection-menu",
       position: "absolute",
       left: 0,
@@ -4752,7 +5795,7 @@ var NativeSelectionMenu = class {
         event.stopPropagation();
       }
     });
-    this.panel = new BoxRenderable6(this.renderer, {
+    this.panel = new BoxRenderable8(this.renderer, {
       id: "omnius-selection-menu-panel",
       position: "absolute",
       width: 14,
@@ -4766,7 +5809,7 @@ var NativeSelectionMenu = class {
         event.stopPropagation();
       }
     });
-    const action = new TextRenderable5(this.renderer, {
+    const action = new TextRenderable7(this.renderer, {
       id: "omnius-selection-copy",
       content: "COPY",
       height: 1,
@@ -4774,7 +5817,7 @@ var NativeSelectionMenu = class {
       selectable: false,
       fg: this.colors.foreground,
       bg: this.colors.background,
-      attributes: TextAttributes6.BOLD | TextAttributes6.INVERSE,
+      attributes: TextAttributes8.BOLD | TextAttributes8.INVERSE,
       onMouseDown: (event) => {
         if (event.button === 0) this.confirm();
         event.preventDefault();
@@ -4815,7 +5858,7 @@ var NativeSelectionMenu = class {
     if (!this.panel) return;
     this.panel.backgroundColor = colors.background;
     this.frame?.setColors(colors);
-    for (const child of this.panel.getChildren()) if (child instanceof TextRenderable5) {
+    for (const child of this.panel.getChildren()) if (child instanceof TextRenderable7) {
       child.fg = colors.foreground;
       child.bg = colors.background;
     }
@@ -4836,13 +5879,13 @@ var NativeSelectionMenu = class {
   }
   destroy() {
     this.close();
-    this.renderer.off(CliRenderEvents3.RESIZE, this.position);
+    this.renderer.off(CliRenderEvents5.RESIZE, this.position);
   }
 };
 
 // packages/cli/src/tui/native/components/tab-strip.ts
-import { BoxRenderable as BoxRenderable7, CliRenderEvents as CliRenderEvents4, ScrollBoxRenderable as ScrollBoxRenderable4, SliderRenderable, TextAttributes as TextAttributes7, TextRenderable as TextRenderable6 } from "@opentui/core";
-var NativeTabStrip = class extends BoxRenderable7 {
+import { BoxRenderable as BoxRenderable9, CliRenderEvents as CliRenderEvents6, ScrollBoxRenderable as ScrollBoxRenderable6, SliderRenderable, TextAttributes as TextAttributes9, TextRenderable as TextRenderable8 } from "@opentui/core";
+var NativeTabStrip = class extends BoxRenderable9 {
   constructor(renderer2, options) {
     super(renderer2, {
       id: options.id,
@@ -4858,7 +5901,7 @@ var NativeTabStrip = class extends BoxRenderable7 {
     this.renderer = renderer2;
     this.options = options;
     this.colors = options.colors;
-    this.scroll = new ScrollBoxRenderable4(renderer2, {
+    this.scroll = new ScrollBoxRenderable6(renderer2, {
       id: `${options.id}:scroll`,
       height: 1,
       minHeight: 1,
@@ -4896,7 +5939,7 @@ var NativeTabStrip = class extends BoxRenderable7 {
     this.rail.focusable = false;
     this.add(this.rail);
     styleNativeSlider(this.rail, this.colors);
-    renderer2.on(CliRenderEvents4.FRAME, this.syncScroll);
+    renderer2.on(CliRenderEvents6.FRAME, this.syncScroll);
   }
   renderer;
   options;
@@ -4913,15 +5956,19 @@ var NativeTabStrip = class extends BoxRenderable7 {
     const signature = JSON.stringify([items, activeId, busy]);
     if (signature === this.signature) return;
     this.signature = signature;
+    const previousFocus = this.renderer.currentFocusedRenderable;
+    const ownedFocus = Boolean(previousFocus) && [...this.buttons.values()].some((entry) => previousFocus === entry.button || previousFocus === entry.close);
     const ids = new Set(items.map((item) => item.id));
     for (const [id, entry] of this.buttons) if (!ids.has(id)) {
       entry.button.destroy();
+      entry.close?.destroy();
       this.buttons.delete(id);
     }
-    for (const [index, action] of items.entries()) {
+    const controls = [];
+    for (const action of items) {
       let entry = this.buttons.get(action.id);
       if (!entry) {
-        const button = new TextRenderable6(this.renderer, {
+        const button = new TextRenderable8(this.renderer, {
           id: `${this.options.prefix}:${action.id}`,
           content: "",
           height: 1,
@@ -4948,35 +5995,73 @@ var NativeTabStrip = class extends BoxRenderable7 {
           this.reveal = button.id;
         });
         button.on("blurred", () => this.style(entry));
+        if (this.options.close) {
+          const close2 = new TextRenderable8(this.renderer, {
+            id: `${this.options.prefix}-close:${action.id}`,
+            content: "×",
+            width: 1,
+            height: 1,
+            flexShrink: 0,
+            wrapMode: "none",
+            selectable: false,
+            fg: this.colors.foreground,
+            bg: this.colors.background,
+            onMouseDown: (event) => {
+              if (event.button === 0 && !entry.blocked) {
+                close2.focus();
+                this.options.close(entry.action.id);
+              }
+              event.preventDefault();
+              event.stopPropagation();
+            },
+            onKeyDown: (key) => this.handleKey(entry, key, true)
+          });
+          entry.close = close2;
+          close2.on("focused", () => {
+            this.style(entry);
+            this.scroll.scrollChildIntoView(close2.id);
+            this.reveal = close2.id;
+          });
+          close2.on("blurred", () => this.style(entry));
+        }
       }
       entry.action = action;
       entry.active = action.id === activeId;
       entry.blocked = busy || Boolean(action.disabled);
       entry.button.focusable = entry.active || !entry.blocked;
-      const label = plainText(action.label);
-      const content = ` ${label} `;
+      if (entry.close) entry.close.focusable = !entry.blocked;
+      const label2 = plainText(action.label);
+      const content = ` ${label2} `;
       if (entry.button.plainText !== content) entry.button.content = content;
       this.style(entry);
-      if (this.scroll.getChildren()[index] !== entry.button) this.scroll.add(entry.button, index);
+      controls.push(entry.button);
+      if (entry.close) controls.push(entry.close);
     }
-    this.naturalWidth = Array.from(this.buttons.values()).reduce((width, entry) => width + terminalCellWidth(entry.button.plainText), 0) + Math.max(0, items.length - 1);
-    const focused = this.renderer.currentFocusedRenderable;
-    if (focused && !focused.focusable && Array.from(this.buttons.values()).some((entry) => entry.button === focused)) this.buttons.get(activeId)?.button.focus();
+    for (const [index, control] of controls.entries()) if (this.scroll.getChildren()[index] !== control) this.scroll.add(control, index);
+    this.naturalWidth = controls.reduce((width, control) => width + terminalCellWidth(control.plainText), 0) + Math.max(0, controls.length - 1);
+    if (ownedFocus && (!previousFocus || previousFocus.isDestroyed || !previousFocus.focusable))
+      (this.buttons.get(activeId)?.button ?? controls.find((control) => control.focusable))?.focus();
     if (activeId !== this.activeId) this.reveal = `${this.options.prefix}:${activeId}`;
     this.activeId = activeId;
     this.renderer.requestRender();
   }
   style(entry) {
-    entry.button.attributes = (entry.active ? TextAttributes7.BOLD | TextAttributes7.UNDERLINE : entry.blocked ? TextAttributes7.DIM : 0) | (entry.button.focused ? TextAttributes7.INVERSE : 0);
+    entry.button.attributes = (entry.active ? TextAttributes9.BOLD | TextAttributes9.UNDERLINE : entry.blocked ? TextAttributes9.DIM : 0) | (entry.button.focused ? TextAttributes9.INVERSE : 0);
+    if (entry.close) entry.close.attributes = (entry.blocked || !entry.close.focused ? TextAttributes9.DIM : 0) | (entry.close.focused ? TextAttributes9.INVERSE : 0);
   }
-  handleKey(entry, key) {
+  handleKey(entry, key, close2 = false) {
     if (key.eventType === "release") return;
     if (key.name === "return" || key.sequence === " ") {
-      if (!entry.blocked) this.options.activate(entry.action.id);
+      if (!entry.blocked) {
+        if (close2) this.options.close?.(entry.action.id);
+        else this.options.activate(entry.action.id);
+      }
+    } else if (this.options.close && (key.name === "delete" || key.ctrl && key.name.toLowerCase() === "w")) {
+      if (!entry.blocked) this.options.close(entry.action.id);
     } else if (["left", "right", "home", "end"].includes(key.name)) {
-      const targets = this.scroll.getChildren().filter((button) => button.focusable);
+      const targets = this.scroll.getChildren().filter((button) => button.focusable && button.id.startsWith(`${this.options.prefix}:`));
       const index = targets.indexOf(entry.button);
-      const next = key.name === "home" ? 0 : key.name === "end" ? targets.length - 1 : (index + (key.name === "left" ? -1 : 1) + targets.length) % targets.length;
+      const next = key.name === "home" ? 0 : key.name === "end" ? targets.length - 1 : (index + (key.name === "left" ? close2 ? 0 : -1 : 1) + targets.length) % targets.length;
       targets[next]?.focus();
     } else return;
     key.preventDefault();
@@ -5001,9 +6086,13 @@ var NativeTabStrip = class extends BoxRenderable7 {
   };
   applyTheme(colors) {
     this.colors = colors;
-    for (const { button } of this.buttons.values()) {
+    for (const { button, close: close2 } of this.buttons.values()) {
       button.fg = colors.foreground;
       button.bg = colors.background;
+      if (close2) {
+        close2.fg = colors.foreground;
+        close2.bg = colors.background;
+      }
     }
     styleNativeScrollbars(this.scroll, colors);
     styleNativeSlider(this.rail, colors);
@@ -5013,7 +6102,7 @@ var NativeTabStrip = class extends BoxRenderable7 {
     this.scroll.scrollLeft = offset2;
   }
   destroySelf() {
-    this.renderer.off(CliRenderEvents4.FRAME, this.syncScroll);
+    this.renderer.off(CliRenderEvents6.FRAME, this.syncScroll);
     super.destroySelf();
   }
 };
@@ -5031,7 +6120,7 @@ var NativeFrontend = class {
     this.selectionMenu = new NativeSelectionMenu(renderer2, colors, (text) => {
       void this.copy(text);
     }, () => this.restoreFocus());
-    this.root = new BoxRenderable8(renderer2, {
+    this.root = new BoxRenderable10(renderer2, {
       id: "omnius-native",
       width: "100%",
       height: "100%",
@@ -5039,7 +6128,7 @@ var NativeFrontend = class {
       backgroundColor: colors.background
     });
     renderer2.root.add(this.root);
-    this.header = new BoxRenderable8(renderer2, {
+    this.header = new BoxRenderable10(renderer2, {
       id: "omnius-header",
       width: "100%",
       minWidth: 0,
@@ -5060,12 +6149,12 @@ var NativeFrontend = class {
         this.header.y + this.header.height - 1,
         this.context.colors.foreground,
         this.context.colors.background,
-        TextAttributes8.DIM
+        TextAttributes10.DIM
       );
     };
-    const headerRow = new BoxRenderable8(renderer2, { id: "omnius-header-row", width: "100%", minWidth: 0, minHeight: 1, flexDirection: "row", gap: 1 });
+    const headerRow = new BoxRenderable10(renderer2, { id: "omnius-header-row", width: "100%", minWidth: 0, minHeight: 1, flexDirection: "row", gap: 1 });
     this.header.add(headerRow);
-    this.identity = new TextRenderable7(renderer2, {
+    this.identity = new TextRenderable9(renderer2, {
       id: "omnius-identity",
       content: "Omnius",
       fg: colors.foreground,
@@ -5075,7 +6164,7 @@ var NativeFrontend = class {
       truncate: true,
       minWidth: 18,
       selectable: false,
-      attributes: TextAttributes8.BOLD,
+      attributes: TextAttributes10.BOLD,
       onMouseDown: (event) => {
         if (event.button === 0) {
           this.toggleHeaderPanel();
@@ -5090,7 +6179,7 @@ var NativeFrontend = class {
       }
     });
     headerRow.add(this.identity);
-    this.headerActions = new ScrollBoxRenderable5(renderer2, {
+    this.headerActions = new ScrollBoxRenderable7(renderer2, {
       id: "omnius-header-actions",
       flexGrow: 0,
       flexShrink: 1,
@@ -5103,16 +6192,16 @@ var NativeFrontend = class {
       verticalScrollbarOptions: { visible: false }
     });
     headerRow.add(this.headerActions);
-    this.headerPanel = new TextRenderable7(renderer2, { id: "omnius-header-panel", content: "", width: "100%", wrapMode: "word", visible: false });
+    this.headerPanel = new TextRenderable9(renderer2, { id: "omnius-header-panel", content: "", width: "100%", wrapMode: "word", visible: false });
     this.header.add(this.headerPanel);
-    this.detailButton = new TextRenderable7(renderer2, {
+    this.detailButton = new TextRenderable9(renderer2, {
       id: "omnius-details-toggle",
       content: "+ DETAILS",
       height: 1,
       width: 9,
       flexShrink: 0,
       fg: colors.foreground,
-      attributes: TextAttributes8.DIM,
+      attributes: TextAttributes10.DIM,
       selectable: false,
       onMouseDown: (event) => {
         if (event.button === 0) {
@@ -5132,13 +6221,13 @@ var NativeFrontend = class {
     for (const control of [this.identity, this.detailButton]) {
       const attributes = control.attributes;
       control.on("focused", () => {
-        control.attributes = attributes | TextAttributes8.INVERSE;
+        control.attributes = attributes | TextAttributes10.INVERSE;
       });
       control.on("blurred", () => {
         control.attributes = attributes;
       });
     }
-    this.sessionRow = new BoxRenderable8(renderer2, {
+    this.sessionRow = new BoxRenderable10(renderer2, {
       id: "omnius-sessions-row",
       width: "100%",
       height: 1,
@@ -5153,10 +6242,11 @@ var NativeFrontend = class {
       id: "omnius-session-tabs",
       prefix: "session",
       colors,
-      activate: (id) => this.emitAction("session", id)
+      activate: (id) => this.emitAction("session", id),
+      close: (id) => this.emitAction("session-close", id)
     });
     this.sessionRow.add(this.sessions);
-    this.newSession = new TextRenderable7(renderer2, {
+    this.newSession = new TextRenderable9(renderer2, {
       id: "omnius-session-new",
       content: "+ NEW",
       width: 5,
@@ -5180,21 +6270,58 @@ var NativeFrontend = class {
     });
     this.newSession.focusable = true;
     const styleNew = () => {
-      this.newSession.attributes = (this.state?.sessions?.busy ? TextAttributes8.DIM : 0) | (this.newSession.focused ? TextAttributes8.INVERSE : 0);
+      this.newSession.attributes = (this.state?.sessions?.busy ? TextAttributes10.DIM : 0) | (this.newSession.focused ? TextAttributes10.INVERSE : 0);
     };
     this.newSession.on("focused", styleNew);
     this.newSession.on("blurred", styleNew);
     this.sessionRow.add(this.newSession);
-    this.routeWarning = new TextRenderable7(renderer2, { id: "omnius-route-warning", content: "", width: "100%", wrapMode: "word", fg: colors.warning, attributes: TextAttributes8.BOLD | TextAttributes8.UNDERLINE, visible: false, flexShrink: 0 });
+    this.sessionPicker = new TextRenderable9(renderer2, {
+      id: "omnius-session-picker",
+      content: "SESSIONS",
+      width: 8,
+      height: 1,
+      flexShrink: 0,
+      selectable: false,
+      fg: colors.foreground,
+      bg: colors.background,
+      onMouseDown: (event) => {
+        if (event.button === 0 && !this.state?.sessions?.busy) this.emitAction("session-picker");
+        event.preventDefault();
+        event.stopPropagation();
+      },
+      onKeyDown: (key) => {
+        if (key.eventType !== "release" && (key.name === "return" || key.sequence === " ")) {
+          if (!this.state?.sessions?.busy) this.emitAction("session-picker");
+          key.preventDefault();
+          key.stopPropagation();
+        }
+      }
+    });
+    this.sessionPicker.focusable = true;
+    const stylePicker = () => {
+      this.sessionPicker.attributes = (this.state?.sessions?.busy ? TextAttributes10.DIM : 0) | (this.sessionPicker.focused ? TextAttributes10.INVERSE : 0);
+    };
+    this.sessionPicker.on("focused", stylePicker);
+    this.sessionPicker.on("blurred", stylePicker);
+    this.sessionRow.add(this.sessionPicker);
+    this.routeWarning = new TextRenderable9(renderer2, { id: "omnius-route-warning", content: "", width: "100%", wrapMode: "word", fg: colors.warning, attributes: TextAttributes10.BOLD | TextAttributes10.UNDERLINE, visible: false, flexShrink: 0 });
     this.root.add(this.routeWarning);
-    this.taskPane = new BoxRenderable8(renderer2, { id: "omnius-tasks", width: "100%", flexDirection: "column", maxHeight: 6, flexShrink: 0, overflow: "hidden", visible: false });
+    this.taskPane = new BoxRenderable10(renderer2, { id: "omnius-tasks", width: "100%", flexDirection: "column", maxHeight: 6, flexShrink: 0, overflow: "hidden", visible: false });
     this.tasks = new NativeBlockList(this.context, this.taskPane);
     this.root.add(this.taskPane);
-    this.body = new BoxRenderable8(renderer2, { id: "omnius-body", width: "100%", flexDirection: "row", flexGrow: 1, minHeight: 1 });
+    this.taskStrip = new NativeTaskStrip(renderer2, colors, (id) => {
+      if (renderer2.terminalWidth >= 110) this.detailsOpen = true;
+      else this.narrowDetailsOpen = true;
+      this.layoutInstruments();
+      this.instruments.taskNotes.inspect(id);
+      renderer2.requestRender();
+    });
+    this.root.add(this.taskStrip);
+    this.body = new BoxRenderable10(renderer2, { id: "omnius-body", width: "100%", flexDirection: "row", flexGrow: 1, minHeight: 1 });
     this.root.add(this.body);
-    this.transcriptPane = new BoxRenderable8(renderer2, { id: "omnius-transcript-pane", flexDirection: "column", flexGrow: 1, flexShrink: 1, minWidth: 0, minHeight: 1 });
+    this.transcriptPane = new BoxRenderable10(renderer2, { id: "omnius-transcript-pane", flexDirection: "column", flexGrow: 1, flexShrink: 1, minWidth: 0, minHeight: 1 });
     this.body.add(this.transcriptPane);
-    this.scroll = new ScrollBoxRenderable5(renderer2, {
+    this.scroll = new ScrollBoxRenderable7(renderer2, {
       id: "omnius-conversation",
       flexGrow: 1,
       flexShrink: 1,
@@ -5252,7 +6379,7 @@ var NativeFrontend = class {
     this.transcriptPane.add(this.scroll);
     this.content = new NativeBlockList(this.context, this.scroll);
     this.instrumentDivider = new InstrumentDivider(renderer2, {
-      resize: (column) => this.resizeInstruments(column),
+      resize: (column3) => this.resizeInstruments(column3),
       toggle: () => this.toggleDetails(),
       start: () => {
         this.sidebarDragWidth = this.sidebarWidth ?? Math.floor(this.renderer.terminalWidth * 0.38);
@@ -5265,9 +6392,17 @@ var NativeFrontend = class {
     this.root.onMouseDrag = (event) => this.instrumentDivider.handleDrag(event);
     this.root.onMouseDragEnd = (event) => this.instrumentDivider.handleRelease(event);
     this.root.onMouseUp = (event) => this.instrumentDivider.handleRelease(event);
-    this.instruments = new InstrumentRail(renderer2, { colors, onInspectAgent: (id) => this.emitAction("view", id), onAction: (command2) => this.emitAction(command2) });
+    this.instruments = new InstrumentRail(renderer2, {
+      colors,
+      onInspectAgent: (id) => this.emitAction("view", id),
+      onAction: (command2) => this.emitAction(command2),
+      onWorkQueueAction: (event) => {
+        this.flushLatestInput();
+        this.emit(event);
+      }
+    });
     this.body.add(this.instruments);
-    this.embeddedPane = new BoxRenderable8(renderer2, {
+    this.embeddedPane = new BoxRenderable10(renderer2, {
       id: "omnius-editor-pane",
       width: "50%",
       flexShrink: 0,
@@ -5278,7 +6413,7 @@ var NativeFrontend = class {
       visible: false
     });
     this.body.add(this.embeddedPane);
-    this.liveButton = new TextRenderable7(renderer2, {
+    this.liveButton = new TextRenderable9(renderer2, {
       id: "omnius-live-button",
       content: "↓ Live",
       width: "100%",
@@ -5301,7 +6436,7 @@ var NativeFrontend = class {
     });
     this.liveButton.focusable = true;
     this.transcriptPane.add(this.liveButton);
-    this.queue = new TextRenderable7(renderer2, { id: "omnius-steering-queue", content: "", width: "100%", height: 1, wrapMode: "none", truncate: true, fg: colors.dim, visible: false, flexShrink: 0 });
+    this.queue = new TextRenderable9(renderer2, { id: "omnius-steering-queue", content: "", width: "100%", height: 1, wrapMode: "none", truncate: true, fg: colors.dim, visible: false, flexShrink: 0 });
     this.transcriptPane.add(this.queue);
     this.suggestions = new NativeSelectRenderable(renderer2, {
       id: "omnius-suggestions",
@@ -5320,9 +6455,9 @@ var NativeFrontend = class {
     this.suggestions.onActivate = () => this.acceptSuggestion();
     this.suggestions.on("itemSelected", () => this.acceptSuggestion());
     this.transcriptPane.add(this.suggestions);
-    this.status = new BoxRenderable8(renderer2, { id: "omnius-live-status", width: "100%", height: 1, flexShrink: 0, flexDirection: "row", gap: 2, visible: false });
+    this.status = new BoxRenderable10(renderer2, { id: "omnius-live-status", width: "100%", height: 1, flexShrink: 0, flexDirection: "row", gap: 2, visible: false });
     this.transcriptPane.add(this.status);
-    this.footer = new BoxRenderable8(renderer2, {
+    this.footer = new BoxRenderable10(renderer2, {
       id: "omnius-input-box",
       width: "100%",
       flexShrink: 0,
@@ -5331,7 +6466,7 @@ var NativeFrontend = class {
       flexDirection: "column"
     });
     this.root.add(this.footer);
-    this.footerRule = new BoxRenderable8(renderer2, {
+    this.footerRule = new BoxRenderable10(renderer2, {
       id: "omnius-input-rule",
       width: "100%",
       height: 1,
@@ -5357,11 +6492,11 @@ var NativeFrontend = class {
       buffer.drawText(formatSignalDivider(this.footerRule.width, {
         direction: "bottom",
         sidebarColumn: this.instrumentDivider.visible ? this.instrumentDivider.x - this.footerRule.x : void 0
-      }), this.footerRule.x, this.footerRule.y, this.context.colors.foreground, this.context.colors.background, TextAttributes8.DIM);
+      }), this.footerRule.x, this.footerRule.y, this.context.colors.foreground, this.context.colors.background, TextAttributes10.DIM);
     };
-    const inputRow = new BoxRenderable8(renderer2, { id: "omnius-input-row", width: "100%", flexDirection: "row", gap: 1 });
+    const inputRow = new BoxRenderable10(renderer2, { id: "omnius-input-row", width: "100%", flexDirection: "row", gap: 1 });
     this.footer.add(inputRow);
-    this.prompt = new TextRenderable7(renderer2, { id: "omnius-prompt", content: "❯", fg: colors.accent, wrapMode: "none", selectable: false, flexShrink: 0 });
+    this.prompt = new TextRenderable9(renderer2, { id: "omnius-prompt", content: "❯", fg: colors.accent, wrapMode: "none", selectable: false, flexShrink: 0 });
     inputRow.add(this.prompt);
     this.editor = new TextareaRenderable2(renderer2, {
       id: "omnius-input",
@@ -5381,14 +6516,14 @@ var NativeFrontend = class {
       onCursorChange: () => this.editorChanged(),
       onSubmit: () => this.submit()
     });
-    this.vimMode = new TextRenderable7(renderer2, {
+    this.vimMode = new TextRenderable9(renderer2, {
       id: "omnius-vim-mode",
       content: "INSERT",
       height: 1,
       maxWidth: 12,
       flexShrink: 0,
       fg: colors.foreground,
-      attributes: TextAttributes8.DIM,
+      attributes: TextAttributes10.DIM,
       wrapMode: "none",
       truncate: true,
       visible: false,
@@ -5402,42 +6537,42 @@ var NativeFrontend = class {
       this.renderer.requestRender();
     });
     inputRow.add(this.editor);
-    this.enhance = new BoxRenderable8(renderer2, { id: "omnius-enhance", flexDirection: "row", gap: 1, flexShrink: 0, visible: false });
+    this.enhance = new BoxRenderable10(renderer2, { id: "omnius-enhance", flexDirection: "row", gap: 1, flexShrink: 0, visible: false });
     inputRow.add(this.enhance);
-    this.activity = new TextRenderable7(renderer2, { id: "omnius-activity", content: "", flexGrow: 1, minWidth: 0, height: 1, wrapMode: "none", truncate: true, visible: false, fg: colors.accent });
+    this.activity = new TextRenderable9(renderer2, { id: "omnius-activity", content: "", flexGrow: 1, minWidth: 0, height: 1, wrapMode: "none", truncate: true, visible: false, fg: colors.accent });
     this.status.add(this.activity);
-    this.media = new BoxRenderable8(renderer2, { id: "omnius-media", height: 1, minWidth: 0, flexShrink: 1, flexDirection: "row", gap: 1, visible: false });
-    this.mediaText = new TextRenderable7(renderer2, { id: "omnius-media-text", content: "", flexGrow: 1, minWidth: 0, wrapMode: "none", truncate: true, fg: colors.accent });
+    this.media = new BoxRenderable10(renderer2, { id: "omnius-media", height: 1, minWidth: 0, flexShrink: 1, flexDirection: "row", gap: 1, visible: false });
+    this.mediaText = new TextRenderable9(renderer2, { id: "omnius-media-text", content: "", flexGrow: 1, minWidth: 0, wrapMode: "none", truncate: true, fg: colors.accent });
     this.media.add(this.mediaText);
-    this.micTrack = new TextRenderable7(renderer2, { id: "omnius-mic-meter", width: 12, height: 1, flexShrink: 0, fg: colors.foreground, visible: false });
+    this.micTrack = new TextRenderable9(renderer2, { id: "omnius-mic-meter", width: 12, height: 1, flexShrink: 0, fg: colors.foreground, visible: false });
     this.media.add(this.micTrack);
     this.status.add(this.media);
-    this.copyFeedback = new TextRenderable7(renderer2, {
+    this.copyFeedback = new TextRenderable9(renderer2, {
       id: "omnius-copy-feedback",
       content: "",
       height: 1,
       flexShrink: 0,
       fg: colors.foreground,
-      attributes: TextAttributes8.DIM,
+      attributes: TextAttributes10.DIM,
       selectable: false,
       visible: false
     });
     this.status.add(this.copyFeedback);
-    this.metricsRow = new BoxRenderable8(renderer2, { id: "omnius-metrics-row", width: "100%", height: 1, flexShrink: 0, flexDirection: "row", gap: 1 });
-    this.keyHints = new TextRenderable7(renderer2, { id: "omnius-key-hints", content: "F1 HELP  TAB FOCUS", height: 1, flexShrink: 0, attributes: TextAttributes8.DIM, fg: colors.foreground, selectable: false });
+    this.metricsRow = new BoxRenderable10(renderer2, { id: "omnius-metrics-row", width: "100%", height: 1, flexShrink: 0, flexDirection: "row", gap: 1 });
+    this.keyHints = new TextRenderable9(renderer2, { id: "omnius-key-hints", content: "F1 HELP  TAB FOCUS", height: 1, flexShrink: 0, attributes: TextAttributes10.DIM, fg: colors.foreground, selectable: false });
     this.metricsRow.add(this.keyHints);
-    this.metricsStartActions = new BoxRenderable8(renderer2, { id: "omnius-metrics-start-actions", flexDirection: "row", gap: 1, flexShrink: 0 });
+    this.metricsStartActions = new BoxRenderable10(renderer2, { id: "omnius-metrics-start-actions", flexDirection: "row", gap: 1, flexShrink: 0 });
     this.metricsRow.add(this.metricsStartActions);
-    this.metrics = new TextRenderable7(renderer2, { id: "omnius-metrics", content: "", height: 1, wrapMode: "none", truncate: true, fg: colors.dim, flexShrink: 1, flexGrow: 1, minWidth: 0 });
+    this.metrics = new TextRenderable9(renderer2, { id: "omnius-metrics", content: "", height: 1, wrapMode: "none", truncate: true, fg: colors.dim, flexShrink: 1, flexGrow: 1, minWidth: 0 });
     this.metricsRow.add(this.metrics);
-    this.metricsEndActions = new BoxRenderable8(renderer2, { id: "omnius-metrics-end-actions", flexDirection: "row", gap: 1, flexShrink: 0 });
+    this.metricsEndActions = new BoxRenderable10(renderer2, { id: "omnius-metrics-end-actions", flexDirection: "row", gap: 1, flexShrink: 0 });
     this.metricsRow.add(this.metricsEndActions);
     this.root.add(this.metricsRow);
     this.modals = new NativeModalStack(this.context, () => this.restoreFocus());
     renderer2.keyInput.on("keypress", this.onKey);
     renderer2.keyInput.on("paste", this.onPaste);
-    renderer2.on(CliRenderEvents5.FRAME, this.onFrame);
-    renderer2.on(CliRenderEvents5.RESIZE, this.onResize);
+    renderer2.on(CliRenderEvents7.FRAME, this.onFrame);
+    renderer2.on(CliRenderEvents7.RESIZE, this.onResize);
     this.applyTheme(initialTheme);
     this.editor.focus();
   }
@@ -5460,7 +6595,9 @@ var NativeFrontend = class {
   sessionRow;
   sessions;
   newSession;
+  sessionPicker;
   taskPane;
+  taskStrip;
   tasks;
   body;
   transcriptPane;
@@ -5520,7 +6657,8 @@ var NativeFrontend = class {
   pendingInterface;
   embeddedId;
   selectionArmed = false;
-  update(state, patch) {
+  update(frame, patch) {
+    const state = { ...frame, workQueue: Object.hasOwn(frame, "workQueue") ? frame.workQueue ?? void 0 : this.state?.workQueue };
     const inputWasEnabled = this.state?.input.enabled;
     const previousView = this.state ? `${this.state.sessions?.activeId ?? ""}:${this.state.activeViewId}:${this.state.presentation ?? "stack"}` : void 0;
     const currentView = `${state.sessions?.activeId ?? ""}:${state.activeViewId}:${state.presentation ?? "stack"}`;
@@ -5556,10 +6694,13 @@ var NativeFrontend = class {
       this.sessionRow.visible = Boolean(state.sessions);
       this.sessions.update(state.sessions?.items ?? [], state.sessions?.activeId ?? "", state.sessions?.busy);
       this.newSession.focusable = !state.sessions?.busy;
-      if (state.sessions?.busy && this.newSession.focused) this.getRenderable(`session:${state.sessions.activeId}`)?.focus();
-      this.newSession.attributes = state.sessions?.busy ? TextAttributes8.DIM : this.newSession.focused ? TextAttributes8.INVERSE : 0;
-      this.tasks.replace(state.tasks);
-      this.taskPane.visible = state.tasks.length > 0;
+      this.sessionPicker.focusable = !state.sessions?.busy;
+      if (state.sessions?.busy && (this.newSession.focused || this.sessionPicker.focused)) this.getRenderable(`session:${state.sessions.activeId}`)?.focus();
+      this.newSession.attributes = state.sessions?.busy ? TextAttributes10.DIM : this.newSession.focused ? TextAttributes10.INVERSE : 0;
+      this.sessionPicker.attributes = state.sessions?.busy ? TextAttributes10.DIM : this.sessionPicker.focused ? TextAttributes10.INVERSE : 0;
+      this.tasks.replace(state.taskNotes ? [] : state.tasks);
+      this.taskPane.visible = !state.taskNotes && state.tasks.length > 0;
+      this.taskStrip.update(state.taskNotes);
       if (patch) {
         if (this.offset > 0 && !viewChanged && !patch.reset) this.newEntries += patch.upsert.filter((block) => !this.content.views.has(block.id)).length;
         this.content.patch(patch);
@@ -5570,7 +6711,7 @@ var NativeFrontend = class {
         this.pendingDisclosures = void 0;
       }
       this.queue.content = state.queued.length ? `Queued (${state.queued.length}) · ${state.queued.join("  ·  ")}` : "";
-      this.queue.visible = state.queued.length > 0;
+      this.queue.visible = !state.workQueue && state.queued.length > 0;
       const suggestionSignature = JSON.stringify(state.suggestions);
       if (suggestionSignature !== this.suggestionSignature) {
         this.suggestionSignature = suggestionSignature;
@@ -5616,8 +6757,8 @@ var NativeFrontend = class {
     for (const child of [...parent.getChildren()]) child.destroy();
     for (const action of actions) {
       const colors = this.context.colors;
-      const attributes = action.disabled ? TextAttributes8.DIM : action.active ? TextAttributes8.BOLD | TextAttributes8.UNDERLINE : 0;
-      const button = new TextRenderable7(this.renderer, {
+      const attributes = action.disabled ? TextAttributes10.DIM : action.active ? TextAttributes10.BOLD | TextAttributes10.UNDERLINE : 0;
+      const button = new TextRenderable9(this.renderer, {
         id: `${prefix}:${action.id}`,
         content: styledText(action.label),
         flexShrink: 0,
@@ -5640,16 +6781,16 @@ var NativeFrontend = class {
       button.focusable = !action.disabled;
       if (!action.disabled) {
         button.on("focused", () => {
-          button.attributes = attributes | TextAttributes8.INVERSE;
+          button.attributes = attributes | TextAttributes10.INVERSE;
         });
         button.on("blurred", () => {
           button.attributes = attributes;
         });
         button.onMouseOver = () => {
-          button.attributes = attributes | TextAttributes8.UNDERLINE | (button.focused ? TextAttributes8.INVERSE : 0);
+          button.attributes = attributes | TextAttributes10.UNDERLINE | (button.focused ? TextAttributes10.INVERSE : 0);
         };
         button.onMouseOut = () => {
-          button.attributes = attributes | (button.focused ? TextAttributes8.INVERSE : 0);
+          button.attributes = attributes | (button.focused ? TextAttributes10.INVERSE : 0);
         };
       }
       parent.add(button);
@@ -5665,10 +6806,10 @@ var NativeFrontend = class {
   renderActivity() {
     const activity = this.state?.activity;
     const stage = activity?.stage === "idle" ? void 0 : activity?.stage?.replace(/_/g, " ").toUpperCase();
-    const label = activity?.label && activity.label.toUpperCase() !== stage ? activity.label : void 0;
+    const label2 = activity?.label && activity.label.toUpperCase() !== stage ? activity.label : void 0;
     const elapsed = activity?.elapsedMs === void 0 ? void 0 : `${Math.max(0, Math.floor(activity.elapsedMs / 1e3))}s`;
     const progress = activity?.progress === void 0 ? void 0 : `${Math.round(activity.progress * 100)}% source accounted`;
-    const reading = [stage, label, elapsed, progress].filter(Boolean).join(" · ") || this.state?.instruments?.runtimeStatus || "";
+    const reading = [stage, label2, elapsed, progress].filter(Boolean).join(" · ") || this.state?.instruments?.runtimeStatus || "";
     this.activity.visible = Boolean(activity?.processing || reading);
     this.activity.content = `${activity?.processing ? "RUN · " : ""}${reading}`;
     this.status.visible = this.activity.visible || this.media.visible || this.copyFeedback.visible;
@@ -5691,7 +6832,7 @@ var NativeFrontend = class {
     this.mediaText.fg = media.recording ? this.context.colors.warning : this.context.colors.accent;
     this.micTrack.visible = media.recording && media.levelDb !== void 0;
     const level = Math.round(Math.max(0, Math.min(1, ((media.levelDb ?? -60) + 60) / 60)) * 8);
-    this.micTrack.content = `[${"●".repeat(level)}${"·".repeat(8 - level)}]`;
+    this.micTrack.content = `[${"▮".repeat(level)}${"░".repeat(8 - level)}]`;
   }
   applyTheme(theme) {
     const signature = JSON.stringify(theme);
@@ -5725,6 +6866,7 @@ var NativeFrontend = class {
     styleNativeScrollbars(this.headerActions, colors);
     styleNativeScrollbars(this.scroll, colors);
     this.instruments.applyTheme(colors);
+    this.taskStrip.applyTheme(colors);
     this.instrumentDivider.fg = colors.foreground;
     this.instrumentDivider.bg = colors.background;
     this.copyFeedback.fg = colors.foreground;
@@ -5745,10 +6887,10 @@ var NativeFrontend = class {
     this.layoutInstruments();
     this.renderer.requestRender();
   }
-  resizeInstruments(column) {
+  resizeInstruments(column3) {
     if (this.renderer.terminalWidth < 110 || this.embeddedPane.visible) return;
     const width = this.renderer.terminalWidth;
-    const requested = Math.max(0, this.body.x + width - Math.round(column) - 1);
+    const requested = Math.max(0, this.body.x + width - Math.round(column3) - 1);
     if (requested <= 4) {
       this.detailsOpen = false;
       if (this.sidebarDragWidth !== void 0) this.sidebarWidth = this.sidebarDragWidth;
@@ -5771,6 +6913,8 @@ var NativeFrontend = class {
     this.scroll.height = "auto";
     this.scroll.flexBasis = 0;
     this.instruments.visible = shown;
+    this.taskStrip.visible = Boolean(this.state?.taskNotes && this.taskStrip.hasItems && (!wide || !shown) && !this.embeddedPane.visible);
+    this.taskStrip.reconcile();
     this.instrumentDivider.visible = wide && !this.embeddedPane.visible;
     this.instrumentDivider.setCollapsed(!shown);
     const railWidth = Math.max(24, Math.min(width - 41, this.sidebarWidth ?? Math.floor(width * 0.38)));
@@ -5832,12 +6976,12 @@ var NativeFrontend = class {
       this.tabs.restoreOffset(state.tabs.agents);
       const focus = state.focusId && !this.modals.active ? this.getRenderable(state.focusId) : void 0;
       if (focus?.focusable) {
-        let ancestor = focus, visible = true;
+        let ancestor = focus, visible2 = true;
         while (ancestor) {
-          visible &&= ancestor.visible;
+          visible2 &&= ancestor.visible;
           ancestor = ancestor.parent;
         }
-        if (visible) focus.focus();
+        if (visible2) focus.focus();
       }
     }
     if (this.pendingScrollRestore) {
@@ -6108,7 +7252,7 @@ var NativeFrontend = class {
     const targets = [];
     const visit = (node) => {
       if (!node.visible) return;
-      if (node.focusable && node !== this.scroll && !(node instanceof ScrollBoxRenderable5) && node.height > 0 && node.width > 0) targets.push(node);
+      if (node.focusable && node !== this.scroll && !(node instanceof ScrollBoxRenderable7) && node.height > 0 && node.width > 0) targets.push(node);
       for (const child of node.getChildren()) visit(child);
     };
     visit(this.root);
@@ -6347,8 +7491,8 @@ var NativeFrontend = class {
     this.disposeSelectionContrast();
     this.renderer.keyInput.off("keypress", this.onKey);
     this.renderer.keyInput.off("paste", this.onPaste);
-    this.renderer.off(CliRenderEvents5.FRAME, this.onFrame);
-    this.renderer.off(CliRenderEvents5.RESIZE, this.onResize);
+    this.renderer.off(CliRenderEvents7.FRAME, this.onFrame);
+    this.renderer.off(CliRenderEvents7.RESIZE, this.onResize);
     const mediaClosed = [...this.context.mediaViews ?? []].map((media) => {
       media.pausePlayback();
       return media.closed;
@@ -6364,7 +7508,7 @@ var NativeFrontend = class {
 };
 
 // packages/cli/src/tui/native/components/cursor.ts
-import { CliRenderEvents as CliRenderEvents6 } from "@opentui/core";
+import { CliRenderEvents as CliRenderEvents8 } from "@opentui/core";
 function installTerminalCursorDefaults(renderer2, session) {
   const reset = new TextEncoder().encode("\x1B]112\x07");
   let disposed = false;
@@ -6414,11 +7558,11 @@ function installTerminalCursorDefaults(renderer2, session) {
   const dispose = () => {
     if (disposed) return;
     disposed = true;
-    renderer2.off(CliRenderEvents6.FRAME, afterFrame);
-    renderer2.off(CliRenderEvents6.DESTROY, dispose);
+    renderer2.off(CliRenderEvents8.FRAME, afterFrame);
+    renderer2.off(CliRenderEvents8.DESTROY, dispose);
   };
-  renderer2.on(CliRenderEvents6.FRAME, afterFrame);
-  renderer2.once(CliRenderEvents6.DESTROY, dispose);
+  renderer2.on(CliRenderEvents8.FRAME, afterFrame);
+  renderer2.once(CliRenderEvents8.DESTROY, dispose);
   return { restore, dispose };
 }
 
@@ -6507,10 +7651,10 @@ try {
     maxFps: 60,
     clearOnShutdown: false
   });
-  renderer.on(CliRenderEvents7.RENDER_ERROR, (event) => {
+  renderer.on(CliRenderEvents9.RENDER_ERROR, (event) => {
     void fail(event.error);
   });
-  renderer.on(CliRenderEvents7.HANDLER_ERROR, (event) => {
+  renderer.on(CliRenderEvents9.HANDLER_ERROR, (event) => {
     void fail(event.error);
   });
   renderer.on("error", (event) => {