omnius 1.0.863 → 1.0.865

package/dist/tui/native/worker.js

@@ -2,19 +2,19 @@
 import { createWriteStream } from "node:fs";
 import { createInterface } from "node:readline";
 import { PassThrough } from "node:stream";
-import { CliRenderEvents as CliRenderEvents4, NativeSession, RGBA as RGBA3, createCliRenderer } from "@opentui/core";
+import { CliRenderEvents as CliRenderEvents6, NativeSession, RGBA as RGBA3, createCliRenderer } from "@opentui/core";
 
 // packages/cli/src/tui/native/components/frontend.ts
 import {
-  BoxRenderable as BoxRenderable4,
-  CliRenderEvents as CliRenderEvents2,
+  BoxRenderable as BoxRenderable6,
+  CliRenderEvents as CliRenderEvents4,
   EmbeddedTerminalRenderable as EmbeddedTerminalRenderable2,
   ScrollBoxRenderable as ScrollBoxRenderable4,
   SyntaxStyle as SyntaxStyle2,
   TabSelectRenderable,
   TextareaRenderable as TextareaRenderable2,
-  TextRenderable as TextRenderable4,
-  TextAttributes as TextAttributes6,
+  TextRenderable as TextRenderable5,
+  TextAttributes as TextAttributes7,
   createClipboard,
   createHostClipboard,
   createRendererClipboardAdapter
@@ -171,6 +171,215 @@ function installDefaultSelectionContrast(renderer2) {
   return dispose;
 }
 
+// packages/cli/src/tui/native/components/code.ts
+var aliases = {
+  js: "javascript",
+  jsx: "javascript",
+  ts: "typescript",
+  tsx: "typescriptreact",
+  py: "python",
+  sh: "bash",
+  shell: "bash",
+  yml: "yaml",
+  jsonl: "json",
+  json5: "json",
+  jsonc: "json"
+};
+function nativeCodeLanguage(language) {
+  const name = language?.trim().split(/\s+/)[0]?.toLowerCase();
+  return name ? aliases[name] ?? name : void 0;
+}
+function prettyNativeJson(source) {
+  try {
+    JSON.parse(source);
+  } catch {
+    return void 0;
+  }
+  let compact = "", quoted = false, escaped = false;
+  for (const char of source) {
+    if (quoted || !/[\t\r\n ]/.test(char)) compact += char;
+    if (quoted) {
+      if (escaped) escaped = false;
+      else if (char === "\\") escaped = true;
+      else if (char === '"') quoted = false;
+    } else if (char === '"') quoted = true;
+  }
+  let result = "", depth = 0;
+  quoted = escaped = false;
+  const newline = () => "\n" + "  ".repeat(depth);
+  for (let index = 0; index < compact.length; index++) {
+    const char = compact[index];
+    if (quoted) {
+      result += char;
+      if (escaped) escaped = false;
+      else if (char === "\\") escaped = true;
+      else if (char === '"') quoted = false;
+    } else if (char === '"') {
+      quoted = true;
+      result += char;
+    } else if (char === "{" || char === "[") {
+      result += char;
+      depth++;
+      if (compact[index + 1] !== (char === "{" ? "}" : "]"))
+        result += newline();
+    } else if (char === "}" || char === "]") {
+      depth--;
+      if (compact[index - 1] !== (char === "}" ? "{" : "["))
+        result += newline();
+      result += char;
+    } else if (char === ",") result += char + newline();
+    else if (char === ":") result += ": ";
+    else result += char;
+  }
+  return result;
+}
+function nativeCodeContent(source, language) {
+  const selected = nativeCodeLanguage(language);
+  if (selected === "json" || !selected && /^[\s]*[\[{]/.test(source)) {
+    const pretty = prettyNativeJson(source);
+    if (pretty !== void 0) return { content: pretty, language: "json" };
+  }
+  return { content: source, language: selected };
+}
+function nativeCodeHighlights(source) {
+  const highlights = [];
+  const tokens = /("(?:\\.|[^"\\])*"?|'(?:\\.|[^'\\])*'?|`(?:\\.|[^`\\])*`?)|(\/\/[^\n]*|\/\*[\s\S]*?(?:\*\/|$)|\#[^\n]*)|\b(true|false|null|None|True|False|nil)\b|\b(const|let|var|function|class|def|return|if|else|elif|for|while|in|import|from|export|async|await|try|catch|except|throw|raise|new|public|private|static|void|int|bool|struct|enum|fn|pub|use|match|impl|package|func|select|switch|case|break|continue|end|do|then|fi|done)\b|(?<![\w])(-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)|([{}\[\](),:;])/g;
+  for (const match of source.matchAll(tokens)) {
+    const start = match.index, end = start + match[0].length;
+    const group = match[1] ? /^\s*:/.test(source.slice(end)) ? "property" : "string" : match[2] ? "comment" : match[3] ? "constant" : match[4] ? "keyword" : match[5] ? "number" : "punctuation";
+    highlights.push([start, end, group]);
+  }
+  return highlights;
+}
+function installNativeSyntax(syntax, colors) {
+  const base = { fg: colors.foreground, bg: colors.background };
+  for (const [name, attributes] of Object.entries({
+    default: {},
+    conceal: { dim: true },
+    "markup.heading": { bold: true },
+    "markup.strong": { bold: true },
+    "markup.italic": { italic: true },
+    "markup.link": { underline: true },
+    "markup.link.url": { dim: true },
+    "markup.raw": {},
+    "markup.list": { dim: true },
+    "markup.quote": { dim: true },
+    comment: { dim: true, italic: true },
+    keyword: { bold: true },
+    property: { bold: true },
+    "string.special.key": { bold: true },
+    string: { italic: true },
+    "string.escape": { bold: true },
+    number: { bold: true },
+    boolean: { bold: true },
+    constant: { bold: true },
+    function: { bold: true },
+    type: { underline: true },
+    punctuation: { dim: true },
+    operator: {},
+    variable: {},
+    tag: { bold: true },
+    attribute: { italic: true }
+  }))
+    syntax.registerStyle(name, { ...base, ...attributes });
+}
+function nativeMarkdownSections(owner, source, streaming = false) {
+  const bare = !source.includes("\n```") && !source.includes("\n~~~") && /^[\s]*[\[{]/.test(source) ? prettyNativeJson(source) : void 0;
+  if (bare !== void 0)
+    return [
+      {
+        id: `${owner}:json`,
+        kind: "code",
+        title: "JSON",
+        language: "json",
+        text: bare,
+        collapsible: true,
+        streaming
+      }
+    ];
+  const rows = source.split("\n"), offsets = [];
+  let offset = 0;
+  for (const row of rows) {
+    offsets.push(offset);
+    offset += row.length + 1;
+  }
+  const output = [], stack = [
+    { level: 0, children: output }
+  ];
+  let prose = [], proseStart = 0, segmented = false;
+  const current = () => stack.at(-1).children;
+  const flush = () => {
+    if (prose.join("\n").trim())
+      current().push({
+        id: `${owner}:prose:${proseStart}`,
+        kind: "markdown",
+        text: prose.join("\n"),
+        streaming
+      });
+    prose = [];
+  };
+  for (let index = 0; index < rows.length; index++) {
+    const row = rows[index];
+    const fence = row.match(/^([ >]*)(`{3,}|~{3,})([^`]*)$/);
+    if (fence) {
+      flush();
+      segmented = true;
+      const start = offsets[index], contents = [], marker = fence[2];
+      const quoteDepth = (fence[1].match(/>/g) ?? []).length;
+      const indentation = Math.max(
+        0,
+        fence[1].split(">").at(-1).length - (quoteDepth ? 1 : 0)
+      );
+      const containerContent = (line) => {
+        for (let depth = 0; depth < quoteDepth; depth++)
+          line = line.replace(/^ {0,3}> ?/, "");
+        return line.replace(new RegExp(`^ {0,${indentation}}`), "");
+      };
+      while (++index < rows.length) {
+        const line = containerContent(rows[index]);
+        const closing = line.match(/^ {0,3}(`{3,}|~{3,})\s*$/);
+        if (closing && closing[1][0] === marker[0] && closing[1].length >= marker.length)
+          break;
+        contents.push(line);
+      }
+      const code = nativeCodeContent(contents.join("\n"), fence[3]);
+      current().push({
+        id: `${owner}:code:${start}`,
+        kind: "code",
+        title: code.language?.toUpperCase() ?? "CODE",
+        language: code.language,
+        text: code.content,
+        collapsible: true,
+        streaming: streaming && index >= rows.length
+      });
+      continue;
+    }
+    const atx = row.match(/^ {0,3}(#{1,6})(?:\s+(.*?)\s*#*\s*|\s*)$/);
+    const setext = row.trim() && rows[index + 1]?.match(/^ {0,3}(=+|-+)\s*$/);
+    if (atx || setext) {
+      flush();
+      segmented = true;
+      const level = atx ? atx[1].length : setext[1][0] === "=" ? 1 : 2;
+      while (stack.length > 1 && stack.at(-1).level >= level) stack.pop();
+      const section = {
+        id: `${owner}:section:${offsets[index]}`,
+        kind: "column",
+        title: atx ? atx[2] ?? "" : row.trim(),
+        collapsible: true,
+        children: []
+      };
+      current().push(section);
+      stack.push({ level, children: section.children });
+      if (!atx) index++;
+    } else {
+      if (!prose.length) proseStart = offsets[index];
+      prose.push(row);
+    }
+  }
+  flush();
+  return segmented ? output : void 0;
+}
+
 // packages/cli/src/tui/native/components/blocks.ts
 function nativeProgressText(value, working = false) {
   if (value === void 0 || !Number.isFinite(value)) return `[············] ${working ? "working" : "pending"}`;
@@ -212,6 +421,7 @@ var NativeBlockView = class {
   text;
   body;
   children;
+  markdownSections;
   actions;
   progress;
   image;
@@ -314,14 +524,31 @@ var NativeBlockView = class {
         flexShrink: 0,
         internalBlockMode: "top-level",
         conceal: true,
-        tableOptions: { style: "columns", widthMode: "full", wrapMode: "word", selectable: true }
+        tableOptions: { style: "columns", widthMode: "full", wrapMode: "word", selectable: true },
+        renderNode: (token) => {
+          if (token.type !== "code") return;
+          const value = nativeCodeContent(token.text, token.lang);
+          return new CodeRenderable(renderer2, {
+            content: value.content,
+            filetype: value.language ?? "text",
+            syntaxStyle: syntax,
+            fg: colors.foreground,
+            bg: colors.background,
+            width: "100%",
+            flexShrink: 0,
+            wrapMode: "word",
+            selectable: true,
+            streaming: this.spec.streaming ?? false,
+            onHighlight: (highlights, context) => highlights.length ? void 0 : nativeCodeHighlights(context.content)
+          });
+        }
       });
       this.body.add(this.text);
     } else if (spec.kind === "code") {
       this.text = new CodeRenderable(renderer2, {
         id: `code:${spec.id}`,
         content: "",
-        filetype: spec.language,
+        filetype: spec.language ?? "text",
         syntaxStyle: syntax,
         fg: colors.foreground,
         bg: colors.background,
@@ -330,7 +557,8 @@ var NativeBlockView = class {
         streaming: spec.streaming ?? false,
         selectable: true,
         wrapMode: "word",
-        drawUnstyledText: true
+        drawUnstyledText: true,
+        onHighlight: (highlights, context) => highlights.length ? void 0 : nativeCodeHighlights(context.content)
       });
       this.body.add(this.text);
     } else if (spec.text !== void 0) {
@@ -371,6 +599,8 @@ var NativeBlockView = class {
   }
   reset() {
     this.children?.destroy();
+    this.markdownSections?.destroy();
+    this.markdownSections = void 0;
     if (this.terminal) this.context.terminals.delete(this.spec.id);
     for (const child of [...this.root.getChildren()]) child.destroyRecursively();
     this.title = this.text = this.body = this.actions = this.progress = this.image = this.terminal = void 0;
@@ -394,11 +624,21 @@ var NativeBlockView = class {
       this.title.focusable = Boolean(spec.collapsible);
     }
     if (this.body) this.body.visible = !this.collapsed;
+    const sections = spec.kind === "markdown" ? nativeMarkdownSections(spec.id, plainText(spec.text), spec.streaming) : void 0;
+    if (this.text && spec.kind === "markdown") this.text.visible = !sections;
+    if (sections && this.body) {
+      this.markdownSections ??= new NativeBlockList(this.context, this.body);
+      this.markdownSections.replace(sections);
+    } else if (this.markdownSections) {
+      this.markdownSections.destroy();
+      this.markdownSections = void 0;
+    }
     if (this.text instanceof TextRenderable) this.text.content = styledText(spec.kind === "image" ? spec.text ?? "Image unavailable" : spec.text);
     else if (this.text instanceof MarkdownRenderable || this.text instanceof CodeRenderable) {
-      this.text.content = plainText(spec.text);
+      const code = this.text instanceof CodeRenderable ? nativeCodeContent(plainText(spec.text), spec.language) : void 0;
+      this.text.content = sections ? "" : code?.content ?? plainText(spec.text);
       this.text.streaming = spec.streaming ?? false;
-      if (this.text instanceof CodeRenderable) this.text.filetype = spec.language;
+      if (this.text instanceof CodeRenderable) this.text.filetype = code?.language ?? "text";
     }
     if (this.image && spec.imagePath && this.image.source !== spec.imagePath) this.image.source = spec.imagePath;
     if (this.terminal) this.terminal.height = spec.height ?? 14;
@@ -470,9 +710,11 @@ var NativeBlockView = class {
       action.bg = colors.background;
     }
     this.children?.applyTheme();
+    this.markdownSections?.applyTheme();
   }
   destroy() {
     this.children?.destroy();
+    this.markdownSections?.destroy();
     if (this.terminal) this.context.terminals.delete(this.spec.id);
     this.root.destroyRecursively();
   }
@@ -532,7 +774,7 @@ var NativeBlockList = class {
 
 // packages/cli/src/tui/native/components/modals.ts
 import {
-  BoxRenderable as BoxRenderable2,
+  BoxRenderable as BoxRenderable3,
   InputRenderable,
   ScrollBoxRenderable as ScrollBoxRenderable2,
   TextareaRenderable,
@@ -688,7 +930,7 @@ var NativeSelectRenderable = class extends SelectRenderable {
 };
 
 // packages/cli/src/tui/native/components/corner-frame.ts
-import { RenderableEvents as RenderableEvents2, TextAttributes as TextAttributes3 } from "@opentui/core";
+import { BoxRenderable as BoxRenderable2, CliRenderEvents as CliRenderEvents2, RenderableEvents as RenderableEvents2, TextAttributes as TextAttributes3 } from "@opentui/core";
 function drawCornerFrame(buffer, panel, colors, progress = 1) {
   const { x, y, width, height } = panel;
   if (width <= 0 || height <= 0) return;
@@ -722,43 +964,122 @@ function drawCornerFrame(buffer, panel, colors, progress = 1) {
   }
 }
 var NativeCornerFrame = class {
-  constructor(panel, colors, renderer2) {
+  constructor(panel, colors, renderer2, container = panel.parent) {
     this.panel = panel;
     this.colors = colors;
     this.renderer = renderer2;
-    this.previousRender = panel.renderAfter;
-    this.render = (buffer, deltaTime) => {
-      this.previousRender?.call(panel, buffer, deltaTime);
-      drawCornerFrame(buffer, panel, this.colors, this.progress);
+    this.container = container;
+    this.chrome = new BoxRenderable2(renderer2, {
+      id: `${panel.id}:corners`,
+      position: "absolute",
+      left: 0,
+      top: 0,
+      width: 1,
+      height: 1,
+      backgroundColor: colors.background,
+      shouldFill: true,
+      zIndex: 0,
+      visible: false
+    });
+    this.chrome.renderAfter = (buffer) => {
+      drawCornerFrame(buffer, this.chrome, this.colors, this.progress);
+      if (this.progress < 0.1 && this.chrome.width >= 3 && this.chrome.height >= 3)
+        buffer.drawText("■", this.chrome.x + Math.floor(this.chrome.width / 2), this.chrome.y + Math.floor(this.chrome.height / 2), this.colors.foreground, this.colors.background);
+      this.painted = true;
     };
-    panel.renderAfter = this.render;
+    (container ?? renderer2.root).add(this.chrome, 0);
+    panel.border = false;
+    panel.shouldFill = false;
+    panel.zIndex = 1;
+    panel.opacity = this.reduced ? 1 : 0;
     panel.once(RenderableEvents2.DESTROYED, this.destroy);
-    if (process.env["OMNIUS_TUI_REDUCE_MOTION"] === "1" || process.env["REDUCE_MOTION"] === "1") this.progress = 1;
-    else {
-      let frame = 0;
-      const advance = () => {
-        if (this.disposed) return;
-        this.progress = ++frame / 4;
-        renderer2.requestRender();
-        if (frame < 4) this.timer = setTimeout(advance, 32);
-        else this.timer = void 0;
-      };
-      this.timer = setTimeout(advance, 32);
+    if (this.reduced) {
+      this.progress = 1;
+      this.phase = "open";
     }
+    renderer2.on(CliRenderEvents2.FRAME, this.onFrame);
   }
   panel;
   colors;
   renderer;
+  container;
+  chrome;
   progress = 0;
   timer;
   disposed = false;
-  previousRender;
-  render;
+  phase = "opening";
+  started = false;
+  painted = false;
+  geometry = "";
+  reduced = process.env["OMNIUS_TUI_REDUCE_MOTION"] === "1" || process.env["REDUCE_MOTION"] === "1";
   get animating() {
-    return this.timer !== void 0;
+    return !this.disposed && (this.phase === "opening" || this.phase === "closing");
+  }
+  get closing() {
+    return this.phase === "closing" || this.phase === "closed";
+  }
+  get bounds() {
+    return this.chrome;
   }
   setColors(colors) {
     this.colors = colors;
+    this.chrome.backgroundColor = colors.background;
+  }
+  onFrame = () => {
+    this.layout();
+    if (!this.started && this.painted && this.panel.width > 0 && this.panel.height > 0) {
+      this.started = true;
+      if (this.phase === "opening") this.animate(1, 10);
+    }
+  };
+  layout() {
+    if (this.disposed || this.panel.width < 1 || this.panel.height < 1) return;
+    const target = this.panel;
+    const width = Math.round(Math.min(5, target.width) + (target.width - Math.min(5, target.width)) * this.progress);
+    const height = Math.round(Math.min(3, target.height) + (target.height - Math.min(3, target.height)) * this.progress);
+    const left = target.x - (this.container?.x ?? 0) + Math.floor((target.width - width) / 2);
+    const top = target.y - (this.container?.y ?? 0) + Math.floor((target.height - height) / 2);
+    const geometry = `${left}:${top}:${width}:${height}`;
+    if (this.geometry === geometry) return;
+    this.geometry = geometry;
+    this.chrome.left = left;
+    this.chrome.top = top;
+    this.chrome.width = width;
+    this.chrome.height = height;
+    this.chrome.visible = true;
+    this.renderer.requestRender();
+  }
+  animate(to, steps, done) {
+    if (this.timer) clearTimeout(this.timer);
+    const from = this.progress;
+    let step = 0;
+    const advance = () => {
+      if (this.disposed) return;
+      const t = ++step / steps;
+      this.progress = from + (to - from) * (t * t * (3 - 2 * t));
+      this.layout();
+      this.renderer.requestRender();
+      if (step < steps) this.timer = setTimeout(advance, 16);
+      else if (to === 1) {
+        this.phase = "open";
+        this.panel.opacity = 1;
+        this.timer = void 0;
+      } else this.timer = setTimeout(() => {
+        this.timer = void 0;
+        this.phase = "closed";
+        done?.();
+      }, 32);
+    };
+    this.timer = setTimeout(advance, 16);
+  }
+  close(done) {
+    if (this.closing || this.disposed) return;
+    this.phase = "closing";
+    this.panel.opacity = 0;
+    if (this.reduced) {
+      this.phase = "closed";
+      done();
+    } else this.animate(0, 8, done);
   }
   destroy = () => {
     if (this.disposed) return;
@@ -766,7 +1087,8 @@ var NativeCornerFrame = class {
     if (this.timer !== void 0) clearTimeout(this.timer);
     this.timer = void 0;
     this.panel.off(RenderableEvents2.DESTROYED, this.destroy);
-    if (this.panel.renderAfter === this.render) this.panel.renderAfter = this.previousRender;
+    this.renderer.off(CliRenderEvents2.FRAME, this.onFrame);
+    this.chrome.destroyRecursively();
   };
 };
 
@@ -777,7 +1099,7 @@ var NativeModalView = class {
     this.close = close2;
     this.spec = spec;
     const { renderer: renderer2, colors } = context;
-    this.root = new BoxRenderable2(renderer2, {
+    this.root = new BoxRenderable3(renderer2, {
       id: `modal:${spec.id}`,
       position: "absolute",
       top: 0,
@@ -789,24 +1111,31 @@ var NativeModalView = class {
       alignItems: "center",
       zIndex: 100,
       backgroundColor: "transparent",
-      shouldFill: false
+      shouldFill: false,
+      onMouseDown: (event) => {
+        const bounds = this.frame.bounds;
+        if (event.button === 0 && (event.x < bounds.x || event.x >= bounds.x + bounds.width || event.y < bounds.y || event.y >= bounds.y + bounds.height)) {
+          this.cancel();
+          event.preventDefault();
+          event.stopPropagation();
+        }
+      }
     });
-    this.panel = new BoxRenderable2(renderer2, {
+    this.panel = new BoxRenderable3(renderer2, {
       id: `modal-panel:${spec.id}`,
       flexDirection: "column",
       width: "94%",
       maxHeight: "94%",
-      border: true,
-      borderStyle: "single",
-      borderColor: colors.border,
+      border: false,
       backgroundColor: colors.background,
-      paddingX: 1,
-      paddingY: 0,
+      shouldFill: false,
+      paddingX: 2,
+      paddingY: 1,
       focusable: true,
       onMouseDown: () => this.focus()
     });
-    this.frame = new NativeCornerFrame(this.panel, colors, renderer2);
     this.root.add(this.panel);
+    this.frame = new NativeCornerFrame(this.panel, colors, renderer2, this.root);
     this.breadcrumb = this.addText(`modal-breadcrumb:${spec.id}`);
     this.heading = this.addText(`modal-title:${spec.id}`);
     this.description = this.addText(`modal-description:${spec.id}`);
@@ -838,13 +1167,13 @@ var NativeModalView = class {
         selectable: false
       });
       this.panel.add(this.progress);
-      const progressBlocks = new BoxRenderable2(renderer2, { id: `modal-progress-blocks:${spec.id}`, flexDirection: "column", width: "100%" });
+      const progressBlocks = new BoxRenderable3(renderer2, { id: `modal-progress-blocks:${spec.id}`, flexDirection: "column", width: "100%" });
       this.panel.add(progressBlocks);
       this.blocks = new NativeBlockList(this.modalContext(), progressBlocks);
     }
     this.error = this.addText(`modal-error:${spec.id}`);
     this.hints = this.addText(`modal-hints:${spec.id}`);
-    this.actions = new BoxRenderable2(renderer2, { id: `modal-actions:${spec.id}`, flexDirection: "row", gap: 1, width: "100%", marginTop: 0 });
+    this.actions = new BoxRenderable3(renderer2, { id: `modal-actions:${spec.id}`, flexDirection: "row", gap: 1, width: "100%", marginTop: 0 });
     this.panel.add(this.actions);
     this.update(spec);
   }
@@ -1045,6 +1374,7 @@ var NativeModalView = class {
     this.context.emit({ type: "modal-action", id: this.spec.id, action, key: current?.item.key, index: current?.index, value });
   }
   confirm() {
+    if (this.frame.closing) return;
     if (this.spec.kind === "progress") {
       this.emitAction("enter");
       return;
@@ -1059,6 +1389,7 @@ var NativeModalView = class {
     this.close(this.spec.id, { confirmed: true, key: current?.item.key ?? null, index: current?.index ?? -1, ...value === void 0 ? {} : { value } });
   }
   cancel(action = "cancel") {
+    if (this.frame.closing) return;
     if (this.spec.deferSelection) {
       this.emitAction(action);
       return;
@@ -1066,6 +1397,7 @@ var NativeModalView = class {
     this.close(this.spec.id, { confirmed: false, key: this.spec.breadcrumbs?.length ? "__back__" : null, index: this.current()?.index ?? -1 });
   }
   focus() {
+    if (this.frame.closing) return;
     if (this.filterInput) this.filterInput.focus();
     else if (this.editor && !this.spec.secret) this.editor.focus();
     else if (this.document) this.document.focus();
@@ -1095,6 +1427,7 @@ var NativeModalView = class {
       key.stopPropagation();
       return true;
     };
+    if (this.frame.closing) return consume();
     if (key.eventType === "release") return false;
     if (key.name === "escape" || key.ctrl && key.name === "c") {
       this.cancel();
@@ -1163,6 +1496,11 @@ var NativeModalView = class {
     return false;
   }
   handlePaste(event) {
+    if (this.frame.closing) {
+      event.preventDefault();
+      event.stopPropagation();
+      return true;
+    }
     const text = new TextDecoder().decode(event.bytes);
     if (this.overBudget(text, this.filterInput?.plainText ?? this.editor?.plainText ?? "")) {
       event.preventDefault();
@@ -1188,7 +1526,6 @@ var NativeModalView = class {
   applyTheme() {
     const colors = this.context.colors;
     this.panel.backgroundColor = colors.background;
-    this.panel.borderColor = colors.border;
     this.frame.setColors(colors);
     this.heading.fg = colors.foreground;
     this.heading.attributes = 1;
@@ -1247,7 +1584,7 @@ var NativeModalStack = class {
   dimUnderlay = (buffer) => {
     const panel = this.active?.panel;
     if (!panel || panel.isDestroyed || !panel.visible) return;
-    const { x, y, width, height } = panel;
+    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)
@@ -1278,17 +1615,19 @@ var NativeModalStack = class {
   close(id, result, notify = false) {
     const view = this.byId.get(id);
     if (!view) return;
-    const wasActive = view === this.active;
-    view.destroy();
-    this.byId.delete(id);
-    this.views = this.views.filter((candidate) => candidate !== view);
-    if (wasActive) {
-      if (this.active) {
-        this.active.root.visible = true;
-        this.active.focus();
-      } else this.restoreFocus();
-    }
-    if (notify) this.context.emit({ type: "modal-result", id, result });
+    view.frame.close(() => {
+      const wasActive = view === this.active;
+      view.destroy();
+      this.byId.delete(id);
+      this.views = this.views.filter((candidate) => candidate !== view);
+      if (wasActive) {
+        if (this.active) {
+          this.active.root.visible = true;
+          this.active.focus();
+        } else this.restoreFocus();
+      }
+      if (notify) this.context.emit({ type: "modal-result", id, result });
+    });
   }
   applyTheme() {
     for (const view of this.views) view.applyTheme();
@@ -1303,7 +1642,7 @@ var NativeModalStack = class {
 
 // packages/cli/src/tui/native/components/instruments.ts
 import {
-  BoxRenderable as BoxRenderable3,
+  BoxRenderable as BoxRenderable4,
   RGBA as RGBA2,
   RenderableEvents as RenderableEvents3,
   ScrollBoxRenderable as ScrollBoxRenderable3,
@@ -1311,6 +1650,58 @@ import {
   TextRenderable as TextRenderable3
 } from "@opentui/core";
 
+// packages/cli/src/tui/native/components/device-history.ts
+var DeviceHistory = class {
+  samples = [];
+  append(sample) {
+    if (!Number.isFinite(sample.at) || sample.at <= (this.samples.at(-1)?.at ?? 0)) return;
+    this.samples.push(sample);
+    if (this.samples.length > 120) this.samples.splice(0, this.samples.length - 120);
+  }
+};
+function deviceHistorySparkline(samples, field, width) {
+  const columns = Math.max(0, Math.floor(width));
+  const latest = samples.at(-1)?.at;
+  const values = Array(columns).fill(void 0);
+  if (latest !== void 0) for (const sample of samples) {
+    const x = columns - 1 - Math.round((latest - sample.at) / 2e3);
+    if (x >= 0 && x < columns) values[x] = sample[field];
+  }
+  return values.map((value) => value === void 0 || !Number.isFinite(value) || value < 0 ? " " : "▁▂▃▄▅▆▇█"[Math.round(Math.min(100, value) * 7 / 100)]).join("");
+}
+function deviceHistoryGraph(samples, field, width) {
+  const columns = Math.max(0, Math.floor(width) - 5), pixels = columns * 2;
+  if (columns < 2) return "";
+  const cells = Array.from({ length: 3 }, () => Array(columns).fill(0));
+  const latest = samples.at(-1)?.at;
+  const dots = [[1, 8], [2, 16], [4, 32], [64, 128]];
+  const point = (x, y) => {
+    if (x < 0 || x >= pixels || y < 0 || y >= 12) return;
+    cells[Math.floor(y / 4)][Math.floor(x / 2)] |= dots[y % 4][x % 2];
+  };
+  let previous;
+  if (latest !== void 0) for (const sample of samples) {
+    const value = sample[field];
+    const x = pixels - 1 - Math.round((latest - sample.at) / 1e3);
+    if (x < 0) {
+      previous = void 0;
+      continue;
+    }
+    if (value === void 0 || !Number.isFinite(value) || value < 0) {
+      previous = void 0;
+      continue;
+    }
+    const y = Math.round(11 * (1 - Math.min(100, value) / 100));
+    if (previous && sample.at - previous.at <= 5e3) {
+      const distance = Math.max(1, Math.abs(x - previous.x), Math.abs(y - previous.y));
+      for (let step = 0; step <= distance; step++) point(Math.round(previous.x + (x - previous.x) * step / distance), Math.round(previous.y + (y - previous.y) * step / distance));
+    } else point(x, y);
+    previous = { x, y, at: sample.at };
+  }
+  const labels = ["100%│", " 50%│", "  0%└"];
+  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/terminal-cells.ts
 var graphemes = new Intl.Segmenter(void 0, { granularity: "grapheme" });
 var extendedPictographic = /\p{Extended_Pictographic}/u;
@@ -1390,6 +1781,13 @@ function terminalCellWidth(value) {
 
 // packages/cli/src/tui/native/components/instrument-format.ts
 var graphemes2 = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+function formatSignalDivider(width) {
+  const cells = Math.max(0, Math.floor(width));
+  if (cells < 32) return "─".repeat(cells);
+  const plateau = Math.min(12, Math.max(6, Math.floor(cells / 8)));
+  const left = Math.floor((cells - plateau - 2) / 2);
+  return "▁".repeat(left) + "╱" + "▔".repeat(plateau) + "╲" + "▁".repeat(cells - left - plateau - 2);
+}
 function fitInstrumentText(value, cells, marker = "~") {
   const text = stripTerminalSequences(normalizeTerminalLine(value));
   const width = Math.max(0, Math.floor(cells));
@@ -1551,7 +1949,357 @@ var SignalMeter = class extends TelemetryRow {
     this.update(formatSignalMeter(value, maximum));
   }
 };
-var ChannelMap = class extends BoxRenderable3 {
+var InstrumentDivider = class extends TextRenderable3 {
+  constructor(renderer2, actions) {
+    super(renderer2, {
+      id: "omnius-instrument-divider",
+      width: 1,
+      minWidth: 1,
+      maxWidth: 1,
+      height: "100%",
+      flexGrow: 0,
+      flexShrink: 0,
+      fg: foreground,
+      bg: background,
+      selectable: false,
+      wrapMode: "none",
+      attributes: TextAttributes5.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;
+        event.preventDefault();
+        event.stopPropagation();
+      },
+      onMouseDrag: (event) => {
+        this.handleDrag(event);
+      },
+      onMouseUp: (event) => {
+        this.handleRelease(event);
+      },
+      onMouseDragEnd: (event) => {
+        this.handleRelease(event);
+      },
+      onMouseOver: () => {
+        this.attributes = TextAttributes5.BOLD;
+      },
+      onMouseOut: () => {
+        if (!this.held) this.attributes = this.focused ? TextAttributes5.INVERSE : TextAttributes5.DIM;
+      },
+      onKeyDown: (key) => {
+        if (key.eventType === "release") return;
+        if (key.name === "return" || key.sequence === " ") this.actions.toggle();
+        else if (key.name === "left" || key.name === "right") this.actions.resize(this.x + (key.name === "left" ? -1 : 1) * (key.shift ? 8 : 2));
+        else return;
+        key.preventDefault();
+        key.stopPropagation();
+      }
+    });
+    this.actions = actions;
+    this.focusable = true;
+    this.on(RenderableEvents3.FOCUSED, () => {
+      this.attributes = TextAttributes5.INVERSE;
+    });
+    this.on(RenderableEvents3.BLURRED, () => {
+      this.attributes = TextAttributes5.DIM;
+    });
+  }
+  actions;
+  collapsed = false;
+  held = false;
+  moved = false;
+  startX = 0;
+  setCollapsed(collapsed) {
+    this.collapsed = collapsed;
+    this.refresh();
+  }
+  handleDrag(event) {
+    if (!this.held) return;
+    if (event.x !== this.startX) this.moved = true;
+    if (this.moved) this.actions.resize(event.x);
+    event.preventDefault();
+    event.stopPropagation();
+  }
+  handleRelease(event) {
+    if (!this.held) return;
+    this.release(event.x);
+    event.preventDefault();
+    event.stopPropagation();
+  }
+  onResize(width, height) {
+    super.onResize(width, height);
+    this.refresh();
+  }
+  refresh() {
+    const rows = Array.from({ length: Math.max(0, this.height) }, (_, row) => row === Math.floor(this.height / 2) ? this.collapsed ? "‹" : "›" : "│");
+    const text = rows.join("\n");
+    if (this.plainText !== text) this.content = text;
+  }
+  release(column) {
+    if (this.moved) this.actions.resize(column);
+    else this.actions.toggle();
+    this.held = false;
+    this.actions.finish?.();
+    this.attributes = this.focused ? TextAttributes5.INVERSE : TextAttributes5.DIM;
+  }
+};
+var DeviceMonitor = class extends BoxRenderable4 {
+  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 TextRenderable3(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 TextRenderable3(renderer2, { id: "omnius-devices:load-history", content: "", width: "100%", height: 1, flexShrink: 0, fg: foreground, bg: background, wrapMode: "none", truncate: true });
+    this.compactMemory = new TextRenderable3(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, {
+      id: "omnius-devices:scroll",
+      width: "100%",
+      flexGrow: 1,
+      flexShrink: 1,
+      minHeight: 0,
+      visible: false,
+      scrollY: true,
+      scrollX: false,
+      viewportCulling: true,
+      horizontalScrollbarOptions: { visible: false },
+      verticalScrollbarOptions: { showArrows: false },
+      contentOptions: { flexDirection: "column" }
+    });
+    this.add(this.scroll);
+    this.notes = new TextRenderable3(renderer2, {
+      id: "omnius-devices:notes",
+      content: "",
+      width: "100%",
+      height: 1,
+      flexShrink: 0,
+      fg: foreground,
+      bg: background,
+      wrapMode: "none",
+      truncate: true
+    });
+    this.scroll.add(this.notes);
+    const controls = new BoxRenderable4(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");
+    });
+    this.status = this.button(renderer2, "omnius-devices:status", "STATUS", () => this.action?.("/gpu status"));
+    controls.add(this.policy);
+    controls.add(this.status);
+  }
+  action;
+  heading;
+  scroll;
+  summary;
+  compactLoad;
+  compactMemory;
+  policy;
+  status;
+  notes;
+  expanded = false;
+  availableRows = 100;
+  snapshot;
+  historySource = "";
+  rows = /* @__PURE__ */ new Map();
+  button(renderer2, id, label, activate) {
+    const button = new TextRenderable3(renderer2, {
+      id,
+      content: label,
+      height: 1,
+      flexShrink: 0,
+      fg: foreground,
+      bg: background,
+      selectable: false,
+      wrapMode: "none",
+      truncate: true,
+      onMouseDown: (event) => {
+        if (event.button === 0 && button.focusable) {
+          button.focus();
+          activate();
+          event.preventDefault();
+          event.stopPropagation();
+        }
+      },
+      onKeyDown: (key) => {
+        if (key.eventType !== "release" && (key.name === "return" || key.sequence === " ") && button.focusable) {
+          activate();
+          key.preventDefault();
+          key.stopPropagation();
+        }
+      }
+    });
+    button.focusable = Boolean(this.action);
+    button.on(RenderableEvents3.FOCUSED, () => {
+      button.attributes = TextAttributes5.INVERSE;
+    });
+    button.on(RenderableEvents3.BLURRED, () => {
+      button.attributes = button.focusable ? 0 : TextAttributes5.DIM;
+    });
+    return button;
+  }
+  canSelect() {
+    return Boolean(this.action && this.snapshot?.selectionAvailable && !this.snapshot.selectionLocked);
+  }
+  canSelectDevice(device) {
+    return this.canSelect() && device.eligible === true && !device.unifiedMemory && /^GPU-[\w-]+$/.test(device.uuid);
+  }
+  update(snapshot) {
+    this.snapshot = snapshot;
+    this.visible = Boolean(snapshot) && this.availableRows >= 3;
+    const historySource = `${snapshot?.source}:${snapshot?.local}`;
+    if (this.historySource !== historySource) {
+      for (const row of this.rows.values()) row.history.samples.splice(0);
+      this.historySource = historySource;
+    }
+    const allowed = this.canSelect();
+    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;
+    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();
+      row.root.destroyRecursively();
+      this.rows.delete(uuid);
+    }
+    for (const device of snapshot?.devices ?? []) {
+      let row = this.rows.get(device.uuid);
+      if (!row) {
+        const root = new BoxRenderable4(this._ctx, {
+          id: `omnius-device:${device.uuid}`,
+          width: "100%",
+          flexDirection: "column",
+          flexShrink: 0,
+          onSizeChange: () => {
+            if (!row) return;
+            for (const child of [row.title, row.load, row.memory, row.reason, row.loadGraph, row.memoryGraph]) child.width = row.root.width;
+            this.refresh();
+          }
+        });
+        const title = this.button(this._ctx, `${root.id}:select`, "", () => {
+          const current = this.snapshot?.devices.find((item) => item.uuid === device.uuid);
+          if (current && this.canSelectDevice(current)) this.action?.(`/gpu select ${current.uuid}`);
+        });
+        title.width = "100%";
+        title.on(RenderableEvents3.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 TextRenderable3(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 TextRenderable3(this._ctx, {
+          id: `${root.id}:reason`,
+          content: "",
+          width: "100%",
+          height: 1,
+          fg: foreground,
+          bg: background,
+          attributes: TextAttributes5.DIM,
+          wrapMode: "none",
+          truncate: true,
+          visible: false
+        });
+        root.add(title);
+        root.add(load);
+        root.add(loadGraph);
+        root.add(memory);
+        root.add(memoryGraph);
+        root.add(reason);
+        this.scroll.add(root);
+        row = { root, title, load, memory, reason, history, loadGraph, memoryGraph };
+        this.rows.set(device.uuid, row);
+      }
+      if (snapshot?.sampledAt !== void 0) row.history.append({
+        at: snapshot.sampledAt,
+        load: device.utilization,
+        memory: device.memoryUsedMB !== void 0 && device.memoryUsedMB >= 0 && device.memoryTotalMB !== void 0 && device.memoryTotalMB > 0 ? device.memoryUsedMB * 100 / device.memoryTotalMB : void 0
+      });
+      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.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);
+      row.memory.update(`${used}/${total} GiB`, device.unifiedMemory ? "UMA" : "VRAM");
+      row.reason.content = device.policyReason ?? "";
+      row.reason.visible = Boolean(device.policyReason);
+    }
+    this.refresh();
+  }
+  toggle() {
+    this.expanded = !this.expanded;
+    this.scroll.visible = this.expanded;
+    this.scroll.minHeight = this.expanded ? 1 : 0;
+    this.fitHeight(this.availableRows + 2);
+    this.refresh();
+  }
+  fitHeight(railRows) {
+    this.availableRows = Math.max(0, railRows - 2);
+    this.visible = Boolean(this.snapshot) && this.availableRows >= 3;
+    this.minHeight = Math.min(5, this.availableRows);
+    this.maxHeight = this.availableRows;
+    this.summary.visible = this.availableRows >= 5;
+    this.compactLoad.visible = !this.expanded;
+    this.compactMemory.visible = !this.expanded && this.availableRows >= 4;
+    this.height = Math.min(this.availableRows, this.expanded ? Math.min(18, Math.max(6, Math.floor(railRows * 0.6))) : 5);
+  }
+  onResize(width, height) {
+    super.onResize(width, height);
+    this.refresh();
+  }
+  refresh() {
+    if (!this.heading) return;
+    const data = this.snapshot, devices = data?.devices ?? [];
+    this.heading.update(data?.source === "jtop" ? "DEVICES / JETSON" : "DEVICES", this.expanded);
+    const measured = devices.map((device) => device.utilization).filter((value) => value !== void 0 && Number.isFinite(value) && value >= 0);
+    const on = devices.filter((device) => device.enabled === true).length;
+    const policyKnown = devices.every((device) => device.enabled !== void 0);
+    this.summary.content = !devices.length ? data?.source === "unavailable" ? "Telemetry unavailable" : "No local GPUs reported" : `${devices.length} GPU · ${policyKnown ? on : "--"} ON · ${measured.length === devices.length ? Math.round(Math.max(...measured)) : "--"}% PEAK`;
+    this.notes.content = [
+      data?.local === false ? "REMOTE" : void 0,
+      data ? `${data.source.toUpperCase()} · ${data.policy.toUpperCase()} · ${data.broker.toUpperCase()}` : void 0,
+      "2s/col",
+      data?.warnings.length ? `${data.warnings.length} notices` : void 0
+    ].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"]]) {
+      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 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;
+    }
+    for (const device of devices) {
+      const row = this.rows.get(device.uuid);
+      if (!row) continue;
+      const state = device.enabled === void 0 ? "--" : device.enabled ? "ON" : "OFF";
+      row.title.content = formatTelemetryRow(`GPU ${device.index} ${device.name}`, `${state}${device.preferred ? " *" : ""}`, row.root.width, 6);
+      for (const [plot, field] of [[row.loadGraph, "load"], [row.memoryGraph, "memory"]]) {
+        const next = deviceHistoryGraph(row.history.samples, field, row.root.width);
+        if (plot.plainText !== next) plot.content = next;
+      }
+    }
+  }
+  focusTargets() {
+    return !this.visible ? [] : [
+      this.heading,
+      ...this.policy.focusable ? [this.policy] : [],
+      ...this.status.focusable ? [this.status] : [],
+      ...this.expanded ? [...this.rows.values()].map((row) => row.title).filter((title) => title.focusable) : []
+    ];
+  }
+};
+var ChannelMap = class extends BoxRenderable4 {
   constructor(renderer2, id, inspect, reveal) {
     super(renderer2, {
       id,
@@ -1649,16 +2397,23 @@ var ChannelMap = class extends BoxRenderable3 {
     }
   }
 };
-var InstrumentRail = class extends BoxRenderable3 {
+var InstrumentRail = class extends BoxRenderable4 {
   scroll;
   inferenceHeader;
   sessionHeader;
   channels;
+  devices;
   inference;
   session;
   model;
   rows = /* @__PURE__ */ new Map();
   contextMeter;
+  contextHeader;
+  contextDetails;
+  onResize(width, height) {
+    super.onResize(width, height);
+    this.devices?.fitHeight(height);
+  }
   constructor(renderer2, options = {}) {
     const id = options.id ?? "omnius-instruments";
     super(renderer2, {
@@ -1696,7 +2451,7 @@ var InstrumentRail = class extends BoxRenderable3 {
       () => this.reveal(this.inferenceHeader)
     );
     this.scroll.add(this.inferenceHeader);
-    this.inference = new BoxRenderable3(renderer2, {
+    this.inference = new BoxRenderable4(renderer2, {
       id: `${id}:inference-body`,
       width: "100%",
       flexDirection: "column",
@@ -1734,6 +2489,20 @@ var InstrumentRail = class extends BoxRenderable3 {
     );
     this.inference.add(this.contextMeter);
     addRow(this.inference, "state", "STATE");
+    this.contextHeader = new SectionBanner(renderer2, "CONTEXT DETAILS", `${id}:context-details`, () => {
+      this.contextDetails.visible = !this.contextDetails.visible;
+      this.contextHeader.update("CONTEXT DETAILS", this.contextDetails.visible);
+    });
+    this.contextHeader.on(RenderableEvents3.FOCUSED, () => this.reveal(this.contextHeader));
+    this.inference.add(this.contextHeader);
+    this.contextDetails = new BoxRenderable4(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");
+    addRow(this.contextDetails, "headroom", "HEADROOM");
+    addRow(this.contextDetails, "context-tools", "TOOL CALLS");
+    addRow(this.contextDetails, "adversary", "ADVERSARY");
+    addRow(this.contextDetails, "duration", "LAST GEN");
     this.sessionHeader = new SectionBanner(
       renderer2,
       "SESSION / AGENTS",
@@ -1745,7 +2514,7 @@ var InstrumentRail = class extends BoxRenderable3 {
       () => this.reveal(this.sessionHeader)
     );
     this.scroll.add(this.sessionHeader);
-    this.session = new BoxRenderable3(renderer2, {
+    this.session = new BoxRenderable4(renderer2, {
       id: `${id}:session-body`,
       width: "100%",
       flexDirection: "column",
@@ -1767,6 +2536,8 @@ var InstrumentRail = class extends BoxRenderable3 {
     this.session.add(this.channels);
     this.session.visible = false;
     this.sessionHeader.update("SESSION / AGENTS", false);
+    this.devices = new DeviceMonitor(renderer2, options.onAction);
+    this.add(this.devices);
     if (options.colors) this.applyTheme(options.colors);
   }
   update(state) {
@@ -1774,6 +2545,14 @@ var InstrumentRail = class extends BoxRenderable3 {
     const inference = data?.inference;
     const session = data?.session;
     const set = (id, value) => this.rows.get(id).update(value);
+    set("messages", instrumentNumber(inference?.contextMessages));
+    set("headroom", inference?.contextHeadroom !== void 0 && Number.isFinite(inference.contextHeadroom) ? String(Math.round(inference.contextHeadroom)) : "--");
+    set("context-tools", instrumentNumber(inference?.contextToolCalls));
+    set("adversary", instrumentNumber(inference?.contextAdversaryOutcomes));
+    set("duration", inference?.generationDurationMs === void 0 ? "--" : instrumentNumber(inference.generationDurationMs / 1e3, 1, "s"));
+    this.contextHeader.visible = [inference?.contextMessages, inference?.contextHeadroom, inference?.contextToolCalls, inference?.contextAdversaryOutcomes, inference?.generationDurationMs].some((value) => value !== void 0);
+    this.contextDetails.visible = this.contextHeader.visible && this.contextHeader.expanded;
+    this.devices.update(data?.devices);
     set("route", (inference?.route || "UNKNOWN").toUpperCase());
     set("backend", (inference?.backend || "--").toUpperCase());
     const model = `MODEL ${inference?.model || "--"}`;
@@ -1826,6 +2605,7 @@ var InstrumentRail = class extends BoxRenderable3 {
     };
     visit(this);
     styleNativeScrollbars(this.scroll, colors);
+    styleNativeScrollbars(this.devices.scroll, colors);
   }
   toggleSection(id) {
     const header = id === "inference" ? this.inferenceHeader : this.sessionHeader;
@@ -1840,8 +2620,10 @@ var InstrumentRail = class extends BoxRenderable3 {
     if (!this.visible) return [];
     return [
       this.inferenceHeader,
+      ...this.inference.visible && this.contextHeader.visible ? [this.contextHeader] : [],
       this.sessionHeader,
-      ...this.session.visible ? this.channels.focusTargets() : []
+      ...this.session.visible ? this.channels.focusTargets() : [],
+      ...this.devices.focusTargets()
     ];
   }
   focusSection(index = 0) {
@@ -1860,17 +2642,1584 @@ var InstrumentRail = class extends BoxRenderable3 {
   }
 };
 
+// packages/cli/src/tui/command-registry.ts
+var COMMAND_SIGNATURES = [
+  ["/model", "Select from available models"],
+  ["/model <name>", "Switch to a specific model"],
+  ["/models", "List all available models"],
+  ["/endpoint", "Show current endpoint"],
+  ["/endpoint <url>", "Set backend URL (auto-detects type)"],
+  ["/endpoint <url> --auth <t>", "Set endpoint with Bearer auth"],
+  ["/fallback", "Show remote inference fallback mode"],
+  ["/fallback status", "Show remote inference fallback mode"],
+  ["/fallback auto", "Automatically use remote inference after local failure (default)"],
+  ["/fallback manual", "Ask before remote inference after each local failure"],
+  ["/config", "Show current configuration"],
+  ["/color", "Use terminal colors and thin section rules"],
+  ["/color status", "Show terminal appearance preferences"],
+  ["/color frill on|off|toggle|status", "Legacy text ornament preference"],
+  [
+    "/color flow on|off|toggle|status",
+    "Legacy border animation preference"
+  ],
+  ["/theme", "Alias for /color"],
+  ["/setup", "Open guided cloud setup; /setup local opens local model setup"],
+  ["/wizard", "Alias for /setup"],
+  ["/parallel", "Show current Ollama parallel inference slots"],
+  ["/parallel <1-15>", "Set parallel slots (restarts Ollama, max 15)"],
+  ["/gpu", "Select enabled GPUs with arrow keys and Space"],
+  ["/gpu status|reset", "Inspect or reset the host-local GPU policy"],
+  ["/gpu select <UUID>", "Open the GPU policy selector focused on a device"],
+  [
+    "/broker",
+    "Show resource broker status — loaded models, in-flight loads, RAM/VRAM headroom"
+  ],
+  [
+    "/broker evict <host>:<name>",
+    "Force eviction of a tracked model (e.g. /broker evict ollama:moondream)"
+  ],
+  [
+    "/broker threshold <ram|vram|idle> <v>",
+    "Tune broker thresholds (RAM/VRAM in MB, idle in seconds)"
+  ],
+  ["/ollama cleanup", "Dry-run stale Ollama pool process cleanup"],
+  ["/ollama cleanup --execute", "Terminate guarded stale Ollama pool runners"],
+  ["/mcp", "Show MCP server/tool status and controls"],
+  ["/mcp reload", "Reload MCP servers and tools"],
+  ["/indicator", "Start the native system indicator and report readiness"],
+  ["/indicator start", "Start the native system indicator and report readiness"],
+  ["/indicator status", "Report native system indicator readiness and daemon health"],
+  ["/tray", "Alias for /indicator"],
+  ["/tray start", "Alias for /indicator start"],
+  ["/tray status", "Alias for /indicator status"],
+  ["/update", "Check for updates and auto-install"],
+  ["/upgrade", "Alias for /update"],
+  ["/update auto", "Auto-install updates, restart, and resume work (default)"],
+  ["/update manual", "Disable auto-update (only update on /update)"],
+  ["/agents", "Open the agent command center"],
+  [
+    "/update check",
+    "Check for Omnius and Ollama updates without opening the menu"
+  ],
+  ["/update quick", "Install the latest Omnius package non-interactively"],
+  [
+    "/update full",
+    "Run full non-interactive update: package, deps, rebuild, Python, cloudflared"
+  ],
+  ["/voice", "Toggle TTS voice feedback"],
+  [
+    "/voice <model>",
+    "Set voice: glados, overwatch, luxtts:announcer-testchamber03, kokoro, luxtts, misotts, supertonic, or a selected voicebox_* model"
+  ],
+  ["/voice clone <file>", "Set voice clone reference audio (wav/mp3/ogg/flac)"],
+  ["/voice asr", "Open ASR system and model selection"],
+  ["/voice asr status", "Show selected ASR engine/model and activation state"],
+  ["/voice asr list", "List ASR engines, models, and live/file capabilities"],
+  ["/voice asr use <engine> [model]", "Select and activate an installed ASR engine/model"],
+  ["/voice asr setup <engine> [model] [device=N]", "Install pinned ASR runtime/weights and activate on an exact CUDA device"],
+  [
+    "/voice clone glados",
+    "Generate clone ref from GLaDOS for LuxTTS/MisoTTS voice cloning"
+  ],
+  [
+    "/voice clone overwatch",
+    "Generate clone ref from Overwatch for LuxTTS/MisoTTS voice cloning"
+  ],
+  ["/think", "Toggle thinking/reasoning mode (Qwen3, DeepSeek-R1, etc.)"],
+  ["/stream", "Toggle real-time token streaming (earth syntax highlighting)"],
+  ["/tree", "Switch between the action waterfall and an explorable action tree"],
+  ["/tree on|off|status", "Show, hide, or inspect the action-tree presentation"],
+  ["/realtime", "Toggle short spoken-dialogue mode for ASR/TTS-backed chat"],
+  ["/realtime on|off|status", "Set or inspect realtime conversation mode"],
+  ["/mouse", "Toggle terminal mouse tracking"],
+  ["/neovim", "Toggle embedded Neovim editor (Ctrl+N to switch focus)"],
+  ["/neovim <file>", "Open file in embedded Neovim editor"],
+  ["/nvim <file>", "Alias for /neovim <file>"],
+  ["/vim", "Toggle Vim composer editing (Esc normal; i insert)"],
+  ["/vim on|off|status", "Set or inspect Vim composer editing"],
+  [
+    "/dream",
+    "Start dream mode - creative idle exploration (writes to .omnius/dreams/)"
+  ],
+  [
+    "/dream deep",
+    "Deep dream - multi-cycle exploration with sleep architecture"
+  ],
+  [
+    "/dream lucid",
+    "Lucid dream - implements proposals, tests, evaluates in cycles"
+  ],
+  ["/dream stop", "Wake up - stop dreaming"],
+  ["/listen", "Toggle live microphone transcription (Whisper)"],
+  ["/mic", "Alias for /listen"],
+  ["/listen <model>", "Set model: tiny, base, small, medium, large"],
+  ["/listen manual", "Manual mode - press Enter to submit (turns off auto)"],
+  ["/listen auto", "Auto-submit after 3s silence (blinking indicator)"],
+  ["/listen stop", "Stop listening"],
+  ["/live", "Open live sensor stream menu for video/audio context"],
+  ["/live status", "Show live sensor devices, selected streams, and latest snapshot"],
+  ["/live run [agent]", "Start low-latency video/audio feedback; agent enables background PFC review"],
+  ["/live chat", "Start low-latency voicechat with live audio/video context and async agent review"],
+  ["/livechat", "Alias for /live chat, used by the top live button"],
+  ["/live camera <device>", "Select a camera and render an ASCII preview"],
+  ["/live resolution [camera] 720p|1080p|1440p|4k|native", "Set per-camera live stream resolution (default 1080p)"],
+  ["/live fps [camera] 1|2|4|8|12|15|24|30", "Set per-camera live stream FPS (default 8)"],
+  ["/live camera-on|camera-off [camera]", "Enable or disable an individual live camera stream"],
+  ["/live rotate auto|cw|ccw|180|none [camera]", "Detect or set persistent camera orientation correction"],
+  ["/live infer [now|on|off]", "Toggle or run camera object/location inference"],
+  ["/live clip [on|off]", "Toggle CLIP visual-memory recognition on live frames"],
+  ["/live audio|asr|sounds on|off", "Toggle live audio context streams"],
+  ["/live stop", "Disable all live sensor streams"],
+  ["/camera", "Open compact camera preset menu shared with /live"],
+  ["/camera status", "Show selected camera and per-device presets"],
+  ["/camera select|preview|resolution|fps|rotate", "Manage camera source, preview, resolution, FPS, and orientation"],
+  ["/paste", "Attach clipboard image content to the current or next prompt"],
+  ["/image", "Open image-generation model/setup menu"],
+  [
+    "/image <prompt>",
+    "Generate an image from a prompt and show an ASCII preview"
+  ],
+  ["/image --model <model> <prompt>", "Generate with an explicit image model"],
+  [
+    "/image setup <ollama|diffusers|sdcpp>",
+    "Show setup commands for an image-generation backend"
+  ],
+  [
+    "/image list",
+    "List image models by category, quality, size, and hardware fit"
+  ],
+  ["/sound", "Open sound-effect model/setup menu"],
+  ["/sound <prompt>", "Generate a sound effect or ambience clip from a prompt"],
+  [
+    "/sound --model <model> <prompt>",
+    "Generate sound with an explicit audio model"
+  ],
+  [
+    "/sound setup <diffusers|audiocraft|stable-audio|tangoflux>",
+    "Show setup commands for a sound-generation backend"
+  ],
+  [
+    "/sound list",
+    "List sound models by category, quality, size, and hardware fit"
+  ],
+  ["/music", "Open music-generation model/setup menu"],
+  ["/music <prompt>", "Generate a music clip from a prompt"],
+  [
+    "/music --model <model> <prompt>",
+    "Generate music with an explicit music model"
+  ],
+  [
+    "/music setup <transformers|audiocraft|stable-audio|diffusers>",
+    "Show setup commands for a music-generation backend"
+  ],
+  [
+    "/music list",
+    "List music models by category, quality, size, and hardware fit"
+  ],
+  ["/video", "Open video-generation model/setup menu"],
+  [
+    "/video <prompt>",
+    "Generate a short video from a prompt and show an ASCII thumbnail"
+  ],
+  ["/video --model <model> <prompt>", "Generate video with an explicit model"],
+  [
+    "/video --image <path|url> <prompt>",
+    "Image-to-video animation from a still"
+  ],
+  [
+    "/video setup <diffusers|comfyui>",
+    "Show setup commands for a video-generation backend"
+  ],
+  [
+    "/video list",
+    "List video models by category, quality, size, and hardware fit"
+  ],
+  ["/video prewarm", "Download and warm up the selected video model"],
+  ["/pointcloud", "Open point-cloud generation model/setup menu"],
+  [
+    "/pointcloud --image <path>",
+    "Generate a 3D point cloud PLY from an image using depth estimation"
+  ],
+  [
+    "/pointcloud --image <path> --model <model>",
+    "Generate with an explicit depth model (depth-anything-v3-* or mda-*)"
+  ],
+  [
+    "/pointcloud --image <path1,path2> --backend mda",
+    "Multi-view depth fusion from comma-separated image paths"
+  ],
+  [
+    "/pointcloud setup <depth-anything|mda>",
+    "Show setup commands for a point-cloud backend"
+  ],
+  [
+    "/pointcloud list",
+    "List point-cloud models by backend, quality, and VRAM fit"
+  ],
+  ["/pointcloud prewarm", "Download and warm up the selected depth model"],
+  ["/points <args>", "Alias for /pointcloud"],
+  ["/pcl <args>", "Alias for /pointcloud"],
+  ["/call", "Start voice call session (cloudflared tunnel + ASR/TTS)"],
+  ["/hangup", "End active call session"],
+  [
+    "/queue <prompt>",
+    "Queue a prompt for the next turn without interrupting the current run"
+  ],
+  ["/q <prompt>", "Alias for /queue <prompt>"],
+  ["/retry", "Retry the last submitted request"],
+  ["/undo", "Undo the last queued or saved exchange when available"],
+  ["/title [name]", "Show or set the current session title"],
+  [
+    "/rollback [checkpoint]",
+    "List checkpoints or restore an explicit checkpoint when policy allows"
+  ],
+  ["/background <prompt>", "Run a prompt in an independent background session"],
+  ["/bg <prompt>", "Alias for /background <prompt>"],
+  ["/cost", "Show session token cost breakdown"],
+  ["/usage", "Show current session token count and cost"],
+  ["/insights", "Show historical session insights"],
+  ["/evaluate", "Evaluate last completed task (LLM quality scoring)"],
+  [
+    "/score",
+    "Show inference capability scorecard (memory, compute, speed, models)"
+  ],
+  [
+    "/task-type",
+    "Set task type (code, document, analysis, plan, general, auto)"
+  ],
+  ["/stats", "Show session dashboard (metrics, tool usage, task history)"],
+  [
+    "/metrics",
+    "Show runtime metrics: tokens, context window, throughput, and tool usage"
+  ],
+  ["/sessions", "Browse saved sessions"],
+  ["/new", "Start a fresh chat in the current project"],
+  [
+    "/pause",
+    "Pause after current turn finishes (gentle halt, /resume to continue)"
+  ],
+  [
+    "/stop",
+    "Kill current inference immediately and save state (/resume to continue)"
+  ],
+  [
+    "/resume",
+    "Resume a paused task or choose a saved project chat"
+  ],
+  ["/resume <session>", "Resume a saved project chat by id or title"],
+  [
+    "/destroy processes",
+    "Find and kill orphaned Omnius child processes (this project)"
+  ],
+  [
+    "/destroy processes --global",
+    "Kill ALL orphaned Omnius processes system-wide"
+  ],
+  [
+    "/destroy project",
+    "Remove .omnius folder, kill all tasks, clear console, and exit"
+  ],
+  ["/context save", "Force-save session context to .omnius/context/"],
+  ["/context restore", "Restore context from previous sessions into next task"],
+  ["/context show", "Show saved session context status"],
+  ["/compact", "Force context compaction now (default strategy)"],
+  ["/compacted", "Review applied, held, rejected, and failed compaction attempts"],
+  [
+    "/compact <strategy>",
+    "Compact with strategy: aggressive, decisions, errors, summary, structured"
+  ],
+  ["/bruteforce", "Toggle brute-force mode (auto re-engage on turn limit)"],
+  [
+    "/deep",
+    "Toggle deep context - relaxes compaction so large models use 85% of context"
+  ],
+  [
+    "/flow",
+    "Toggle FlowState protocol - immediate action, tight loops, goal clarity"
+  ],
+  ["/emojis", "Toggle emoji rendering in TUI messages"],
+  ["/tools", "List agent-created custom tools"],
+  ["/skills", "List available AIWG skills"],
+  ["/skill", "Alias for /skills"],
+  ["/skills <keyword>", "Filter skills by name or trigger"],
+  ["/skillify [request]", "Extract a reusable skill from the current session"],
+  ["/<skill-name> [args]", "Invoke an AIWG skill directly"],
+  [
+    "/full-send-bless",
+    "Infinite warm loop - DMN self-reflection chains tasks autonomously"
+  ],
+  ["/bless stop", "End blessed mode + DMN"],
+  [
+    "/telegram --key <token>",
+    "Save Telegram bot token (persisted to settings)"
+  ],
+  [
+    "/telegram --admin <userid>",
+    "Set admin user filter (only this user can interact)"
+  ],
+  ["/telegram", "Toggle Telegram bridge on/off (uses saved key)"],
+  ["/telegram status", "Show Telegram bridge status"],
+  ["/telegram stop", "Disconnect Telegram bridge"],
+  ["/telegram disable", "Persistently disable Telegram long polling"],
+  ["/telegram enable", "Re-enable Telegram long polling"],
+  [
+    "/telegram mode auto|chat|action",
+    "Set Telegram interaction routing: auto, fast chat, or action sub-agent"
+  ],
+  [
+    "/telegram subagents <1-5>",
+    "Set global Telegram work-slot limit across all chats/groups"
+  ],
+  [
+    "/telegram model",
+    "Pick the Telegram-isolated model (model list from the Telegram endpoint)"
+  ],
+  [
+    "/telegram model <name|reset>",
+    "Set or clear the Telegram-isolated model (separate from main agent)"
+  ],
+  [
+    "/telegram endpoint",
+    "Pick the Telegram-isolated backend endpoint (same menu as /endpoint, bot-scoped)"
+  ],
+  [
+    "/telegram endpoint <url|reset> [--auth <t>]",
+    "Set or clear the Telegram-isolated endpoint"
+  ],
+  [
+    "/telegram auth",
+    "Show a TUI-only one-time code for Telegram admin authentication"
+  ],
+  [
+    "/telegram auth cancel",
+    "Cancel the pending Telegram admin authentication code"
+  ],
+  [
+    "/telegram bot <username> <text>",
+    "Send a Bot API bot-to-bot message by @username"
+  ],
+  [
+    "/telegram poll <chat> <question> | <option> [| <option>]",
+    "Send a Telegram poll"
+  ],
+  [
+    "/telegram live-photo <chat> <live_photo> <photo> [caption]",
+    "Send a Telegram live photo"
+  ],
+  [
+    "/telegram draft <chat_id> <draft_id> [text]",
+    "Set or clear a Telegram message draft"
+  ],
+  [
+    "/telegram admins <chat> [--bots]",
+    "List chat administrators, optionally including bots"
+  ],
+  [
+    "/telegram personal <user_id> <limit>",
+    "Fetch last messages from a user's profile personal chat"
+  ],
+  [
+    "/telegram access get <managed_bot_user_id>",
+    "Show managed-bot access restriction settings"
+  ],
+  [
+    "/telegram access set <managed_bot_user_id> <restricted|open> [added_user_ids]",
+    "Set managed-bot access restrictions"
+  ],
+  [
+    "/telegram tools [group <chat>|panel <chat> [policy_chat]]",
+    "Show unified Telegram tool policy or send inline admin toggle buttons"
+  ],
+  [
+    "/telegram delete-message <chat> <message> [reason]",
+    "Delete one Telegram message after policy and Bot API rights checks"
+  ],
+  [
+    "/telegram delete-messages <chat> <message,message> [reason]",
+    "Delete multiple Telegram messages after policy and Bot API rights checks"
+  ],
+  [
+    "/telegram delete-reaction <chat> <message> [--user <id>|--actor <chat>]",
+    "Delete a Telegram message reaction"
+  ],
+  [
+    "/telegram delete-reactions <chat> [--user <id>|--actor <chat>]",
+    "Delete recent Telegram message reactions by user or chat"
+  ],
+  ["/platforms", "Show gateway platform state"],
+  ["/platforms status", "Show gateway platform state"],
+  ["/platforms menu", "Open interactive platform connectivity menu"],
+  ["/platforms setup", "Open platform onboarding menu"],
+  ["/platforms onboard", "Open platform onboarding menu"],
+  ["/platforms config", "Show redacted platform adapter configuration"],
+  ["/platforms enable <id>", "Enable a platform adapter"],
+  ["/platforms disable <id>", "Disable a platform adapter"],
+  [
+    "/platforms set <id> token-env <ENV>",
+    "Set adapter token environment variable"
+  ],
+  ["/platforms set <id> base-url <url>", "Set adapter base URL or webhook URL"],
+  [
+    "/platforms set <id> target <target>",
+    "Set adapter default channel, room, or target"
+  ],
+  [
+    "/platforms set <id> mode <polling|webhook>",
+    "Set adapter polling or webhook mode"
+  ],
+  [
+    "/platforms clear <id> <key>",
+    "Clear saved adapter token, token-env, base-url, or target"
+  ],
+  ["/gateway", "Alias for /platforms"],
+  ["/gateway menu", "Alias for /platforms menu"],
+  [
+    "/cohere",
+    "Toggle COHERE cognitive commons - join distributed memory/identity mesh"
+  ],
+  [
+    "/cohere stats",
+    "Show network stats - queries in/out, model usage, peer transparency"
+  ],
+  ["/cohere models", "List downloaded models with COHERE exposure status"],
+  ["/cohere allow <model>", "Allow a model for remote COHERE queries"],
+  ["/cohere deny <model>", "Hide a model from remote COHERE queries"],
+  ["/nexus", "Show nexus P2P network status"],
+  ["/nexus connect", "Connect to the agent mesh network"],
+  [
+    "/nexus name <name>",
+    "Set custom agent name (persists globally across all Omnius instances)"
+  ],
+  ["/nexus name", "Show current agent name"],
+  ["/nexus restart", "Kill daemon and reconnect (picks up new version)"],
+  ["/nexus restart --clean", "Restart + clear metering data for fresh stats"],
+  ["/nexus disconnect", "Kill daemon without reconnecting"],
+  ["/nexus wallet", "Show wallet address and x402 payment status"],
+  ["/ipfs", "Show IPFS/Helia status"],
+  ["/ipfs pin <cid>", "Pin an IPFS CID"],
+  ["/ipfs publish", "Publish identity snapshot to IPFS"],
+  ["/ipfs share <tool|skill> <name>", "Share a tool or skill through IPFS"],
+  ["/ipfs import <cid>", "Import a shared IPFS tool or skill reference"],
+  ["/sponsor", "Sponsor inference - onboarding wizard or dashboard"],
+  ["/sponsor status", "Show sponsor dashboard with usage metrics"],
+  ["/sponsor image <prompt>", "Generate an image on a sponsored peer"],
+  ["/sponsor video <prompt>", "Generate a video on a sponsored peer"],
+  ["/sponsor sound <prompt>", "Generate a sound effect on a sponsored peer"],
+  ["/sponsor music <prompt>", "Generate music on a sponsored peer"],
+  ["/sponsor pause", "Pause active sponsorship"],
+  ["/sponsor remove", "Remove sponsorship entirely"],
+  [
+    "/endpoint sponsor",
+    "Browse and connect to sponsored inference from the nexus mesh"
+  ],
+  ["/expose <backend>", "Expose local inference via libp2p (default)"],
+  ["/expose <backend> --tunnel", "Expose via cloudflared tunnel"],
+  ["/expose passthrough", "Forward configured /endpoint through libp2p P2P"],
+  [
+    "/expose forward --loadbalance",
+    "Passthrough with distributed rate-limit budget"
+  ],
+  ["/expose config", "Interactive expose configuration menu"],
+  ["/expose status", "Show gateway stats (requests, models, budget)"],
+  ["/expose stop", "Stop all expose gateways"],
+  ["/expose stop --tunnel", "Stop tunnel gateway only"],
+  ["/expose stop --libp2p", "Stop libp2p gateway only"],
+  ["/access", "Show access policy and host binding"],
+  [
+    "/access <loopback|lan|any>",
+    "Set access policy (OMNIUS_ACCESS) and restart daemon"
+  ],
+  ["/k <any|lan|loopback|config>", "Quick network access helper"],
+  ["/scheduler", "Scheduled tasks control panel (list/kill/toggle)"],
+  ["/cron", "Cron/scheduled job management"],
+  ["/cron list", "List cron jobs"],
+  ["/cron add <schedule> <prompt>", "Create a new cron job"],
+  ["/cron edit <id> <field> <val>", "Update a cron job field"],
+  ["/cron pause <id>", "Pause a cron job"],
+  ["/cron resume <id>", "Resume a paused cron job"],
+  ["/cron run <id>", "Execute a cron job immediately"],
+  ["/cron remove <id>", "Delete a cron job"],
+  ["/cron outputs <id>", "Show saved output files for a job"],
+  ["/cron tick", "Run scheduler tick"],
+  ["/scheduler menu", "Interactive scheduler menu (toggle/kill)"],
+  ["/scheduler list", "List all scheduled tasks and timers"],
+  [
+    "/scheduler kill",
+    "Kill schedulers + active runs (with escalation if needed)"
+  ],
+  ["/reminder [list|all]", "List scoped TUI reminders"],
+  [
+    "/remind <when> <message>",
+    "Set a scoped person notification; a due time is required"
+  ],
+  [
+    "/remind in 30m <message>",
+    "Set a scoped person notification with a relative due time"
+  ],
+  ["/reminders", "Alias for /reminder"],
+  ["/daemon", "Show or manage the local API daemon"],
+  ["/daemon <start|stop|restart|takeover>", "Control the local API daemon"],
+  ["/apikey", "Show current API key (for pasting into Web UI / clients)"],
+  ["/apikey copy", "Copy the API key to clipboard"],
+  ["/apikey new", "Rotate to a new API key (regenerate)"],
+  ["/secrets", "List registered secrets"],
+  ["/secrets set <name> <value>", "Register a secret for redacted tool use"],
+  ["/secrets delete <name>", "Remove a registered secret"],
+  ["/key", "Alias for /apikey"],
+  ["/codegraph", "Code-graph snapshot: stats, top files, recent activity"],
+  [
+    "/codegraph watch [N]",
+    "Subscribe to live code-graph events for N seconds (default 30)"
+  ],
+  ["/cg", "Alias for /codegraph"],
+  ["/storage", "Show .omnius storage usage and safety summary"],
+  ["/files", "Show searchable working-directory file overview"],
+  ["/files <query>", "Filter the working-directory file overview"],
+  ["/files menu", "Open searchable workspace file selector"],
+  ["/workspace", "Alias for /files"],
+  ["/workspace <query>", "Alias for /files <query>"],
+  ["/workspace menu", "Alias for /files menu"],
+  ["/ingest <file>", "Ingest an audio, PDF, or text file into memory"],
+  ["/transcribe <file>", "Alias for /ingest <file>"],
+  ["/fortemi", "Manage Fortemi React bridge integration"],
+  [
+    "/host <host[:port]>",
+    "Set bind host:port (OMNIUS_HOST) and restart daemon"
+  ],
+  ["/network config", "Interactive network access menu"],
+  ["/p2p start", "Join the P2P agent mesh network"],
+  ["/p2p status", "Show mesh peers and rooms"],
+  ["/p2p stop", "Leave the mesh network"],
+  ["/style", "Show current response style"],
+  ["/style <preset>", "Set style: concise, balanced, verbose, pedagogical"],
+  [
+    "/personality <preset>",
+    "Alias family for response style/personality controls"
+  ],
+  ["/commands auto", "Allow agent to invoke slash commands as tools"],
+  ["/cmds auto", "Alias for /commands auto"],
+  ["/commands manual", "Slash commands are user-only (default)"],
+  [
+    "/selfmodify",
+    "Toggle agent self-modify mode for natural-language runtime commands"
+  ],
+  [
+    "/selfmodify on",
+    "Allow the agent to decide when to invoke self-modifying slash commands"
+  ],
+  [
+    "/selfmodify off",
+    "Disable agent self-modifying slash-command access (default)"
+  ],
+  ["/selfmodify status", "Show current self-modify mode"],
+  [
+    "/selfimprove status",
+    "Show durable review/proposal backlog, leases, retries, and last error"
+  ],
+  [
+    "/selfimprove start",
+    "Enable review mode and drain eligible work with the parent model"
+  ],
+  ["/selfimprove stop", "Disable processing while retaining the durable backlog"],
+  ["/selfimprove disable", "Alias for /selfimprove stop"],
+  [
+    "/selfimprove review",
+    "Run evidence review and candidate generation without active promotion"
+  ],
+  [
+    "/selfimprove autonomous",
+    "Opt in to downstream candidate experiment and promotion orchestration"
+  ],
+  [
+    "/selfimprove rollback <promotion-id> [reason]",
+    "Restore the exact pre-promotion baseline and verify the rollback"
+  ],
+  ["/debug", "Toggle debug mode — show/hide trust_tier wrappers and REG fires"],
+  ["/debug on", "Show trust_tier wrappers and REG fires in terminal"],
+  ["/debug off", "Hide trust_tier wrappers and REG fires (default)"],
+  ["/debug", "Toggle debug mode — show/hide trust_tier wrappers and REG fires"],
+  ["/debug on", "Show trust_tier wrappers and REG fires in terminal"],
+  ["/debug off", "Hide trust_tier wrappers and REG fires (default)"],
+  ["/hf", "Show HF token status (set / not set)"],
+  [
+    "/hf <token>",
+    "Save Hugging Face access token to ~/.omnius/hf_token and unblock the active gated download"
+  ],
+  ["/hf clear", "Remove the persisted HF token"],
+  [
+    "/hf cancel",
+    "Cancel any pending HF token prompt and fall back immediately"
+  ],
+  [
+    "/models",
+    "Show unified ~/.omnius model store: disk usage, cached repos, last-used"
+  ],
+  ["/models 3d", "Select CAD/3D generation and reconstruction model adapters"],
+  ["/models cad", "Select text-to-CAD model adapters such as cad0"],
+  [
+    "/models viewer [file]",
+    "Start a temporary standalone CAD/3D viewer endpoint"
+  ],
+  [
+    "/models hf list --modality 3d",
+    "List curated and installed Hugging Face CAD/3D adapters"
+  ],
+  [
+    "/models evict <repo>",
+    "Remove a cached HF repo from the unified store to reclaim disk"
+  ],
+  [
+    "/models evict --free <GB>",
+    "LRU-evict cached models until <GB> of free disk is available"
+  ],
+  [
+    "/models cleanup",
+    "Migrate legacy per-repo .omnius/{image,video,audio}-gen caches into the unified store and delete the originals"
+  ],
+  [
+    "/models cleanup --dry-run",
+    "Preview /models cleanup without touching disk"
+  ],
+  ["/voicechat", "Start voice chat session (async voice conversation)"],
+  ["/voicechat stop", "Stop voice chat session"],
+  ["/memory", "Open the interactive memory pixel map and provenance trace"],
+  ["/memory legacy", "Open the legacy list-based memory browser"],
+  [
+    "/metabolize [--dry-run] [--verbose] [--min-score <n>]",
+    "Run memory maintenance: import deferred memory, prune episodes, compact graph stores"
+  ],
+  [
+    "/prune [now|dry|infer|aggressive|stats] [--target <n>]",
+    "Shrink knowledge.db in the background: evict low-signal graph nodes (archived), then VACUUM. 'infer' = model-guided sleep consolidation. No arg shows stats + usage"
+  ],
+  ["/verbose", "Toggle verbose mode"],
+  ["/clear", "Clear the screen"],
+  ["/help", "Show this help"],
+  ["/quit", "Exit omnius"]
+].map(([signature, description]) => ({ signature, description }));
+var PLANNED_SIGNATURES = [
+  ["/provider", "Show or select provider profile"],
+  ["/prompt", "Show or edit the active prompt template"],
+  ["/reasoning", "Alias family for thinking/reasoning controls"],
+  ["/statusbar", "Configure the status bar"],
+  ["/sb", "Alias for /statusbar"],
+  ["/skin", "Configure the visual skin/theme bundle"],
+  ["/toolsets", "Show or select tool exposure sets"],
+  ["/browser connect|disconnect|status", "Manage browser-agent connectivity"],
+  ["/reload-mcp", "Reload MCP servers and tools"],
+  ["/plugins", "List or manage plugins"],
+  ["/status", "Show overall runtime status"],
+  ["/sethome", "Set the project home for gateway/session use"],
+  ["/approve", "Approve a pending gateway/admin action"],
+  ["/deny", "Deny a pending gateway/admin action"]
+].map(([signature, description]) => ({
+  signature,
+  description,
+  implementationStatus: "planned"
+}));
+var CATEGORY_OVERRIDES = {
+  model: "model",
+  models: "model",
+  endpoint: "network",
+  fallback: "network",
+  provider: "network",
+  parallel: "runtime",
+  gpu: "runtime",
+  broker: "runtime",
+  setup: "runtime",
+  wizard: "runtime",
+  mcp: "tools",
+  mcps: "tools",
+  update: "admin",
+  upgrade: "admin",
+  voice: "media",
+  voicechat: "media",
+  listen: "media",
+  mic: "media",
+  paste: "media",
+  image: "media",
+  video: "media",
+  pointcloud: "media",
+  points: "media",
+  pcl: "media",
+  ingest: "media",
+  transcribe: "media",
+  call: "media",
+  hangup: "media",
+  queue: "session",
+  q: "session",
+  retry: "session",
+  undo: "session",
+  title: "session",
+  rollback: "session",
+  background: "session",
+  bg: "session",
+  pause: "session",
+  stop: "session",
+  resume: "session",
+  new: "session",
+  context: "session",
+  compact: "session",
+  compacted: "session",
+  gc: "session",
+  sessions: "session",
+  session: "session",
+  dream: "runtime",
+  "full-send-bless": "runtime",
+  bless: "runtime",
+  telegram: "gateway",
+  cohere: "network",
+  nexus: "network",
+  ipfs: "network",
+  storage: "admin",
+  files: "tools",
+  workspace: "tools",
+  "task-type": "runtime",
+  tasktype: "runtime",
+  sponsor: "network",
+  expose: "gateway",
+  access: "network",
+  host: "network",
+  network: "network",
+  k: "network",
+  scheduler: "runtime",
+  reminder: "runtime",
+  daemon: "runtime",
+  indicator: "ui",
+  apikey: "secret",
+  key: "secret",
+  secrets: "secret",
+  secret: "secret",
+  vault: "secret",
+  codegraph: "tools",
+  cg: "tools",
+  p2p: "network",
+  tools: "tools",
+  skills: "tools",
+  skill: "tools",
+  skillify: "tools",
+  memory: "memory",
+  mem: "memory",
+  metabolize: "memory",
+  prune: "memory",
+  mouse: "ui",
+  color: "ui",
+  colors: "ui",
+  theme: "ui",
+  neovim: "ui",
+  nvim: "ui",
+  vim: "ui",
+  emojis: "ui",
+  emoji: "ui",
+  statusbar: "ui",
+  sb: "ui",
+  skin: "ui",
+  prompt: "ui",
+  personality: "ui",
+  reasoning: "ui",
+  selfmodify: "runtime",
+  selfimprove: "runtime",
+  "self-improve": "runtime",
+  debug: "runtime",
+  selfmod: "runtime",
+  "self-modify": "runtime",
+  stats: "session",
+  metrics: "session"
+};
+var ALIASES = {
+  help: ["h", "?"],
+  quit: ["exit"],
+  queue: ["q"],
+  background: ["bg"],
+  clear: ["cls"],
+  verbose: ["v"],
+  config: ["cfg"],
+  color: ["colors", "theme"],
+  setup: ["wizard"],
+  mcp: ["mcps"],
+  update: ["upgrade"],
+  indicator: ["tray"],
+  listen: ["mic"],
+  pointcloud: ["points", "pcl", "point"],
+  neovim: ["nvim"],
+  apikey: ["key"],
+  secrets: ["secret", "vault"],
+  sessions: ["session"],
+  cost: ["costs"],
+  evaluate: ["eval"],
+  score: ["inference"],
+  "task-type": ["tasktype", "tt"],
+  stats: ["dashboard"],
+  memory: ["mem"],
+  metabolize: ["metab"],
+  files: ["workspace"],
+  skills: ["skill"],
+  commands: ["cmds"],
+  selfmodify: ["selfmod", "self-modify"],
+  selfimprove: ["self-improve"],
+  codegraph: ["cg"],
+  endpoint: ["ep"],
+  telegram: ["tg"],
+  bruteforce: ["brute"],
+  deep: ["deep-context"],
+  flow: ["flowstate"],
+  emojis: ["emoji"],
+  compact: ["gc"],
+  network: ["k"],
+  scheduler: [],
+  reminder: ["remind", "reminders"],
+  statusbar: ["sb"],
+  platforms: ["gateway"]
+};
+var USER_ONLY = /* @__PURE__ */ new Set([
+  "fallback",
+  "quit",
+  "exit",
+  "clear",
+  "cls",
+  "q",
+  "queue",
+  "model",
+  "endpoint",
+  "parallel",
+  "gpu",
+  "memory",
+  "broker",
+  "commands",
+  "cmds",
+  "selfmodify",
+  "selfmod",
+  "self-modify",
+  "selfimprove",
+  "self-improve",
+  "debug",
+  "dbg",
+  "hf",
+  "models",
+  "mcp",
+  "mcps",
+  "update",
+  "upgrade",
+  "setup",
+  "wizard",
+  "telegram",
+  "call",
+  "hangup",
+  "listen",
+  "mic",
+  "paste",
+  "image",
+  "video",
+  "pointcloud",
+  "points",
+  "pcl",
+  "ingest",
+  "transcribe",
+  "expose",
+  "p2p",
+  "ipfs",
+  "storage",
+  "files",
+  "workspace",
+  "secrets",
+  "secret",
+  "vault",
+  "skillify",
+  "dream",
+  "bless",
+  "full-send-bless",
+  "pause",
+  "stop",
+  "resume",
+  "new",
+  "retry",
+  "undo",
+  "rollback",
+  "background",
+  "bg",
+  "apikey",
+  "key",
+  "access",
+  "host",
+  "network",
+  "k",
+  "scheduler",
+  "cron",
+  "daemon",
+  "indicator",
+  "compacted",
+  "fortemi",
+  "mouse",
+  "approve",
+  "deny",
+  "sethome"
+]);
+var DESTRUCTIVE = /* @__PURE__ */ new Set([
+  "destroy",
+  "stop",
+  "rollback",
+  "update",
+  "upgrade",
+  "deny",
+  "daemon",
+  "ollama"
+]);
+var NETWORKED = /* @__PURE__ */ new Set([
+  "endpoint",
+  "update",
+  "upgrade",
+  "telegram",
+  "call",
+  "listen",
+  "mic",
+  "image",
+  "video",
+  "pointcloud",
+  "points",
+  "pcl",
+  "cohere",
+  "nexus",
+  "ipfs",
+  "sponsor",
+  "expose",
+  "access",
+  "host",
+  "network",
+  "k",
+  "p2p",
+  "daemon",
+  "fortemi",
+  "mcp",
+  "mcps",
+  "browser",
+  "cron",
+  "reload-mcp",
+  "plugins",
+  "platforms",
+  "gateway"
+]);
+var SECRET_BEARING = /* @__PURE__ */ new Set([
+  "endpoint",
+  "apikey",
+  "key",
+  "telegram",
+  "secrets",
+  "secret",
+  "vault",
+  "hf"
+]);
+var PROFILE_GATED = /* @__PURE__ */ new Set([
+  "destroy",
+  "update",
+  "upgrade",
+  "telegram",
+  "call",
+  "listen",
+  "mic",
+  "expose",
+  "access",
+  "host",
+  "network",
+  "k",
+  "p2p",
+  "daemon",
+  "fortemi",
+  "mcp",
+  "mcps",
+  "ipfs",
+  "approve",
+  "deny",
+  "sethome"
+]);
+var REST_BLOCKED = /* @__PURE__ */ new Set([
+  "pause",
+  "resume",
+  "new",
+  "retry",
+  "undo",
+  "rollback",
+  "background",
+  "bg",
+  "paste",
+  "indicator"
+]);
+var LOCAL_TUI_ONLY = /* @__PURE__ */ new Set(["indicator", "compacted", "gpu", "memory"]);
+var CANONICAL_BY_ALIAS = /* @__PURE__ */ new Map();
+for (const [canonical, aliases2] of Object.entries(ALIASES)) {
+  for (const alias of aliases2) CANONICAL_BY_ALIAS.set(alias, canonical);
+}
+var DYNAMIC_COMMANDS = [];
+function getSlashHelpEntries(opts = {}) {
+  const includePlanned = opts.includePlanned === true;
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const item of [
+    ...DYNAMIC_COMMANDS,
+    ...COMMAND_SIGNATURES,
+    ...PLANNED_SIGNATURES
+  ]) {
+    if (!includePlanned && item.implementationStatus === "planned") continue;
+    if (seen.has(item.signature)) continue;
+    seen.add(item.signature);
+    out.push([item.signature, item.description]);
+  }
+  return out;
+}
+var SLASH_COMMANDS = getSlashHelpEntries();
+function listCommandRegistry(opts = {}) {
+  const includePlanned = opts.includePlanned !== false;
+  const grouped = /* @__PURE__ */ new Map();
+  for (const sig of [
+    ...COMMAND_SIGNATURES,
+    ...PLANNED_SIGNATURES,
+    ...DYNAMIC_COMMANDS
+  ]) {
+    if (!includePlanned && sig.implementationStatus === "planned") continue;
+    const name = commandNameFromSignature(sig.signature);
+    if (!name || name.startsWith("<")) continue;
+    if (!grouped.has(name)) grouped.set(name, []);
+    grouped.get(name).push(sig);
+  }
+  return Array.from(grouped.entries()).map(
+    ([name, signatures]) => buildCommandDef(name, signatures)
+  );
+}
+function findCommand(name) {
+  const normalized = normalizeCommandName(name);
+  const all = listCommandRegistry({ includePlanned: true });
+  return all.find(
+    (cmd) => cmd.name === normalized || cmd.aliases.includes(normalized)
+  );
+}
+function buildCommandDef(name, signatures) {
+  const status = signatures.every(
+    (sig) => sig.implementationStatus === "planned"
+  ) ? "planned" : "implemented";
+  const safety = {
+    userOnly: USER_ONLY.has(name),
+    destructive: DESTRUCTIVE.has(name),
+    networked: NETWORKED.has(name),
+    secretBearing: SECRET_BEARING.has(name),
+    profileGated: PROFILE_GATED.has(name)
+  };
+  const aliases2 = Array.from(new Set(ALIASES[name] ?? []));
+  const category = CATEGORY_OVERRIDES[name] ?? (status === "planned" ? "planned" : "core");
+  const subcommands = Array.from(
+    new Set(
+      signatures.map((sig) => subcommandFromSignature(sig.signature)).filter((sub) => !!sub)
+    )
+  );
+  const argsHint = inferArgsHint(signatures[0]?.signature ?? `/${name}`);
+  const surfaces = {
+    tui: true,
+    rest: status === "implemented" && !["quit", "exit"].includes(name) && !safety.destructive && !safety.secretBearing && !REST_BLOCKED.has(name) && !LOCAL_TUI_ONLY.has(name),
+    gateway: status === "implemented" && !safety.destructive && !safety.secretBearing && !LOCAL_TUI_ONLY.has(name),
+    agentTool: status === "implemented" && !safety.userOnly && !safety.destructive && !safety.secretBearing && !safety.profileGated && !LOCAL_TUI_ONLY.has(name)
+  };
+  return {
+    name,
+    aliases: aliases2,
+    description: signatures[0]?.description ?? "",
+    category,
+    argsHint,
+    subcommands,
+    signatures,
+    surfaces,
+    safety,
+    implementationStatus: status
+  };
+}
+function commandNameFromSignature(signature) {
+  const raw = normalizeCommandName(
+    (signature.trim().split(/\s+/)[0] ?? "").replace(/^\//, "")
+  );
+  return CANONICAL_BY_ALIAS.get(raw) ?? raw;
+}
+function subcommandFromSignature(signature) {
+  const parts = signature.trim().split(/\s+/);
+  if (parts.length < 2) return null;
+  const sub = parts[1] ?? "";
+  if (!sub || sub.startsWith("<") || sub.startsWith("[") || sub.includes("|"))
+    return null;
+  return sub.replace(/[|].*$/, "");
+}
+function inferArgsHint(signature) {
+  return signature.trim().split(/\s+/).slice(1).join(" ");
+}
+function normalizeCommandName(name) {
+  return name.replace(/^\//, "").trim().toLowerCase();
+}
+
+// packages/cli/src/tui/native/components/vim-composer.ts
+var VimComposer = class {
+  constructor(editor, changed) {
+    this.editor = editor;
+    this.changed = changed;
+  }
+  editor;
+  changed;
+  enabled = false;
+  mode = "INSERT";
+  count = "";
+  operator = "";
+  operatorCount = 1;
+  anchor = 0;
+  register = "";
+  linewise = false;
+  find = "";
+  search;
+  lastSearch;
+  setEnabled(enabled) {
+    if (enabled === this.enabled) return;
+    this.enabled = enabled;
+    this.mode = "INSERT";
+    this.reset();
+    this.editor.clearSelection();
+    this.changed();
+  }
+  get label() {
+    return this.search ? `${this.search.backward ? "?" : "/"}${this.search.value}` : this.mode;
+  }
+  reset() {
+    this.count = "";
+    this.operator = "";
+    this.operatorCount = 1;
+    this.find = "";
+    this.search = void 0;
+  }
+  normal() {
+    this.mode = "NORMAL";
+    this.editor.clearSelection();
+    this.reset();
+    this.changed();
+  }
+  end() {
+    return this.editor.editBuffer.measureText(this.editor.plainText);
+  }
+  takeCount() {
+    const n = Math.max(1, Math.min(1e4, Number(this.count) || 1));
+    this.count = "";
+    return n;
+  }
+  select(start, end) {
+    this.editor.setSelection(Math.min(start, end), Math.max(start, end));
+  }
+  operate(start, end, operation, linewise = false) {
+    this.select(start, end);
+    this.register = this.editor.getSelectedText();
+    this.linewise = linewise;
+    if (linewise && this.register && !this.register.endsWith("\n")) this.register += "\n";
+    if (operation !== "y") this.editor.deleteSelection();
+    else {
+      this.editor.clearSelection();
+      this.editor.cursorOffset = Math.min(start, end);
+    }
+    this.reset();
+    this.mode = operation === "c" ? "INSERT" : "NORMAL";
+    this.changed();
+  }
+  lineRange(count) {
+    const row = this.editor.logicalCursor.row;
+    const start = this.editor.editBuffer.getLineStartOffset(row);
+    const next = row + count;
+    let end = next < this.editor.lineCount ? this.editor.editBuffer.getLineStartOffset(next) : this.end();
+    if (end === start && row > 0) return [start - 1, end];
+    return [start, end];
+  }
+  motion(key, count) {
+    const editor = this.editor;
+    if (key === "0") editor.gotoLineHome();
+    else if (key === "$") {
+      if (count > 1) editor.gotoLine(Math.min(editor.lineCount - 1, editor.logicalCursor.row + count - 1));
+      editor.gotoLineEnd();
+    } else if (key === "^") {
+      editor.gotoLineHome();
+      const line = editor.getTextRange(editor.cursorOffset, this.end()).split("\n")[0];
+      for (const char of line) {
+        if (!/\s/.test(char)) break;
+        editor.moveCursorRight();
+      }
+    } else if (key === "G") {
+      editor.gotoLine(count > 1 ? Math.min(editor.lineCount - 1, count - 1) : editor.lineCount - 1);
+      editor.gotoLineHome();
+    } else if (key === "gg") {
+      editor.gotoLine(Math.max(0, count - 1));
+      editor.gotoLineHome();
+    } else if (key === "e") {
+      for (let i = 0; i < count; i++) {
+        const start = editor.cursorOffset;
+        const endWord = () => {
+          editor.moveWordForward();
+          const nextWord2 = editor.cursorOffset;
+          editor.moveCursorLeft();
+          while (editor.cursorOffset > start && /\s/u.test(editor.getTextRange(editor.cursorOffset, nextWord2).slice(0, 1))) editor.moveCursorLeft();
+          return nextWord2;
+        };
+        const nextWord = endWord();
+        if (editor.cursorOffset <= start && nextWord < this.end()) {
+          editor.cursorOffset = nextWord;
+          endWord();
+        }
+      }
+    } else if (["h", "l", "j", "k", "w", "b", "left", "right", "up", "down"].includes(key)) {
+      for (let i = 0; i < count; i++) {
+        if (key === "h" || key === "left") editor.moveCursorLeft();
+        else if (key === "l" || key === "right") editor.moveCursorRight();
+        else if (key === "j" || key === "down") editor.moveCursorDown();
+        else if (key === "k" || key === "up") editor.moveCursorUp();
+        else if (key === "w") editor.moveWordForward();
+        else editor.moveWordBackward();
+      }
+    } else return false;
+    return true;
+  }
+  searchFor(value, backward) {
+    if (!value) return;
+    const text = this.editor.plainText;
+    const character = this.editor.getTextRange(0, this.editor.cursorOffset).length;
+    const index = backward ? character > 0 ? text.lastIndexOf(value, character - 1) : -1 : text.indexOf(value, character + 1);
+    const found = index >= 0 ? index : backward ? text.lastIndexOf(value) : text.indexOf(value);
+    if (found >= 0) this.editor.cursorOffset = this.editor.editBuffer.measureText(text.slice(0, found));
+  }
+  handle(key) {
+    if (!this.enabled || key.eventType === "release") return false;
+    const consume = () => {
+      key.preventDefault();
+      key.stopPropagation();
+      return true;
+    };
+    if (this.mode === "INSERT") {
+      if (key.name !== "escape") return false;
+      if (this.editor.logicalCursor.col > 0) this.editor.moveCursorLeft();
+      this.normal();
+      return consume();
+    }
+    if (key.name === "escape") {
+      this.normal();
+      return consume();
+    }
+    if (key.ctrl && key.name === "r") {
+      this.editor.redo();
+      return consume();
+    }
+    if (key.ctrl || key.meta || key.name === "return" && !this.search || key.name === "tab") return false;
+    const char = key.sequence.length === 1 ? key.sequence : key.name;
+    if (this.search) {
+      if (key.name === "return") {
+        this.lastSearch = this.search;
+        this.searchFor(this.search.value, this.search.backward);
+        this.search = void 0;
+      } else if (key.name === "backspace") this.search.value = [...this.search.value].slice(0, -1).join("");
+      else if (key.sequence.length === 1) this.search.value += key.sequence;
+      this.changed();
+      return consume();
+    }
+    if (this.find) {
+      if (this.find === "r") {
+        const start2 = this.editor.cursorOffset;
+        this.editor.moveCursorRight();
+        if (this.editor.cursorOffset !== start2) {
+          this.select(start2, this.editor.cursorOffset);
+          this.editor.insertText(char);
+          this.editor.cursorOffset = start2;
+        }
+        this.find = "";
+        return consume();
+      }
+      const forward = this.find === "f" || this.find === "t", till = this.find === "t" || this.find === "T";
+      const start = this.editor.cursorOffset, row = this.editor.logicalCursor.row;
+      for (let i = 0; i < this.editor.plainText.length; i++) {
+        const previous = this.editor.cursorOffset;
+        if (forward) this.editor.moveCursorRight();
+        else this.editor.moveCursorLeft();
+        const current = this.editor.cursorOffset;
+        if (current === previous || this.editor.logicalCursor.row !== row) {
+          this.editor.cursorOffset = start;
+          break;
+        }
+        const end = current;
+        this.editor.moveCursorRight();
+        const next = this.editor.cursorOffset;
+        this.editor.cursorOffset = end;
+        if (this.editor.getTextRange(end, next) === char) {
+          if (till) {
+            if (forward) this.editor.moveCursorLeft();
+            else this.editor.moveCursorRight();
+          }
+          break;
+        }
+      }
+      this.find = "";
+      this.changed();
+      return consume();
+    }
+    if (/^[1-9]$/.test(char) || char === "0" && this.count) {
+      this.count = (this.count + char).slice(0, 5);
+      return consume();
+    }
+    const count = this.takeCount();
+    if (this.operator === "g") {
+      this.operator = "";
+      if (char === "g") {
+        this.motion("gg", this.operatorCount);
+        return consume();
+      }
+    }
+    if (this.operator && this.operator !== "g") {
+      const op = this.operator, repeat = count * this.operatorCount, start = this.editor.cursorOffset;
+      if (char === op) {
+        const range = this.lineRange(repeat);
+        this.operate(...range, op, true);
+        return consume();
+      }
+      if (this.motion(char, Math.min(1e4, repeat))) this.operate(start, this.editor.cursorOffset, op);
+      else this.reset();
+      return consume();
+    }
+    if (this.mode === "VISUAL" && ["d", "x", "c", "y"].includes(char)) {
+      const selection = this.editor.getSelection();
+      if (selection) this.operate(selection.start, selection.end, char === "x" ? "d" : char);
+      return consume();
+    }
+    if (this.motion(char, count)) {
+      if (this.mode === "VISUAL") this.select(this.anchor, this.editor.cursorOffset);
+      return consume();
+    }
+    if (char === "g") {
+      this.operator = "g";
+      this.operatorCount = count;
+      return consume();
+    }
+    if (["d", "c", "y"].includes(char)) {
+      this.operator = char;
+      this.operatorCount = count;
+      return consume();
+    }
+    if (char === "i" || char === "a" || char === "I" || char === "A") {
+      if (char === "a" && this.editor.cursorOffset < this.end()) this.editor.moveCursorRight();
+      if (char === "I") this.motion("^", 1);
+      if (char === "A") this.editor.gotoLineEnd();
+      this.mode = "INSERT";
+      this.reset();
+      this.changed();
+      return consume();
+    }
+    if (char === "o" || char === "O") {
+      if (char === "o") {
+        this.editor.gotoLineEnd();
+        this.editor.newLine();
+      } else {
+        this.editor.gotoLineHome();
+        this.editor.insertText("\n");
+        this.editor.moveCursorLeft();
+      }
+      this.mode = "INSERT";
+      this.changed();
+      return consume();
+    }
+    if (char === "v") {
+      if (this.mode === "VISUAL") this.normal();
+      else {
+        this.mode = "VISUAL";
+        this.anchor = this.editor.cursorOffset;
+        this.changed();
+      }
+      return consume();
+    }
+    if (char === "x" || char === "X") {
+      const start = this.editor.cursorOffset;
+      for (let i = 0; i < count; i++) char === "x" ? this.editor.moveCursorRight() : this.editor.moveCursorLeft();
+      this.operate(start, this.editor.cursorOffset, "d");
+      return consume();
+    }
+    if (char === "D" || char === "C") {
+      const start = this.editor.cursorOffset;
+      this.editor.gotoLineEnd();
+      this.operate(start, this.editor.cursorOffset, char === "C" ? "c" : "d");
+      return consume();
+    }
+    if (char === "p" || char === "P") {
+      if (this.register) {
+        if (this.linewise) {
+          if (char === "P") this.editor.gotoLineHome();
+          else {
+            this.editor.gotoLineEnd();
+            if (this.editor.cursorOffset < this.end()) this.editor.moveCursorRight();
+            else this.editor.insertText("\n");
+          }
+        } else if (char === "p") this.editor.moveCursorRight();
+        this.editor.insertText(this.register.repeat(Math.min(1e3, count)));
+      }
+      return consume();
+    }
+    if (char === "u") {
+      for (let i = 0; i < count; i++) this.editor.undo();
+      return consume();
+    }
+    if (["f", "F", "t", "T", "r"].includes(char)) {
+      this.find = char;
+      return consume();
+    }
+    if (char === "/" || char === "?") {
+      this.search = { value: "", backward: char === "?" };
+      this.changed();
+      return consume();
+    }
+    if ((char === "n" || char === "N") && this.lastSearch) {
+      this.searchFor(this.lastSearch.value, this.lastSearch.backward !== (char === "N"));
+      return consume();
+    }
+    return consume();
+  }
+};
+
+// packages/cli/src/tui/native/components/selection-menu.ts
+import { BoxRenderable as BoxRenderable5, CliRenderEvents as CliRenderEvents3, TextAttributes as TextAttributes6, TextRenderable as TextRenderable4 } 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);
+  }
+  renderer;
+  colors;
+  copy;
+  restoreFocus;
+  overlay;
+  panel;
+  frame;
+  previousFocus;
+  anchor = { x: 0, y: 0 };
+  selectedText = "";
+  get active() {
+    return Boolean(this.overlay);
+  }
+  open(x, y, text) {
+    if (!text) return;
+    this.close();
+    this.selectedText = text;
+    this.anchor = { x, y };
+    this.previousFocus = this.renderer.currentFocusedRenderable;
+    this.overlay = new BoxRenderable5(this.renderer, {
+      id: "omnius-selection-menu",
+      position: "absolute",
+      left: 0,
+      top: 0,
+      width: "100%",
+      height: "100%",
+      backgroundColor: "transparent",
+      shouldFill: false,
+      zIndex: 120,
+      onMouseDown: (event) => {
+        this.close();
+        event.preventDefault();
+        event.stopPropagation();
+      }
+    });
+    this.panel = new BoxRenderable5(this.renderer, {
+      id: "omnius-selection-menu-panel",
+      position: "absolute",
+      width: 14,
+      height: 3,
+      flexDirection: "column",
+      paddingX: 2,
+      paddingY: 1,
+      backgroundColor: this.colors.background,
+      onMouseDown: (event) => {
+        event.preventDefault();
+        event.stopPropagation();
+      }
+    });
+    const action = new TextRenderable4(this.renderer, {
+      id: "omnius-selection-copy",
+      content: "COPY",
+      height: 1,
+      width: "100%",
+      selectable: false,
+      fg: this.colors.foreground,
+      bg: this.colors.background,
+      attributes: TextAttributes6.BOLD | TextAttributes6.INVERSE,
+      onMouseDown: (event) => {
+        if (event.button === 0) this.confirm();
+        event.preventDefault();
+        event.stopPropagation();
+      }
+    });
+    action.focusable = true;
+    this.panel.add(action);
+    this.overlay.add(this.panel);
+    this.frame = new NativeCornerFrame(this.panel, this.colors, this.renderer, this.overlay);
+    this.renderer.root.add(this.overlay);
+    this.position();
+    action.focus();
+    this.renderer.requestRender();
+  }
+  position = () => {
+    if (!this.panel) return;
+    const width = Math.min(14, this.renderer.terminalWidth);
+    this.panel.width = width;
+    this.panel.left = Math.max(0, Math.min(this.anchor.x, this.renderer.terminalWidth - width));
+    this.panel.top = Math.max(0, Math.min(this.anchor.y + 1, this.renderer.terminalHeight - 3));
+  };
+  handleKey(key) {
+    if (key.eventType !== "release") {
+      if (key.name === "return" || key.sequence === " " || key.ctrl && key.shift && key.name.toLowerCase() === "c") this.confirm();
+      else if (key.name === "escape" || key.name === "tab") this.close();
+    }
+    key.preventDefault();
+    key.stopPropagation();
+  }
+  confirm() {
+    const text = this.selectedText;
+    this.close();
+    this.copy(text);
+  }
+  applyTheme(colors) {
+    this.colors = colors;
+    if (!this.panel) return;
+    this.panel.backgroundColor = colors.background;
+    this.frame?.setColors(colors);
+    for (const child of this.panel.getChildren()) if (child instanceof TextRenderable4) {
+      child.fg = colors.foreground;
+      child.bg = colors.background;
+    }
+  }
+  close() {
+    if (!this.overlay) return;
+    const previous = this.previousFocus;
+    this.previousFocus = void 0;
+    this.frame?.destroy();
+    this.frame = void 0;
+    this.overlay.destroyRecursively();
+    this.overlay = void 0;
+    this.panel = void 0;
+    this.selectedText = "";
+    if (previous && !previous.isDestroyed && previous.visible && previous.focusable) previous.focus();
+    else this.restoreFocus();
+    this.renderer.requestRender();
+  }
+  destroy() {
+    this.close();
+    this.renderer.off(CliRenderEvents3.RESIZE, this.position);
+  }
+};
+
 // packages/cli/src/tui/native/components/frontend.ts
 var initialTheme = { mode: "system", bg: -1, accent: -1, textPrimary: -1, textDim: -1, boxColor: -1 };
 var NativeFrontend = class {
-  constructor(renderer2, emit) {
+  constructor(renderer2, emit, options = {}) {
     this.renderer = renderer2;
     this.emit = emit;
     const colors = palette(initialTheme);
     this.context = { renderer: renderer2, colors, syntax: SyntaxStyle2.fromStyles({}, renderer2.nativeScene), emit, terminals: /* @__PURE__ */ new Map() };
     this.disposeSelectionContrast = installDefaultSelectionContrast(renderer2);
-    this.clipboard = createClipboard({ host: createHostClipboard({ timeoutMs: 1500 }), terminal: createRendererClipboardAdapter(renderer2) });
-    this.root = new BoxRenderable4(renderer2, {
+    this.clipboard = options.clipboard ?? createClipboard({ host: createHostClipboard({ timeoutMs: 1500 }), terminal: createRendererClipboardAdapter(renderer2) });
+    this.selectionMenu = new NativeSelectionMenu(renderer2, colors, (text) => {
+      void this.copy(text);
+    }, () => this.restoreFocus());
+    this.root = new BoxRenderable6(renderer2, {
       id: "omnius-native",
       width: "100%",
       height: "100%",
@@ -1878,7 +4227,7 @@ var NativeFrontend = class {
       backgroundColor: colors.background
     });
     renderer2.root.add(this.root);
-    this.header = new BoxRenderable4(renderer2, {
+    this.header = new BoxRenderable6(renderer2, {
       id: "omnius-header",
       width: "100%",
       minWidth: 0,
@@ -1889,9 +4238,19 @@ var NativeFrontend = class {
       borderColor: colors.border
     });
     this.root.add(this.header);
-    const headerRow = new BoxRenderable4(renderer2, { id: "omnius-header-row", width: "100%", minWidth: 0, minHeight: 1, flexDirection: "row", gap: 1 });
+    this.header.renderAfter = (buffer) => {
+      if (this.header.height > 0) buffer.drawText(
+        formatSignalDivider(this.header.width),
+        this.header.x,
+        this.header.y + this.header.height - 1,
+        this.context.colors.foreground,
+        this.context.colors.background,
+        TextAttributes7.DIM
+      );
+    };
+    const headerRow = new BoxRenderable6(renderer2, { id: "omnius-header-row", width: "100%", minWidth: 0, minHeight: 1, flexDirection: "row", gap: 1 });
     this.header.add(headerRow);
-    this.identity = new TextRenderable4(renderer2, {
+    this.identity = new TextRenderable5(renderer2, {
       id: "omnius-identity",
       content: "Omnius",
       fg: colors.foreground,
@@ -1901,7 +4260,7 @@ var NativeFrontend = class {
       truncate: true,
       minWidth: 18,
       selectable: false,
-      attributes: TextAttributes6.BOLD,
+      attributes: TextAttributes7.BOLD,
       onMouseDown: (event) => {
         if (event.button === 0) {
           this.toggleHeaderPanel();
@@ -1929,16 +4288,16 @@ var NativeFrontend = class {
       verticalScrollbarOptions: { visible: false }
     });
     headerRow.add(this.headerActions);
-    this.headerPanel = new TextRenderable4(renderer2, { id: "omnius-header-panel", content: "", width: "100%", wrapMode: "word", visible: false });
+    this.headerPanel = new TextRenderable5(renderer2, { id: "omnius-header-panel", content: "", width: "100%", wrapMode: "word", visible: false });
     this.header.add(this.headerPanel);
-    this.detailButton = new TextRenderable4(renderer2, {
+    this.detailButton = new TextRenderable5(renderer2, {
       id: "omnius-details-toggle",
       content: "+ DETAILS",
       height: 1,
       width: 9,
       flexShrink: 0,
       fg: colors.foreground,
-      attributes: TextAttributes6.DIM,
+      attributes: TextAttributes7.DIM,
       selectable: false,
       onMouseDown: (event) => {
         if (event.button === 0) {
@@ -1958,13 +4317,13 @@ var NativeFrontend = class {
     for (const control of [this.identity, this.detailButton]) {
       const attributes = control.attributes;
       control.on("focused", () => {
-        control.attributes = attributes | TextAttributes6.INVERSE;
+        control.attributes = attributes | TextAttributes7.INVERSE;
       });
       control.on("blurred", () => {
         control.attributes = attributes;
       });
     }
-    this.routeWarning = new TextRenderable4(renderer2, { id: "omnius-route-warning", content: "", width: "100%", wrapMode: "word", fg: colors.warning, attributes: TextAttributes6.BOLD | TextAttributes6.UNDERLINE, visible: false, flexShrink: 0 });
+    this.routeWarning = new TextRenderable5(renderer2, { id: "omnius-route-warning", content: "", width: "100%", wrapMode: "word", fg: colors.warning, attributes: TextAttributes7.BOLD | TextAttributes7.UNDERLINE, visible: false, flexShrink: 0 });
     this.root.add(this.routeWarning);
     this.tabs = new TabSelectRenderable(renderer2, {
       id: "omnius-agent-tabs",
@@ -2003,13 +4362,13 @@ var NativeFrontend = class {
       const selected = this.tabs.getSelectedIndex();
       const start = Math.max(0, Math.min(selected - Math.floor(count / 2), this.tabs.options.length - count));
       buffer.fillRect(0, 1, this.tabs.width, 1, colors2.background);
-      buffer.drawText("─".repeat(Math.max(0, tabWidth)), (selected - start) * tabWidth, 1, colors2.foreground, colors2.background, TextAttributes6.DIM);
+      buffer.drawText("─".repeat(Math.max(0, tabWidth)), (selected - start) * tabWidth, 1, colors2.foreground, colors2.background, TextAttributes7.DIM);
     };
     this.root.add(this.tabs);
-    this.taskPane = new BoxRenderable4(renderer2, { id: "omnius-tasks", width: "100%", flexDirection: "column", maxHeight: 6, flexShrink: 0, overflow: "hidden", visible: false });
+    this.taskPane = new BoxRenderable6(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 BoxRenderable4(renderer2, { id: "omnius-body", width: "100%", flexDirection: "row", flexGrow: 1, minHeight: 1 });
+    this.body = new BoxRenderable6(renderer2, { id: "omnius-body", width: "100%", flexDirection: "row", flexGrow: 1, minHeight: 1 });
     this.root.add(this.body);
     this.scroll = new ScrollBoxRenderable4(renderer2, {
       id: "omnius-conversation",
@@ -2024,6 +4383,15 @@ var NativeFrontend = class {
       viewportCulling: true,
       verticalScrollbarOptions: { showArrows: false, trackOptions: { foregroundColor: colors.dim, backgroundColor: colors.background } },
       contentOptions: { flexDirection: "column", onMouseDown: (event) => {
+        if (event.button === 2) {
+          const selected = this.renderer.getSelection()?.getSelectedText();
+          if (selected) {
+            this.selectionMenu.open(event.x, event.y, selected);
+            event.preventDefault();
+            event.stopPropagation();
+          }
+          return;
+        }
         if (!this.selectionArmed || event.button !== 0 || !event.target) return;
         this.selectionArmed = false;
         let block = event.target;
@@ -2043,13 +4411,39 @@ var NativeFrontend = class {
         }
         event.preventDefault();
         event.stopPropagation();
+      }, onMouseDrag: (event) => {
+        if (!event.isDragging || !event.target || !this.renderer.getSelection()?.isDragging) return;
+        let container = this.renderer.getSelectionContainer();
+        while (container) {
+          let current = event.target;
+          while (current && current !== container) current = current.parent;
+          if (current) break;
+          this.renderer.updateSelection(event.target, event.x, event.y);
+          const next = this.renderer.getSelectionContainer();
+          if (next === container) break;
+          container = next;
+        }
       } }
     });
     this.body.add(this.scroll);
     this.content = new NativeBlockList(this.context, this.scroll);
-    this.instruments = new InstrumentRail(renderer2, { colors, onInspectAgent: (id) => this.emitAction("view", id) });
+    this.instrumentDivider = new InstrumentDivider(renderer2, {
+      resize: (column) => this.resizeInstruments(column),
+      toggle: () => this.toggleDetails(),
+      start: () => {
+        this.sidebarDragWidth = this.sidebarWidth ?? Math.floor(this.renderer.terminalWidth * 0.38);
+      },
+      finish: () => {
+        this.sidebarDragWidth = void 0;
+      }
+    });
+    this.body.add(this.instrumentDivider);
+    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.body.add(this.instruments);
-    this.embeddedPane = new BoxRenderable4(renderer2, {
+    this.embeddedPane = new BoxRenderable6(renderer2, {
       id: "omnius-editor-pane",
       width: "50%",
       flexShrink: 0,
@@ -2060,7 +4454,7 @@ var NativeFrontend = class {
       visible: false
     });
     this.body.add(this.embeddedPane);
-    this.liveButton = new TextRenderable4(renderer2, {
+    this.liveButton = new TextRenderable5(renderer2, {
       id: "omnius-live-button",
       content: "↓ Live",
       width: "100%",
@@ -2083,7 +4477,7 @@ var NativeFrontend = class {
     });
     this.liveButton.focusable = true;
     this.root.add(this.liveButton);
-    this.queue = new TextRenderable4(renderer2, { id: "omnius-steering-queue", content: "", width: "100%", height: 1, wrapMode: "none", truncate: true, fg: colors.dim, visible: false, flexShrink: 0 });
+    this.queue = new TextRenderable5(renderer2, { id: "omnius-steering-queue", content: "", width: "100%", height: 1, wrapMode: "none", truncate: true, fg: colors.dim, visible: false, flexShrink: 0 });
     this.root.add(this.queue);
     this.suggestions = new NativeSelectRenderable(renderer2, {
       id: "omnius-suggestions",
@@ -2102,9 +4496,9 @@ var NativeFrontend = class {
     this.suggestions.onActivate = () => this.acceptSuggestion();
     this.suggestions.on("itemSelected", () => this.acceptSuggestion());
     this.root.add(this.suggestions);
-    this.status = new BoxRenderable4(renderer2, { id: "omnius-live-status", width: "100%", height: 1, flexShrink: 0, flexDirection: "row", gap: 2, visible: false });
+    this.status = new BoxRenderable6(renderer2, { id: "omnius-live-status", width: "100%", height: 1, flexShrink: 0, flexDirection: "row", gap: 2, visible: false });
     this.root.add(this.status);
-    this.footer = new BoxRenderable4(renderer2, {
+    this.footer = new BoxRenderable6(renderer2, {
       id: "omnius-input-box",
       width: "100%",
       flexShrink: 0,
@@ -2114,9 +4508,19 @@ var NativeFrontend = class {
       flexDirection: "column"
     });
     this.root.add(this.footer);
-    const inputRow = new BoxRenderable4(renderer2, { id: "omnius-input-row", width: "100%", flexDirection: "row", gap: 1 });
+    this.footer.renderAfter = (buffer) => {
+      if (this.footer.height > 0) buffer.drawText(
+        formatSignalDivider(this.footer.width),
+        this.footer.x,
+        this.footer.y,
+        this.context.colors.foreground,
+        this.context.colors.background,
+        TextAttributes7.DIM
+      );
+    };
+    const inputRow = new BoxRenderable6(renderer2, { id: "omnius-input-row", width: "100%", flexDirection: "row", gap: 1 });
     this.footer.add(inputRow);
-    this.prompt = new TextRenderable4(renderer2, { id: "omnius-prompt", content: "❯", fg: colors.accent, wrapMode: "none", selectable: false, flexShrink: 0 });
+    this.prompt = new TextRenderable5(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",
@@ -2136,32 +4540,63 @@ var NativeFrontend = class {
       onCursorChange: () => this.editorChanged(),
       onSubmit: () => this.submit()
     });
+    this.vimMode = new TextRenderable5(renderer2, {
+      id: "omnius-vim-mode",
+      content: "INSERT",
+      height: 1,
+      maxWidth: 12,
+      flexShrink: 0,
+      fg: colors.foreground,
+      attributes: TextAttributes7.DIM,
+      wrapMode: "none",
+      truncate: true,
+      visible: false,
+      selectable: false
+    });
+    inputRow.add(this.vimMode);
+    this.vimComposer = new VimComposer(this.editor, () => {
+      this.vimMode.visible = this.vimComposer.enabled;
+      this.vimMode.content = this.vimComposer.label;
+      this.editorChanged();
+      this.renderer.requestRender();
+    });
     inputRow.add(this.editor);
-    this.enhance = new BoxRenderable4(renderer2, { id: "omnius-enhance", flexDirection: "row", gap: 1, flexShrink: 0, visible: false });
+    this.enhance = new BoxRenderable6(renderer2, { id: "omnius-enhance", flexDirection: "row", gap: 1, flexShrink: 0, visible: false });
     inputRow.add(this.enhance);
-    this.activity = new TextRenderable4(renderer2, { id: "omnius-activity", content: "", flexGrow: 1, minWidth: 0, height: 1, wrapMode: "none", truncate: true, visible: false, fg: colors.accent });
+    this.activity = new TextRenderable5(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 BoxRenderable4(renderer2, { id: "omnius-media", height: 1, minWidth: 0, flexShrink: 1, flexDirection: "row", gap: 1, visible: false });
-    this.mediaText = new TextRenderable4(renderer2, { id: "omnius-media-text", content: "", flexGrow: 1, minWidth: 0, wrapMode: "none", truncate: true, fg: colors.accent });
+    this.media = new BoxRenderable6(renderer2, { id: "omnius-media", height: 1, minWidth: 0, flexShrink: 1, flexDirection: "row", gap: 1, visible: false });
+    this.mediaText = new TextRenderable5(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 TextRenderable4(renderer2, { id: "omnius-mic-meter", width: 12, height: 1, flexShrink: 0, fg: colors.foreground, visible: false });
+    this.micTrack = new TextRenderable5(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.metricsRow = new BoxRenderable4(renderer2, { id: "omnius-metrics-row", width: "100%", height: 1, flexShrink: 0, flexDirection: "row", gap: 1 });
-    this.keyHints = new TextRenderable4(renderer2, { id: "omnius-key-hints", content: "F1 HELP  TAB FOCUS", height: 1, flexShrink: 0, attributes: TextAttributes6.DIM, fg: colors.foreground, selectable: false });
+    this.copyFeedback = new TextRenderable5(renderer2, {
+      id: "omnius-copy-feedback",
+      content: "",
+      height: 1,
+      flexShrink: 0,
+      fg: colors.foreground,
+      attributes: TextAttributes7.DIM,
+      selectable: false,
+      visible: false
+    });
+    this.status.add(this.copyFeedback);
+    this.metricsRow = new BoxRenderable6(renderer2, { id: "omnius-metrics-row", width: "100%", height: 1, flexShrink: 0, flexDirection: "row", gap: 1 });
+    this.keyHints = new TextRenderable5(renderer2, { id: "omnius-key-hints", content: "F1 HELP  TAB FOCUS", height: 1, flexShrink: 0, attributes: TextAttributes7.DIM, fg: colors.foreground, selectable: false });
     this.metricsRow.add(this.keyHints);
-    this.metricsStartActions = new BoxRenderable4(renderer2, { id: "omnius-metrics-start-actions", flexDirection: "row", gap: 1, flexShrink: 0 });
+    this.metricsStartActions = new BoxRenderable6(renderer2, { id: "omnius-metrics-start-actions", flexDirection: "row", gap: 1, flexShrink: 0 });
     this.metricsRow.add(this.metricsStartActions);
-    this.metrics = new TextRenderable4(renderer2, { id: "omnius-metrics", content: "", height: 1, wrapMode: "none", truncate: true, fg: colors.dim, flexShrink: 1, flexGrow: 1, minWidth: 0 });
+    this.metrics = new TextRenderable5(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 BoxRenderable4(renderer2, { id: "omnius-metrics-end-actions", flexDirection: "row", gap: 1, flexShrink: 0 });
+    this.metricsEndActions = new BoxRenderable6(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(CliRenderEvents2.FRAME, this.onFrame);
-    renderer2.on(CliRenderEvents2.RESIZE, this.onResize);
+    renderer2.on(CliRenderEvents4.FRAME, this.onFrame);
+    renderer2.on(CliRenderEvents4.RESIZE, this.onResize);
     this.applyTheme(initialTheme);
     this.editor.focus();
   }
@@ -2170,9 +4605,11 @@ var NativeFrontend = class {
   root;
   scroll;
   editor;
+  vimComposer;
   content;
   modals;
   context;
+  selectionMenu;
   header;
   identity;
   headerActions;
@@ -2183,6 +4620,7 @@ var NativeFrontend = class {
   tasks;
   body;
   instruments;
+  instrumentDivider;
   detailButton;
   embeddedPane;
   liveButton;
@@ -2190,6 +4628,7 @@ var NativeFrontend = class {
   suggestions;
   footer;
   prompt;
+  vimMode;
   enhance;
   metrics;
   keyHints;
@@ -2202,6 +4641,8 @@ var NativeFrontend = class {
   mediaText;
   micTrack;
   clipboard;
+  copyFeedback;
+  copyFeedbackTimer;
   state;
   themeSignature = "";
   headerSignature = "";
@@ -2219,6 +4660,9 @@ var NativeFrontend = class {
   disposeSelectionContrast;
   actionSignatures = /* @__PURE__ */ new WeakMap();
   detailsOpen;
+  narrowDetailsOpen = false;
+  sidebarWidth;
+  sidebarDragWidth;
   headerPanelCollapsed = false;
   inputEventPending = false;
   viewportSignature = "";
@@ -2317,8 +4761,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 ? TextAttributes6.DIM : action.active ? TextAttributes6.BOLD | TextAttributes6.UNDERLINE : 0;
-      const button = new TextRenderable4(this.renderer, {
+      const attributes = action.disabled ? TextAttributes7.DIM : action.active ? TextAttributes7.BOLD | TextAttributes7.UNDERLINE : 0;
+      const button = new TextRenderable5(this.renderer, {
         id: `${prefix}:${action.id}`,
         content: styledText(action.label),
         flexShrink: 0,
@@ -2341,16 +4785,16 @@ var NativeFrontend = class {
       button.focusable = !action.disabled;
       if (!action.disabled) {
         button.on("focused", () => {
-          button.attributes = attributes | TextAttributes6.INVERSE;
+          button.attributes = attributes | TextAttributes7.INVERSE;
         });
         button.on("blurred", () => {
           button.attributes = attributes;
         });
         button.onMouseOver = () => {
-          button.attributes = attributes | TextAttributes6.UNDERLINE | (button.focused ? TextAttributes6.INVERSE : 0);
+          button.attributes = attributes | TextAttributes7.UNDERLINE | (button.focused ? TextAttributes7.INVERSE : 0);
         };
         button.onMouseOut = () => {
-          button.attributes = attributes | (button.focused ? TextAttributes6.INVERSE : 0);
+          button.attributes = attributes | (button.focused ? TextAttributes7.INVERSE : 0);
         };
       }
       parent.add(button);
@@ -2366,14 +4810,15 @@ var NativeFrontend = class {
   renderActivity() {
     const activity = this.state?.activity;
     const stage = activity?.stage === "idle" ? void 0 : activity?.stage;
-    this.activity.visible = Boolean(activity?.processing || activity?.label || stage);
-    this.activity.content = `${activity?.processing ? "RUN · " : ""}${activity?.label || stage || ""}`;
-    this.status.visible = this.activity.visible || this.media.visible;
+    const reading = activity?.label || stage || 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;
   }
   renderMedia() {
     const media = this.state?.media;
     this.media.visible = Boolean(media && (media.audio || media.video || media.voiceEnabled || media.recording || media.countdown > 0 || media.label));
-    this.status.visible = this.activity.visible || this.media.visible;
+    this.status.visible = this.activity.visible || this.media.visible || this.copyFeedback.visible;
     if (!media) return;
     this.mediaText.content = [
       media.recording ? "● REC" : void 0,
@@ -2397,25 +4842,7 @@ var NativeFrontend = class {
     this.headerSignature = "";
     this.metricsActionsSignature = "";
     const colors = this.context.colors = palette(theme);
-    for (const [name, style] of Object.entries({
-      default: { fg: colors.foreground },
-      conceal: { fg: colors.foreground },
-      "markup.heading": { fg: colors.accent, bold: true },
-      "markup.strong": { fg: colors.foreground, bold: true },
-      "markup.italic": { fg: colors.foreground, italic: true },
-      "markup.link": { fg: colors.accent, underline: true },
-      "markup.link.url": { fg: colors.dim },
-      "markup.raw": { fg: colors.accent },
-      "markup.list": { fg: colors.accent },
-      "markup.quote": { fg: colors.dim },
-      comment: { fg: colors.dim, italic: true },
-      keyword: { fg: colors.accent, bold: true },
-      string: { fg: colors.success },
-      number: { fg: colors.warning },
-      function: { fg: colors.foreground },
-      type: { fg: colors.accent },
-      punctuation: { fg: colors.dim }
-    })) this.context.syntax.registerStyle(name, style);
+    installNativeSyntax(this.context.syntax, colors);
     this.root.backgroundColor = colors.background;
     this.header.backgroundColor = this.footer.backgroundColor = colors.background;
     this.header.borderColor = this.footer.borderColor = this.embeddedPane.borderColor = colors.border;
@@ -2423,6 +4850,7 @@ var NativeFrontend = class {
     this.headerPanel.fg = colors.foreground;
     this.routeWarning.fg = colors.warning;
     this.prompt.fg = this.activity.fg = this.liveButton.fg = colors.accent;
+    this.vimMode.fg = colors.foreground;
     this.micTrack.fg = colors.foreground;
     this.queue.fg = this.metrics.fg = colors.dim;
     this.editor.backgroundColor = this.editor.focusedBackgroundColor = colors.background;
@@ -2439,6 +4867,10 @@ var NativeFrontend = class {
     styleNativeScrollbars(this.headerActions, colors);
     styleNativeScrollbars(this.scroll, colors);
     this.instruments.applyTheme(colors);
+    this.instrumentDivider.fg = colors.foreground;
+    this.instrumentDivider.bg = colors.background;
+    this.copyFeedback.fg = colors.foreground;
+    this.selectionMenu.applyTheme(colors);
     this.content.applyTheme();
     this.tasks.applyTheme();
     this.modals?.applyTheme();
@@ -2450,23 +4882,47 @@ var NativeFrontend = class {
     this.update(this.state);
   }
   toggleDetails() {
-    this.detailsOpen = !(this.detailsOpen ?? this.renderer.terminalWidth >= 110);
+    if (this.renderer.terminalWidth >= 110) this.detailsOpen = !(this.detailsOpen ?? true);
+    else this.narrowDetailsOpen = !this.narrowDetailsOpen;
+    this.layoutInstruments();
+    this.renderer.requestRender();
+  }
+  resizeInstruments(column) {
+    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);
+    if (requested <= 4) {
+      this.detailsOpen = false;
+      if (this.sidebarDragWidth !== void 0) this.sidebarWidth = this.sidebarDragWidth;
+    } else {
+      this.detailsOpen = true;
+      this.sidebarWidth = Math.max(24, Math.min(width - 41, requested));
+    }
     this.layoutInstruments();
     this.renderer.requestRender();
   }
   layoutInstruments() {
     const width = this.renderer.terminalWidth;
+    const focusedBeforeLayout = this.renderer.currentFocusedRenderable;
     const wide = width >= 110;
-    const shown = !this.embeddedPane.visible && (this.detailsOpen ?? wide);
-    this.body.flexDirection = wide || this.embeddedPane.visible && width >= 80 ? "row" : "column";
+    const shown = !this.embeddedPane.visible && (wide ? this.detailsOpen ?? true : this.narrowDetailsOpen);
+    const horizontal = wide || this.embeddedPane.visible && width >= 80;
+    this.body.flexDirection = horizontal ? "row" : "column";
+    this.scroll.height = horizontal ? "100%" : "auto";
+    this.scroll.flexBasis = horizontal ? "auto" : 0;
     this.instruments.visible = shown;
-    const railWidth = Math.floor(width * 0.38);
+    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)));
     this.instruments.width = wide ? railWidth : "100%";
-    this.scroll.width = shown && wide ? width - railWidth : this.embeddedPane.visible && width >= 80 ? "50%" : "100%";
-    this.instruments.maxHeight = wide ? "100%" : Math.max(4, Math.min(9, Math.floor(this.renderer.terminalHeight / 3)));
+    this.scroll.width = wide && this.instrumentDivider.visible ? width - (shown ? railWidth : 0) - 1 : this.embeddedPane.visible && width >= 80 ? "50%" : "100%";
+    const inspectorHeight = Math.max(4, Math.min(9, Math.floor(this.renderer.terminalHeight / 3)));
+    this.instruments.height = wide ? "100%" : inspectorHeight;
+    this.instruments.maxHeight = wide ? "100%" : inspectorHeight;
+    this.instruments.minHeight = wide ? 1 : inspectorHeight;
     this.instruments.flexGrow = 0;
-    this.instruments.flexShrink = wide ? 0 : 1;
-    this.instruments.border = wide ? ["left"] : ["top"];
+    this.instruments.flexShrink = 0;
+    this.instruments.border = wide ? [] : ["top"];
     this.instruments.borderStyle = "single";
     this.instruments.borderColor = this.context.colors.border;
     this.instruments.paddingLeft = wide ? 1 : 0;
@@ -2484,8 +4940,8 @@ var NativeFrontend = class {
     this.detailButton.width = detailWidth;
     this.keyHints.content = width < 60 ? "F1 HELP" : "F1 HELP  TAB FOCUS";
     this.detailButton.content = `${shown ? "-" : "+"}${detailWidth > 1 ? " DETAILS" : ""}`;
-    for (let focused = this.renderer.currentFocusedRenderable; focused; focused = focused.parent) {
-      if (!shown && focused === this.instruments || !this.headerActions.visible && focused === this.headerActions) {
+    for (let focused = focusedBeforeLayout; focused; focused = focused.parent) {
+      if (!shown && focused === this.instruments || !this.instrumentDivider.visible && focused === this.instrumentDivider || !this.headerActions.visible && focused === this.headerActions) {
         this.restoreFocus();
         break;
       }
@@ -2553,8 +5009,11 @@ var NativeFrontend = class {
   }
   submit() {
     if (this.paused || this.state?.input.enabled === false) return;
-    if (this.suggestions.visible && this.editor.plainText.startsWith("/") && this.acceptSuggestion()) return;
     const text = this.editor.plainText;
+    const command2 = /^\/([^\s]+)/.exec(text.trimStart())?.[1];
+    const suggestion = String(this.suggestions.getSelectedOption()?.value ?? "");
+    if (this.suggestions.visible && command2 && !findCommand(command2) && suggestion.startsWith(text.trimEnd()) && this.acceptSuggestion()) return;
+    this.suggestions.visible = false;
     if (text.trim() && this.history[0] !== text) {
       this.history.unshift(text);
       this.history.length = Math.min(this.history.length, 1e3);
@@ -2599,6 +5058,10 @@ var NativeFrontend = class {
     this.emit({ type: "action", action, ...id === void 0 ? {} : { id } });
   }
   onKey = (key) => {
+    if (this.selectionMenu.active) {
+      this.selectionMenu.handleKey(key);
+      return;
+    }
     if (this.modals.active) {
       this.modals.active.handleKey(key);
       return;
@@ -2675,6 +5138,7 @@ var NativeFrontend = class {
       this.shortcut("ctrl-u", key);
       return;
     }
+    if (this.renderer.currentFocusedRenderable === this.editor && !this.paused && this.state?.input.enabled !== false && this.vimComposer.handle(key)) return;
     if (key.name === "escape") {
       if (this.renderer.currentFocusedRenderable !== this.editor) {
         this.restoreFocus();
@@ -2769,6 +5233,10 @@ var NativeFrontend = class {
     }
   }
   onPaste = (event) => {
+    if (this.selectionMenu.active) {
+      event.preventDefault();
+      return;
+    }
     if (this.modals.active) {
       this.modals.active.handlePaste(event);
       return;
@@ -2785,8 +5253,27 @@ var NativeFrontend = class {
     else if (!this.paused && this.state?.input.enabled !== false) this.editor.focus();
   }
   async copy(text) {
-    const value = text ?? this.renderer.getSelection()?.getSelectedText() ?? this.editor.getSelectedText();
-    if (value) await this.clipboard.writeText(value, { destination: "best-available" });
+    const value = text ?? (this.renderer.getSelection()?.getSelectedText() || this.editor.getSelectedText());
+    if (!value) return;
+    let message;
+    try {
+      const result = await this.clipboard.writeText(value, { destination: "best-available" });
+      message = result.host.status === "written" ? "COPIED" : result.terminal.status === "attempted" ? "COPY SENT TO TERMINAL" : "COPY UNAVAILABLE";
+    } catch {
+      message = "COPY FAILED";
+    }
+    if (this.destroyed) return;
+    if (this.copyFeedbackTimer) clearTimeout(this.copyFeedbackTimer);
+    this.copyFeedback.content = message;
+    this.copyFeedback.visible = true;
+    this.status.visible = true;
+    this.renderer.requestRender();
+    this.copyFeedbackTimer = setTimeout(() => {
+      this.copyFeedbackTimer = void 0;
+      this.copyFeedback.visible = false;
+      this.status.visible = this.activity.visible || this.media.visible;
+      this.renderer.requestRender();
+    }, 3e3);
   }
   async paste() {
     const result = await this.clipboard.read({ preferredTypes: ["text/plain;charset=utf-8", "text/plain"] });
@@ -2816,6 +5303,10 @@ var NativeFrontend = class {
       case "input-action":
         this.inputAction(command2.action, command2.value);
         break;
+      case "composer-vim":
+        this.vimComposer.setEnabled(command2.enabled);
+        this.restoreFocus();
+        break;
       case "mouse":
         this.renderer.useMouse = command2.enabled;
         break;
@@ -2826,6 +5317,7 @@ var NativeFrontend = class {
         this.renderer.setTerminalTitle(command2.text);
         break;
       case "modal-open":
+        this.selectionMenu.close();
         this.modals.open(command2.modal);
         break;
       case "modal-update":
@@ -2894,6 +5386,7 @@ var NativeFrontend = class {
       this.embeddedPane.add(terminal);
     }
     terminal.focus();
+    this.layoutInstruments();
   }
   closeEmbedded(id) {
     this.context.terminals.get(id)?.destroy();
@@ -2901,17 +5394,20 @@ var NativeFrontend = class {
     if (this.embeddedId === id) {
       this.embeddedId = void 0;
       this.embeddedPane.visible = false;
+      this.layoutInstruments();
       this.restoreFocus();
     }
   }
   async dispose() {
     if (this.destroyed) return;
     this.destroyed = true;
+    if (this.copyFeedbackTimer) clearTimeout(this.copyFeedbackTimer);
+    this.selectionMenu.destroy();
     this.disposeSelectionContrast();
     this.renderer.keyInput.off("keypress", this.onKey);
     this.renderer.keyInput.off("paste", this.onPaste);
-    this.renderer.off(CliRenderEvents2.FRAME, this.onFrame);
-    this.renderer.off(CliRenderEvents2.RESIZE, this.onResize);
+    this.renderer.off(CliRenderEvents4.FRAME, this.onFrame);
+    this.renderer.off(CliRenderEvents4.RESIZE, this.onResize);
     this.modals.destroy();
     this.content.destroy();
     this.tasks.destroy();
@@ -2922,7 +5418,7 @@ var NativeFrontend = class {
 };
 
 // packages/cli/src/tui/native/components/cursor.ts
-import { CliRenderEvents as CliRenderEvents3 } from "@opentui/core";
+import { CliRenderEvents as CliRenderEvents5 } from "@opentui/core";
 function installTerminalCursorDefaults(renderer2, session) {
   const reset = new TextEncoder().encode("\x1B]112\x07");
   let disposed = false;
@@ -2972,11 +5468,11 @@ function installTerminalCursorDefaults(renderer2, session) {
   const dispose = () => {
     if (disposed) return;
     disposed = true;
-    renderer2.off(CliRenderEvents3.FRAME, afterFrame);
-    renderer2.off(CliRenderEvents3.DESTROY, dispose);
+    renderer2.off(CliRenderEvents5.FRAME, afterFrame);
+    renderer2.off(CliRenderEvents5.DESTROY, dispose);
   };
-  renderer2.on(CliRenderEvents3.FRAME, afterFrame);
-  renderer2.once(CliRenderEvents3.DESTROY, dispose);
+  renderer2.on(CliRenderEvents5.FRAME, afterFrame);
+  renderer2.once(CliRenderEvents5.DESTROY, dispose);
   return { restore, dispose };
 }
 
@@ -3052,10 +5548,10 @@ try {
     maxFps: 60,
     clearOnShutdown: false
   });
-  renderer.on(CliRenderEvents4.RENDER_ERROR, (event) => {
+  renderer.on(CliRenderEvents6.RENDER_ERROR, (event) => {
     void fail(event.error);
   });
-  renderer.on(CliRenderEvents4.HANDLER_ERROR, (event) => {
+  renderer.on(CliRenderEvents6.HANDLER_ERROR, (event) => {
     void fail(event.error);
   });
   renderer.on("error", (event) => {