omp-fabric 0.85.0

package/dist/ui/conversation.js

@@ -0,0 +1,1868 @@
+import {
+  ompSymbolTheme
+} from "../chunks/chunk-G2IBGGBM.js";
+import {
+  defaultConversationTarget
+} from "../chunks/chunk-XU5Z4JCQ.js";
+import {
+  conversationFooter
+} from "../chunks/chunk-NCPJZXLM.js";
+import {
+  isActiveStatus
+} from "../chunks/chunk-QPXSCMTG.js";
+import {
+  safeText
+} from "../chunks/chunk-KIH3KLZU.js";
+import {
+  terminalSafe,
+  unwrapActorEnvelopeText
+} from "../chunks/chunk-DLXPTBPL.js";
+
+// src/ui/conversation.ts
+import {
+  CURSOR_MARKER,
+  Editor,
+  fuzzyFilter,
+  getKeybindings as getKeybindings2,
+  Input,
+  Key as Key2,
+  matchesKey as matchesKey2,
+  truncateToWidth as truncateToWidth2,
+  visibleWidth
+} from "@oh-my-pi/pi-tui";
+
+// src/ui/conversation-render.ts
+import {
+  AssistantMessageComponent,
+  BashExecutionComponent,
+  BranchSummaryMessageComponent,
+  CompactionSummaryMessageComponent,
+  ToolExecutionComponent,
+  UserMessageComponent
+} from "@oh-my-pi/pi-coding-agent";
+import { wrapTextWithAnsi } from "@oh-my-pi/pi-tui";
+var textOf = (content) => {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.filter(
+    (part) => typeof part === "object" && part !== null && part.type === "text" && typeof part.text === "string"
+  ).map((part) => part.text).join("\n");
+};
+var safeRender = (component, width, fallback) => {
+  try {
+    return [...component.render(width)];
+  } catch {
+    return fallback();
+  }
+};
+var FabricConversationTranscriptRenderer = class {
+  constructor(tui, theme, rendererOptions = {}) {
+    this.tui = tui;
+    this.theme = theme;
+    this.rendererOptions = rendererOptions;
+  }
+  disposed = false;
+  toolComponents = /* @__PURE__ */ new Map();
+  assistantComponents = /* @__PURE__ */ new Map();
+  messageComponents = /* @__PURE__ */ new Map();
+  invalidate() {
+    if (this.disposed) return;
+    this.toolComponents.clear();
+    this.assistantComponents.clear();
+    this.messageComponents.clear();
+    this.tui.requestRender();
+  }
+  dispose() {
+    this.disposed = true;
+    this.invalidate();
+  }
+  render(transcript, width, options) {
+    if (this.disposed || width <= 0) return [];
+    const lines = [];
+    if (transcript.messages.length === 0 && !transcript.streaming.partialAssistant && transcript.streaming.tools.length === 0) {
+      return [this.theme.fg("dim", "No retained transcript yet; new agent activity will appear here.")];
+    }
+    if (transcript.hasMore) lines.push(this.theme.fg("dim", "\u2191 older activity available"));
+    const renderedTools = /* @__PURE__ */ new Set();
+    for (const message of transcript.messages) this.renderMessage(message, width, options, lines, renderedTools);
+    if (transcript.streaming.partialAssistant) {
+      this.renderAssistant(transcript.streaming.partialAssistant, width, options, lines, renderedTools, true);
+    }
+    for (const tool of transcript.streaming.tools) {
+      if (renderedTools.has(tool.toolCallId)) continue;
+      renderedTools.add(tool.toolCallId);
+      this.renderTool(tool.toolCallId, tool.toolName, tool.args, tool.result, tool.partial, tool.isError, width, options, lines, true);
+    }
+    if (transcript.hasNewer) lines.push(this.theme.fg("dim", "\u2193 newer activity available"));
+    return lines;
+  }
+  renderMessage(message, width, options, lines, renderedTools) {
+    switch (message.role) {
+      case "user": {
+        const text = unwrapActorEnvelopeText(textOf(message.content)) ?? textOf(message.content);
+        if (text) this.push(lines, safeRender(new UserMessageComponent(terminalSafe(text, false)), width, () => this.fallback(text, width)));
+        return;
+      }
+      case "assistant":
+        this.renderAssistant(message, width, options, lines, renderedTools, false);
+        return;
+      case "toolResult":
+        if (typeof message.toolCallId === "string") {
+          this.renderTool(message.toolCallId, message.toolName ?? "tool", void 0, message, void 0, message.isError, width, options, lines, false);
+        }
+        return;
+      case "bashExecution":
+        this.renderBash(message, width, options, lines);
+        return;
+      case "custom":
+        this.renderCustom(message, width, options, lines);
+        return;
+      case "compactionSummary":
+        this.renderSummary(message, width, options, lines, CompactionSummaryMessageComponent);
+        return;
+      case "branchSummary":
+        this.renderSummary(message, width, options, lines, BranchSummaryMessageComponent);
+        return;
+      default:
+        return;
+    }
+  }
+  renderAssistant(message, width, options, lines, renderedTools, transient) {
+    const key = `${message.timestamp}:${options.target.id}:${options.hideThinking === true}`;
+    let component = this.assistantComponents.get(key);
+    if (!component) {
+      component = new AssistantMessageComponent(message, options.hideThinking ?? false);
+      this.assistantComponents.set(key, component);
+    } else {
+      component.updateContent(message, { transient });
+    }
+    this.push(lines, safeRender(component, width, () => this.fallback(textOf(message.content), width)));
+    for (const block of message.content) {
+      if (block.type !== "toolCall" || renderedTools.has(block.id)) continue;
+      renderedTools.add(block.id);
+      this.renderTool(block.id, block.name, block.arguments, void 0, void 0, message.stopReason === "error", width, options, lines, transient);
+    }
+  }
+  renderTool(id, name, args, result, partial, isError, width, options, lines, transient) {
+    let component = this.toolComponents.get(`${options.target.id}:${id}`);
+    if (!component) {
+      const tool = this.rendererOptions.getToolDefinition?.(name);
+      component = new ToolExecutionComponent(name, args, { showImages: options.showImages ?? true }, tool, {
+        requestRender: () => this.tui.requestRender(),
+        requestComponentRender: () => this.tui.requestRender(),
+        resetDisplay: () => void 0,
+        imageBudget: this.tui.imageBudget
+      }, options.target.cwd ?? process.cwd(), id);
+      this.toolComponents.set(`${options.target.id}:${id}`, component);
+    }
+    component.setExpanded(options.toolsExpanded);
+    const normalizeResult = (raw) => {
+      const record = raw ?? {};
+      return {
+        content: Array.isArray(record.content) ? record.content : [],
+        ...record.details !== void 0 ? { details: record.details } : {},
+        ...record.isError !== void 0 ? { isError: record.isError } : {}
+      };
+    };
+    if (args !== void 0) component.updateArgs(args, id);
+    if (result !== void 0) component.updateResult(normalizeResult(result), false, id);
+    else if (partial !== void 0) component.updateResult(normalizeResult(partial), true, id);
+    if (isError) component.seal();
+    lines.push(...safeRender(component, width, () => this.fallback(name, width)));
+  }
+  renderBash(message, width, options, lines) {
+    const component = new BashExecutionComponent(message.command, this.tui, message.excludeFromContext);
+    component.appendOutput(terminalSafe(message.output ?? "", false));
+    component.setComplete(message.exitCode, message.cancelled, { output: message.output ?? "" });
+    component.setExpanded(options.toolsExpanded);
+    this.push(lines, safeRender(component, width, () => this.fallback(message.command, width)));
+  }
+  renderCustom(message, width, options, lines) {
+    const text = textOf(message.content);
+    if (!message.display || !text) return;
+    this.push(lines, safeRender(new UserMessageComponent(terminalSafe(text, false), true), width, () => this.fallback(text, width)));
+  }
+  renderSummary(message, width, options, lines, ComponentClass) {
+    const component = new ComponentClass(message);
+    if ("setExpanded" in component && typeof component.setExpanded === "function") component.setExpanded(options.toolsExpanded);
+    this.push(lines, safeRender(component, width, () => this.fallback(message.summary, width)));
+  }
+  push(lines, block) {
+    lines.push(...block);
+  }
+  fallback(text, width) {
+    return terminalSafe(text, false).split("\n").flatMap((line) => wrapTextWithAnsi(line, Math.max(1, width)).map((item) => this.theme.fg("text", item)));
+  }
+};
+
+// src/ui/conversation-queue-store.ts
+import { createHash } from "node:crypto";
+
+// src/ui/conversation-queue.ts
+import {
+  Ellipsis,
+  Key,
+  getKeybindings,
+  matchesKey,
+  truncateToWidth
+} from "@oh-my-pi/pi-tui";
+var QUEUE_STEER_CONVERSATION_QUEUE_REQUEST_EVENT = "queue-steer:conversation-queue:request:v1";
+var DEQUEUE_FALLBACK = "alt+up";
+var REMOVE_ROW_KEY = "alt+x";
+var PAUSE_ROW_KEY = "alt+p";
+var INDENT_ROW_KEY = "alt+right";
+var OUTDENT_ROW_KEY = "alt+left";
+var TOGGLE_LANE_KEY = "alt+t";
+var NATIVE_LANE_LABEL = {
+  steer: "Steering",
+  followUp: "Follow-up"
+};
+var NativeQueueState = class {
+  items = [];
+  nextIdNumber = 1;
+  nextSequence = 1;
+  enqueue(lane, text, images = []) {
+    const prefix = lane === "steer" ? "steer" : "follow-up";
+    const item = {
+      id: `${prefix}-${this.nextIdNumber++}`,
+      lane,
+      text,
+      images: [...images],
+      sequence: this.nextSequence++,
+      paused: false
+    };
+    this.items.push(item);
+    return { ...item, images: [...item.images] };
+  }
+  snapshot() {
+    return this.items.map((item) => ({ ...item, images: [...item.images] }));
+  }
+  peek() {
+    const item = this.items[0];
+    return item ? { ...item, images: [...item.images] } : void 0;
+  }
+  get(id) {
+    const item = this.items.find((candidate) => candidate.id === id);
+    return item ? { ...item, images: [...item.images] } : void 0;
+  }
+  remove(id) {
+    const index = this.items.findIndex((candidate) => candidate.id === id);
+    if (index === -1) return void 0;
+    const [item] = this.items.splice(index, 1);
+    return item ? { ...item, images: [...item.images] } : void 0;
+  }
+  prepend(item) {
+    this.items.unshift({ ...item, images: [...item.images] });
+  }
+  prependMany(items) {
+    for (let index = items.length - 1; index >= 0; index -= 1) {
+      const item = items[index];
+      if (item) this.items.unshift({ ...item, images: [...item.images] });
+    }
+  }
+  update(id, text) {
+    const item = this.items.find((candidate) => candidate.id === id);
+    if (!item) return false;
+    item.text = text;
+    return true;
+  }
+  setLane(id, lane) {
+    const item = this.items.find((candidate) => candidate.id === id);
+    if (!item || item.lane === lane) return false;
+    item.lane = lane;
+    return true;
+  }
+  setPaused(id, paused) {
+    const item = this.items.find((candidate) => candidate.id === id);
+    if (!item || (item.paused ?? false) === paused) return false;
+    item.paused = paused;
+    return true;
+  }
+  clear() {
+    this.items = [];
+  }
+  get length() {
+    return this.items.length;
+  }
+};
+var NativeEditSession = class {
+  composerDraft;
+  currentId;
+  drafts = /* @__PURE__ */ new Map();
+  constructor(item, composerDraft) {
+    this.currentId = item.id;
+    this.composerDraft = composerDraft;
+    this.drafts.set(item.id, {
+      text: item.text,
+      lane: item.lane,
+      removed: false,
+      paused: item.paused ?? false
+    });
+  }
+  get selectedId() {
+    return this.currentId;
+  }
+  capture(text) {
+    const draft = this.drafts.get(this.currentId);
+    if (draft) draft.text = text;
+  }
+  select(item, currentText) {
+    this.capture(currentText);
+    if (!this.drafts.has(item.id)) {
+      this.drafts.set(item.id, {
+        text: item.text,
+        lane: item.lane,
+        removed: false,
+        paused: item.paused ?? false
+      });
+    }
+    this.currentId = item.id;
+    return this.drafts.get(item.id)?.text ?? item.text;
+  }
+  toggleRemoved(id) {
+    const draft = this.drafts.get(id);
+    if (!draft) return void 0;
+    draft.removed = !draft.removed;
+    return draft.removed;
+  }
+  togglePaused(id) {
+    const draft = this.drafts.get(id);
+    if (!draft) return void 0;
+    draft.paused = !draft.paused;
+    return draft.paused;
+  }
+  setLane(id, lane) {
+    const draft = this.drafts.get(id);
+    if (!draft) return void 0;
+    draft.lane = lane;
+    return draft.lane;
+  }
+  commit(queue, currentText) {
+    this.capture(currentText);
+    let updated = 0;
+    let removed = 0;
+    let moved = 0;
+    let held = 0;
+    let released = 0;
+    for (const [id, draft] of this.drafts.entries()) {
+      if (draft.removed || !draft.text.trim()) {
+        if (queue.remove(id)) removed += 1;
+        continue;
+      }
+      if (queue.update(id, draft.text)) updated += 1;
+      if (queue.setLane(id, draft.lane)) moved += 1;
+      if (queue.setPaused(id, draft.paused)) {
+        if (draft.paused) held += 1;
+        else released += 1;
+      }
+    }
+    return { updated, removed, moved, held, released };
+  }
+  rollbackPositions() {
+  }
+  laneFor(id) {
+    return this.drafts.get(id)?.lane;
+  }
+  textFor(id) {
+    return this.drafts.get(id)?.text;
+  }
+  pausedFor(id) {
+    return this.drafts.get(id)?.paused;
+  }
+  isRemoved(id) {
+    return this.drafts.get(id)?.removed ?? false;
+  }
+};
+var errorText = (error) => error instanceof Error ? error.message : String(error ?? "");
+var controlInputRe = /^[/!]/;
+function createConversationQueue(options) {
+  const { ompEvents, targetId, theme } = options;
+  const notify = (text, kind = "info") => {
+    options.onNotify?.(text, kind);
+  };
+  const requestRender = () => options.requestRender?.();
+  const targetLabel = options.targetName ?? targetId;
+  let bridge;
+  let queue;
+  let mode = "native";
+  let disposed = false;
+  const dispatched = [];
+  let externalPending = [];
+  let lastSendError;
+  let editSession;
+  const seenIds = /* @__PURE__ */ new Set();
+  const consumedIds = /* @__PURE__ */ new Set();
+  const liveTextCounts = /* @__PURE__ */ new Map();
+  const emitHandshake = (action) => {
+    let claimed = false;
+    let settled = false;
+    let result;
+    const request = {
+      version: 1,
+      action,
+      targetId,
+      claim: () => {
+        if (claimed) return false;
+        claimed = true;
+        return true;
+      },
+      respond: (response) => {
+        if (settled) return;
+        settled = true;
+        result = response;
+      }
+    };
+    ompEvents.emit(QUEUE_STEER_CONVERSATION_QUEUE_REQUEST_EVENT, request);
+    return { claimed, result };
+  };
+  const acquisition = emitHandshake("acquire");
+  if (acquisition.claimed && acquisition.result?.ok && acquisition.result.bridge?.version === 1 && acquisition.result.bridge.targetId === targetId) {
+    bridge = acquisition.result.bridge;
+    mode = "extension";
+  } else if (acquisition.claimed && acquisition.result && !acquisition.result.ok) {
+    notify(`pi-queue-steer refused the conversation queue for ${targetLabel}: ${acquisition.result.error ?? "unknown error"}`, "error");
+  }
+  queue = bridge ? bridge.createQueue() : new NativeQueueState();
+  const laneLabel = (lane) => bridge ? bridge.laneLabel(lane) : lane === "steer" ? "steer" : "follow-up";
+  const isQueueable = (text) => bridge ? bridge.isQueueableSubmission(text) : !controlInputRe.test(text.trim()) && text.trim() !== "";
+  const decoratedRow = (item) => ({
+    id: item.id,
+    lane: editSession?.laneFor?.(item.id) ?? item.lane,
+    text: editSession?.textFor?.(item.id) ?? item.text,
+    state: "queued",
+    paused: editSession?.pausedFor?.(item.id) ?? (item.paused ?? false),
+    selected: editSession?.selectedId === item.id,
+    removed: editSession?.isRemoved?.(item.id) ?? false
+  });
+  const orderedRows = () => {
+    const held = queue.snapshot().map(decoratedRow);
+    const inFlight = [...dispatched, ...externalPending].map((row) => ({
+      id: row.id,
+      lane: row.lane,
+      text: row.text,
+      state: "dispatched",
+      paused: false,
+      selected: false,
+      removed: false
+    }));
+    return [...inFlight, ...held];
+  };
+  const headBatch = (lane) => {
+    const items = queue.snapshot();
+    const head = items[0];
+    if (!head || head.lane !== lane) return [];
+    const batch = [];
+    for (const item of items) {
+      if (item.lane !== lane) break;
+      if (item.paused) break;
+      batch.push(item);
+    }
+    return batch;
+  };
+  const dequeueKeys = () => {
+    const manager = options.keybindings ?? getKeybindings();
+    const keys = manager.getKeys("app.message.dequeue");
+    return keys.filter((key) => /up$/i.test(key)).map(
+      (key) => key.endsWith("Up") ? `${key.slice(0, -2)}Down` : `${key.slice(0, -2)}down`
+    );
+  };
+  const actionMatches = (data, action, fallback) => {
+    const manager = options.keybindings;
+    if (manager) {
+      const keys = manager.getKeys(action);
+      if (keys.length === 0) return false;
+      return manager.matches(data, action);
+    }
+    const global = getKeybindings();
+    if (global.getKeys(action).length > 0) return global.matches(data, action);
+    return fallback(data);
+  };
+  const startEditing = () => {
+    if (!options.editor) {
+      notify("Editing queued rows requires the shared editor", "error");
+      return false;
+    }
+    const items = queue.snapshot();
+    if (items.length === 0) {
+      notify("No queued messages to edit", "info");
+      return false;
+    }
+    const mostRecent = items.reduce((newest, item) => item.sequence > newest.sequence ? item : newest, items[0]);
+    editSession = bridge ? bridge.createEditSession(mostRecent, options.editor.getText()) : new NativeEditSession(mostRecent, options.editor.getText());
+    options.editor.setText(mostRecent.text);
+    notify(`Editing queued ${laneLabel(mostRecent.lane)} row \xB7 enter saves, escape rolls back`, "info");
+    requestRender();
+    return true;
+  };
+  const finishEditing = (save) => {
+    const session = editSession;
+    const editor = options.editor;
+    if (!session || !editor) return false;
+    const currentText = editor.getText();
+    editSession = void 0;
+    if (save) {
+      const result = session.commit(queue, currentText);
+      if (result.removed > 0) notify(`Removed ${result.removed} queued row${result.removed === 1 ? "" : "s"}`, "info");
+      if (result.moved > 0) notify(`Changed delivery depth for ${result.moved} row${result.moved === 1 ? "" : "s"}`, "info");
+      if (result.held > 0) notify(`Paused ${result.held} row${result.held === 1 ? "" : "s"} \u2014 dispatch stops there until resumed`, "info");
+      if (result.released > 0) notify(`Resumed ${result.released} row${result.released === 1 ? "" : "s"}`, "info");
+    } else {
+      notify("Row edits rolled back", "info");
+    }
+    editor.setText(session.composerDraft);
+    requestRender();
+    return true;
+  };
+  const matchesOptionArrow = (data, direction) => {
+    const arrow = direction === "left" ? OUTDENT_ROW_KEY : INDENT_ROW_KEY;
+    const wordAlias = direction === "left" ? "alt+b" : "alt+f";
+    return matchesKey(data, arrow) && !matchesKey(data, wordAlias);
+  };
+  const inlineEditorRenderer = () => {
+    const editor = options.editor;
+    if (!editor?.render) return void 0;
+    return (width) => {
+      const lines = editor.render(width);
+      if (bridge?.extractInlineEditorLines) {
+        return bridge.extractInlineEditorLines(lines, editor.paddingX ?? 0);
+      }
+      return [...lines];
+    };
+  };
+  return {
+    targetId,
+    get mode() {
+      return mode;
+    },
+    get active() {
+      return !disposed && (queue.length > 0 || dispatched.length > 0);
+    },
+    get editingActive() {
+      return editSession !== void 0;
+    },
+    stage(text, lane) {
+      if (disposed) return { ok: false, error: "Queue is disposed" };
+      const trimmed = text.trim();
+      if (!trimmed) return { ok: false, error: "Nothing to queue" };
+      if (!isQueueable(trimmed) || controlInputRe.test(trimmed)) {
+        return {
+          ok: false,
+          error: "Control input (/ commands, ! bash) is Main-only and is not queued from a focused conversation"
+        };
+      }
+      const row = queue.enqueue(lane, text);
+      notify(`Queued ${laneLabel(lane)} \u2192 ${targetLabel}`, "info");
+      requestRender();
+      return { ok: true, id: row.id };
+    },
+    async submit(lane) {
+      if (disposed) return false;
+      if (editSession) {
+        notify("Finish or cancel row editing before dispatching the queue", "info");
+        return false;
+      }
+      const batch = headBatch(lane);
+      if (batch.length === 0) {
+        const head = queue.peek();
+        if (head?.paused) notify(`The next ${laneLabel(lane)} row is paused \u2014 dispatch holds there`, "info");
+        else notify(`No dispatchable queued ${laneLabel(lane)} rows at the timeline head`, "info");
+        return false;
+      }
+      let sent = 0;
+      lastSendError = void 0;
+      for (const item of batch) {
+        if (disposed) return false;
+        queue.remove(item.id);
+        const pending = { id: item.id, lane, text: item.text };
+        dispatched.push(pending);
+        requestRender();
+        let expectedId;
+        try {
+          const result = await options.send(item.text, lane);
+          const candidate = result;
+          const reported = candidate?.messageId ?? candidate?.id;
+          if (typeof reported === "string" && reported !== "") expectedId = reported;
+        } catch (error) {
+          lastSendError = error;
+          const pendingIndex = dispatched.indexOf(pending);
+          if (pendingIndex < 0 || disposed) return !disposed;
+          dispatched.splice(pendingIndex, 1);
+          queue.prepend({ ...item });
+          notify(`Send failed for ${targetLabel} (${laneLabel(lane)}); row restored to the queue head: ${errorText(error)}`, "error");
+          requestRender();
+          return false;
+        }
+        if (expectedId) pending.expectedId = expectedId;
+        sent += 1;
+      }
+      notify(`Accepted ${sent} queued ${laneLabel(lane)} row${sent === 1 ? "" : "s"} \u2192 ${targetLabel} \xB7 awaiting delivery`, "info");
+      requestRender();
+      return true;
+    },
+    async dispatch(text, lane) {
+      const row = this.stage(text, lane);
+      if (!row.ok || !row.id) throw new Error(row.error ?? "Unable to queue input");
+      if (!await this.submit(lane)) {
+        queue.remove(row.id);
+        throw lastSendError ?? new Error("The queue head is paused or held; edit or resume it before sending");
+      }
+    },
+    park(text, lane) {
+      const result = this.stage(text, lane);
+      if (result.id) queue.setPaused(result.id, true);
+      return result;
+    },
+    cancelEditing() {
+      if (editSession) finishEditing(false);
+    },
+    syncPending(pending) {
+      externalPending = [];
+      if (!pending) return;
+      const own = [...queue.snapshot(), ...dispatched];
+      for (const [lane, messages] of [["steer", pending.steering], ["followUp", pending.followUp]]) {
+        const remaining = own.filter((row) => row.lane === lane).map((row) => row.text);
+        messages.forEach((text, index) => {
+          const match = remaining.indexOf(text);
+          if (match >= 0) remaining.splice(match, 1);
+          else externalPending.push({ id: `native:${lane}:${index}`, lane, text });
+        });
+      }
+    },
+    rows: orderedRows,
+    render(width) {
+      if (disposed || width <= 0) return [];
+      const rows = orderedRows();
+      if (rows.length === 0) return [];
+      if (bridge?.createTimelineWidget && bridge.buildTimelineItems) {
+        const visibleRows = [
+          ...[...dispatched, ...externalPending].map((row, index) => ({ id: row.id, lane: row.lane, text: row.text, images: [], sequence: index - dispatched.length })),
+          ...queue.snapshot()
+        ];
+        const displayQueue = new Proxy(queue, { get(target, key) {
+          if (key === "snapshot") return () => visibleRows;
+          const value = Reflect.get(target, key, target);
+          return typeof value === "function" ? value.bind(target) : value;
+        } });
+        const items = bridge.buildTimelineItems(displayQueue, editSession);
+        const inline = editSession ? inlineEditorRenderer() : void 0;
+        const editingId = editSession?.selectedId;
+        const widget = bridge.createTimelineWidget(
+          {
+            items,
+            ...editingId !== void 0 ? { editingId } : {},
+            paused: false,
+            idle: options.isIdle?.() ?? false,
+            ...inline ? { renderInlineEditor: inline } : {}
+          },
+          theme
+        );
+        const lines2 = [...widget.render(width)];
+        if (dispatched.length > 0) lines2.push(theme.fg("dim", truncateToWidth("Sent rows await child delivery; they cannot be edited locally.", width, "")));
+        return lines2;
+      }
+      const lines = [""];
+      const innerWidth = Math.max(0, width - 2);
+      const dequeueHint = (options.keybindings ?? getKeybindings()).getKeys("app.message.dequeue").join("/") || DEQUEUE_FALLBACK;
+      for (const row of rows) {
+        const label = bridge ? bridge.laneLabel(row.lane) : NATIVE_LANE_LABEL[row.lane];
+        const marker = row.selected ? "\u203A " : row.paused ? "\u23F8 " : "";
+        const note = row.removed ? " \xB7 removed on save" : row.paused ? " \xB7 paused" : "";
+        const color = row.state === "dispatched" ? "dim" : bridge ? bridge.laneColor(row.lane) : "dim";
+        lines.push(
+          ` ${theme.fg(color, truncateToWidth(`${marker}${label}: ${row.text.replace(/\n/g, " ")}${note}`, innerWidth, Ellipsis.Unicode))} `
+        );
+      }
+      const hint = queue.length > 0 ? `\u21B3 ${dequeueHint} to edit queued messages` : "\u21B3 Waiting for child delivery";
+      lines.push(` ${theme.fg("dim", truncateToWidth(hint, innerWidth, Ellipsis.Unicode))} `);
+      return lines;
+    },
+    handleInput(data) {
+      if (disposed) return false;
+      if (!editSession) {
+        if (queue.length === 0) return false;
+        if (!options.editor?.getText().trim() && matchesKey(data, Key.enter)) {
+          const head = queue.peek();
+          if (head) {
+            queue.setPaused(head.id, false);
+            void this.submit(head.lane);
+          }
+          return true;
+        }
+        if (actionMatches(data, "app.message.dequeue", (input) => matchesKey(input, DEQUEUE_FALLBACK))) {
+          return startEditing();
+        }
+        return false;
+      }
+      const session = editSession;
+      const editor = options.editor;
+      if (actionMatches(data, "app.message.dequeue", (input) => matchesKey(input, DEQUEUE_FALLBACK)) && editor) {
+        const ordered = queue.snapshot();
+        const index = ordered.findIndex((item) => item.id === session.selectedId);
+        const target = index <= 0 ? ordered.at(-1) : ordered[index - 1];
+        if (target) editor.setText(session.select(target, editor.getText()));
+        requestRender();
+        return true;
+      }
+      const nextKeys = dequeueKeys();
+      if (nextKeys.length > 0 && nextKeys.some((key) => matchesKey(data, key)) && editor) {
+        const ordered = queue.snapshot();
+        const index = ordered.findIndex((item) => item.id === session.selectedId);
+        const target = index === -1 || index === ordered.length - 1 ? ordered[0] : ordered[index + 1];
+        if (target) editor.setText(session.select(target, editor.getText()));
+        requestRender();
+        return true;
+      }
+      if (matchesKey(data, REMOVE_ROW_KEY)) {
+        session.toggleRemoved(session.selectedId);
+        requestRender();
+        return true;
+      }
+      if (matchesKey(data, PAUSE_ROW_KEY)) {
+        session.togglePaused(session.selectedId);
+        requestRender();
+        return true;
+      }
+      if (matchesOptionArrow(data, "left")) {
+        session.setLane(session.selectedId, "followUp");
+        requestRender();
+        return true;
+      }
+      if (matchesOptionArrow(data, "right")) {
+        session.setLane(session.selectedId, "steer");
+        requestRender();
+        return true;
+      }
+      if (matchesKey(data, TOGGLE_LANE_KEY)) {
+        const current = queue.get(session.selectedId)?.lane;
+        if (current) session.setLane(session.selectedId, current === "steer" ? "followUp" : "steer");
+        requestRender();
+        return true;
+      }
+      if (actionMatches(data, "tui.input.submit", (input) => matchesKey(input, Key.enter)) || actionMatches(data, "app.message.followUp", () => false)) {
+        return finishEditing(true);
+      }
+      if (actionMatches(data, "app.interrupt", (input) => matchesKey(input, Key.escape))) {
+        return finishEditing(false);
+      }
+      editor?.handleInput?.(data);
+      return true;
+    },
+    syncSnapshot(entries) {
+      if (disposed || dispatched.length === 0) {
+        for (const entry of entries) {
+          if (!seenIds.has(entry.id)) seenIds.add(entry.id);
+        }
+        return 0;
+      }
+      for (const entry of entries) {
+        if (seenIds.has(entry.id)) continue;
+        seenIds.add(entry.id);
+        if (entry.historical) continue;
+        const key = entry.text.trim();
+        liveTextCounts.set(key, (liveTextCounts.get(key) ?? 0) + 1);
+      }
+      let retired = 0;
+      const consume = (entry) => {
+        consumedIds.add(entry.id);
+        if (!entry.historical) {
+          const key = entry.text.trim();
+          const remaining = (liveTextCounts.get(key) ?? 0) - 1;
+          if (remaining > 0) liveTextCounts.set(key, remaining);
+          else liveTextCounts.delete(key);
+        }
+      };
+      const frontierEntry = (row) => {
+        if (row.expectedId) {
+          const match = entries.find((entry) => entry.id === row.expectedId && !consumedIds.has(entry.id));
+          if (match) return match;
+        }
+        for (const entry of entries) {
+          if (entry.historical || consumedIds.has(entry.id)) continue;
+          if (entry.text.trim() === row.text.trim() && (liveTextCounts.get(entry.text.trim()) ?? 0) > 0) {
+            return { id: entry.id, text: entry.text.trim() };
+          }
+        }
+        return void 0;
+      };
+      for (let index = dispatched.length - 1; index >= 0; index -= 1) {
+        const row = dispatched[index];
+        if (!row) continue;
+        const confirmed = frontierEntry(row);
+        if (!confirmed) continue;
+        consume(confirmed);
+        dispatched.splice(index, 1);
+        retired += 1;
+      }
+      if (retired > 0) {
+        notify(`${retired} queued row${retired === 1 ? "" : "s"} confirmed delivered \u2192 ${targetLabel}`, "info");
+        requestRender();
+      }
+      return retired;
+    },
+    retireAll(reason) {
+      if (disposed) return 0;
+      const count = queue.length + dispatched.length;
+      queue.clear();
+      dispatched.length = 0;
+      editSession = void 0;
+      if (count > 0) {
+        const suffix = reason ? ` (${reason})` : "";
+        notify(`Retired ${count} queued row${count === 1 ? "" : "s"} for ${targetLabel}${suffix}`, "info");
+        requestRender();
+      }
+      return count;
+    },
+    pendingCount() {
+      if (disposed) return 0;
+      return queue.length + dispatched.length;
+    },
+    dispose({ retain = false } = {}) {
+      if (disposed) return;
+      disposed = true;
+      editSession = void 0;
+      if (retain) {
+        return;
+      }
+      queue.clear();
+      dispatched.length = 0;
+      if (bridge) emitHandshake("release");
+    }
+  };
+}
+
+// src/ui/conversation-queue-store.ts
+var ConversationQueueStore = class {
+  slots = /* @__PURE__ */ new Map();
+  attach(options) {
+    const existing = this.slots.get(options.targetId);
+    if (existing) {
+      existing.attached = options;
+      return existing.queue;
+    }
+    const slot = { queue: void 0, attached: options, initialized: false, frontier: 0 };
+    const attached = () => slot.attached;
+    slot.queue = createConversationQueue({
+      ...options,
+      send: (text, lane) => {
+        const current = attached();
+        if (!current) return Promise.reject(new Error("Open this conversation to send its queued messages"));
+        return current.send(text, lane);
+      },
+      editor: {
+        getText: () => attached()?.editor?.getText() ?? "",
+        setText: (text) => attached()?.editor?.setText(text),
+        handleInput: (data) => attached()?.editor?.handleInput?.(data),
+        render: (width) => attached()?.editor?.render?.(width) ?? [],
+        get paddingX() {
+          return attached()?.editor?.paddingX ?? 0;
+        }
+      },
+      isIdle: () => attached()?.isIdle?.() ?? true,
+      onNotify: (text, kind) => attached()?.onNotify?.(text, kind),
+      requestRender: () => attached()?.requestRender?.()
+    });
+    this.slots.set(options.targetId, slot);
+    return slot.queue;
+  }
+  get(id) {
+    return this.slots.get(id)?.queue;
+  }
+  detach(id) {
+    const slot = this.slots.get(id);
+    if (!slot) return;
+    slot.queue.cancelEditing();
+    slot.attached = void 0;
+  }
+  sync(id, transcript) {
+    const slot = this.slots.get(id);
+    if (!slot) return;
+    let frontier = slot.frontier;
+    const occurrences = /* @__PURE__ */ new Map();
+    const entries = [];
+    for (const message of transcript.messages) {
+      if (Number.isFinite(message.timestamp)) frontier = Math.max(frontier, message.timestamp);
+      if (message.role !== "user") continue;
+      const raw = typeof message.content === "string" ? message.content : message.content.filter((part) => part.type === "text").map((part) => part.text).join("");
+      const text = unwrapActorEnvelopeText(raw) ?? raw;
+      let identity;
+      if (text !== raw) {
+        try {
+          const envelope = JSON.parse(raw.trim().slice("Fabric actor message from direct:".length));
+          if (typeof envelope.id === "string") identity = envelope.id;
+        } catch {
+        }
+      }
+      if (!identity) identity = createHash("sha256").update(JSON.stringify([message.timestamp, message.content])).digest("hex");
+      const occurrence = occurrences.get(identity) ?? 0;
+      occurrences.set(identity, occurrence + 1);
+      entries.push({
+        id: occurrence === 0 ? identity : `${identity}:${occurrence}`,
+        text,
+        historical: !slot.initialized || message.timestamp < slot.frontier
+      });
+    }
+    slot.queue.syncSnapshot(entries);
+    slot.queue.syncPending(transcript.pendingMessages);
+    slot.frontier = frontier;
+    slot.initialized = true;
+  }
+  clear() {
+    for (const slot of this.slots.values()) {
+      slot.queue.cancelEditing();
+      slot.attached = void 0;
+      slot.queue.dispose();
+    }
+    this.slots.clear();
+  }
+};
+
+// src/ui/conversation.ts
+var STATE_ENTRY_LIMIT = 128;
+var FabricConversationState = class {
+  queues = new ConversationQueueStore();
+  selectedId;
+  epochCounter = 0;
+  entries = /* @__PURE__ */ new Map();
+  pendingSends = /* @__PURE__ */ new Set();
+  get epoch() {
+    return this.epochCounter;
+  }
+  hasPendingSend(id, message) {
+    for (const pending of this.pendingSends) {
+      if (pending.id === id && pending.message === message) return true;
+    }
+    return false;
+  }
+  addPendingSend(pending) {
+    this.pendingSends.add(pending);
+  }
+  /** Acknowledged: drop the pending marker and clear only the exact accepted draft. */
+  resolvePendingSend(id, message) {
+    for (const pending of this.pendingSends) {
+      if (pending.id !== id || pending.message !== message) continue;
+      this.pendingSends.delete(pending);
+      const entry = this.entries.get(id);
+      if (entry && entry.draft === message) entry.draft = "";
+      return;
+    }
+  }
+  /** Rejected: drop the pending marker; the raw draft stays untouched. */
+  failPendingSend(id, message) {
+    for (const pending of this.pendingSends) {
+      if (pending.id !== id || pending.message !== message) continue;
+      this.pendingSends.delete(pending);
+      return;
+    }
+  }
+  /** Live view state for a target; creates (and may evict empty) entries. */
+  view(id) {
+    const existing = this.entries.get(id);
+    if (existing) {
+      this.entries.delete(id);
+      this.entries.set(id, existing);
+      return existing;
+    }
+    const created = {
+      draft: "",
+      following: true,
+      scroll: 0,
+      pageAnchor: void 0,
+      toolsExpanded: false,
+      lastSeenUpdatedAt: 0
+    };
+    this.entries.set(id, created);
+    this.enforceLimit();
+    return created;
+  }
+  /** Non-mutating lookup; unread checks must never create or evict drafts. */
+  peek(id) {
+    return this.entries.get(id);
+  }
+  clear() {
+    this.queues.clear();
+    this.entries.clear();
+    this.pendingSends.clear();
+    this.selectedId = void 0;
+    this.epochCounter++;
+  }
+  enforceLimit() {
+    while (this.entries.size > STATE_ENTRY_LIMIT) {
+      let evicted = false;
+      for (const key of this.entries.keys()) {
+        if (key === this.selectedId) continue;
+        const entry = this.entries.get(key);
+        if (entry && entry.draft === "") {
+          this.entries.delete(key);
+          evicted = true;
+          break;
+        }
+      }
+      if (!evicted) break;
+    }
+  }
+};
+var FEEDBACK_TTL_MS = 8e3;
+var FOLLOW_UP_FALLBACK = ["alt+enter", "ctrl+q"];
+var TOOLS_EXPAND_FALLBACK = ["ctrl+o"];
+var conversationEditorTheme = (theme, thinking) => ({
+  symbols: ompSymbolTheme,
+  borderColor: (value) => {
+    const level = thinking();
+    const color = level === "minimal" ? "thinkingMinimal" : level === "low" ? "thinkingLow" : level === "medium" ? "thinkingMedium" : level === "high" ? "thinkingHigh" : level === "xhigh" ? "thinkingXhigh" : level === "max" ? "thinkingMax" : "borderMuted";
+    return theme.fg(color, value);
+  },
+  selectList: {
+    selectedPrefix: (text) => theme.fg("accent", text),
+    selectedText: (text) => theme.fg("accent", text),
+    description: (text) => theme.fg("muted", text),
+    scrollInfo: (text) => theme.fg("muted", text),
+    noMatch: (text) => theme.fg("muted", text),
+    symbols: ompSymbolTheme
+  }
+});
+var errorText2 = (error) => {
+  if (error instanceof Error) return error.message;
+  return String(error ?? "");
+};
+var isMainTarget = (target) => target?.kind === "main";
+var FabricConversationView = class {
+  focusState = true;
+  tui;
+  theme;
+  options;
+  state;
+  renderer;
+  editor;
+  pickerInput;
+  pickerRows = [];
+  pickerSelectedId;
+  mode = "conversation";
+  currentId;
+  feedback;
+  stopConfirmId;
+  disposed = false;
+  lastBodyLength = 0;
+  lastBody = [];
+  lastBodyBudget = 1;
+  editorTop = 0;
+  editorHeight = 0;
+  ownsMouseMode = false;
+  constructor(tui, theme, options) {
+    this.tui = tui;
+    this.theme = theme;
+    this.options = options;
+    this.state = options.state;
+    this.renderer = new FabricConversationTranscriptRenderer(tui, theme, {
+      ...options.rendererOptions,
+      imageWidthCells: options.appearance?.imageWidthCells
+    });
+    this.editor = new Editor(conversationEditorTheme(theme, () => this.currentTarget()?.thinking));
+    this.editor.focused = true;
+    this.editor.onChange = (text) => {
+      if (this.currentId && !this.state.queues.get(this.currentId)?.editingActive) this.state.view(this.currentId).draft = text;
+    };
+    const nonMain = this.nonMainTargets();
+    const requested = options.initialTargetId ?? defaultConversationTarget(nonMain, options.state.selectedId)?.id;
+    const requestedTarget = requested ? this.currentTargets().find((candidate) => candidate.id === requested) : void 0;
+    const resolved = requested && requestedTarget && !isMainTarget(requestedTarget) ? requested : nonMain[0]?.id;
+    if (resolved) this.applySelection(resolved, false);
+    if (!this.currentId) this.currentId = nonMain[0]?.id;
+    if (true) {
+      tui.terminal.write("\x1B[?1000h\x1B[?1006h");
+      this.ownsMouseMode = true;
+    }
+  }
+  get focused() {
+    return this.focusState;
+  }
+  set focused(value) {
+    this.focusState = value;
+    if (this.mode === "picker") {
+      if (this.pickerInput) this.pickerInput.focused = value;
+      if (this.editor) this.editor.focused = false;
+      return;
+    }
+    if (this.editor) this.editor.focused = value;
+  }
+  /** Re-focus a target while the view is open; selecting Main closes to the native session. */
+  selectTarget(id) {
+    this.applySelection(id, true);
+  }
+  handleInput(data) {
+    if (this.disposed) return;
+    const mouse = /^\x1b\[<(\d+);(\d+);(\d+)([Mm])$/.exec(data);
+    if (mouse) {
+      const button = Number(mouse[1]);
+      if ((button & 64) !== 0 && mouse[4] === "M") {
+        this.handleMouse({ button, col: Number(mouse[2]) - 1, row: Number(mouse[3]) - 1, release: false, wheel: (button & 1) === 0 ? -1 : 1, motion: false, leftClick: false });
+      }
+      return;
+    }
+    if (this.mode === "picker") {
+      this.handlePickerInput(data);
+      this.tui.requestRender();
+      return;
+    }
+    this.handleConversationInput(data);
+    this.tui.requestRender();
+  }
+  handleMouse(event) {
+    if (this.disposed) return;
+    if (event.wheel !== null) {
+      if (this.mode === "picker") this.movePickerSelection(event.wheel);
+      else this.scrollBy(event.wheel * 3);
+      this.tui.requestRender();
+    }
+  }
+  render(width) {
+    if (this.disposed || width <= 0) return [];
+    const rows = Math.max(1, this.terminalRows());
+    this.markCurrentTargetSeen();
+    this.reconcileEditor();
+    const target = this.currentTarget();
+    const queue = this.mode === "conversation" ? this.currentQueue() : void 0;
+    const transcriptLines = this.mode === "conversation" ? this.transcriptLines(width) : [];
+    let queueLines = queue?.render(width) ?? [];
+    let editorLines = this.mode === "conversation" && !(queue?.editingActive && queue.mode === "extension") ? this.renderEditorLines(width) : [];
+    const editorBudget = Math.min(editorLines.length, Math.max(1, rows - (rows >= 6 ? 3 : 0)));
+    if (editorLines.length > editorBudget) {
+      const cursor = Math.max(0, editorLines.findIndex((line) => line.includes(CURSOR_MARKER)));
+      const start = Math.max(0, Math.min(cursor - Math.floor(editorBudget / 2), editorLines.length - editorBudget));
+      editorLines = editorLines.slice(start, start + editorBudget);
+    }
+    let remaining = rows - editorLines.length;
+    const footer = this.mode === "conversation" ? conversationFooter(target, this.theme, width).slice(0, Math.max(0, remaining - 1)) : [];
+    remaining -= footer.length;
+    const head = [];
+    if (remaining > 0) {
+      head.push(this.breadcrumbLine(width));
+      remaining--;
+    }
+    if (target?.readOnlyReason && remaining > 1) {
+      head.push(this.statusLine(width));
+      remaining--;
+    }
+    const feedback = this.currentFeedbackLine(width);
+    if (feedback !== void 0 && remaining > 1) {
+      head.push(feedback);
+      remaining--;
+    }
+    const hints = this.mode === "conversation" && remaining > 2 ? [this.hintsLine(width)] : [];
+    remaining -= hints.length;
+    const queueBudget = Math.max(0, remaining - 1);
+    if (queueLines.length > queueBudget) {
+      const cursor = queueLines.findIndex((line) => line.includes(CURSOR_MARKER));
+      const start = Math.max(0, Math.min(cursor < 0 ? 0 : cursor - Math.floor(queueBudget / 2), queueLines.length - queueBudget));
+      queueLines = queueLines.slice(start, start + queueBudget);
+    }
+    remaining -= queueLines.length;
+    this.editorTop = rows - editorLines.length - footer.length - hints.length;
+    this.editorHeight = editorLines.length;
+    const body = remaining <= 0 ? [] : this.mode === "picker" ? this.pickerLines(width, remaining) : this.windowBody(transcriptLines, remaining);
+    while (body.length < remaining) body.push("");
+    return [...head, ...body.slice(0, remaining), ...queueLines, ...editorLines, ...footer, ...hints].slice(0, rows).map((line) => visibleWidth(line) <= width ? line : truncateToWidth2(line, width, ""));
+  }
+  invalidate() {
+    this.renderer.invalidate();
+    this.editor?.invalidate();
+    this.pickerInput?.invalidate();
+  }
+  dispose() {
+    if (this.currentId) this.state.queues.detach(this.currentId);
+    this.disposed = true;
+    this.editor = void 0;
+    this.pickerInput = void 0;
+    this.renderer.dispose();
+    if (this.ownsMouseMode) {
+      this.ownsMouseMode = false;
+      this.tui.terminal.write("\x1B[?1000l\x1B[?1006l");
+    }
+  }
+  /** Keep the editor in sync with the shared session draft (e.g. after an ack
+   * that landed while a previous view instance was disposed). */
+  reconcileEditor() {
+    if (this.mode !== "conversation" || !this.editor || !this.currentId) return;
+    if (this.state.queues.get(this.currentId)?.editingActive) return;
+    if (this.state.hasPendingSend(this.currentId, this.editor.getText())) return;
+    const draft = this.state.view(this.currentId).draft;
+    if (this.editor.getText() !== draft) this.editor.setText(draft);
+  }
+  applySelection(id, requestRender) {
+    if (this.currentId && this.currentId !== id) this.state.queues.detach(this.currentId);
+    const target = this.currentTargets().find((candidate) => candidate.id === id);
+    if (!target) {
+      this.feedback = {
+        text: `Unknown target ${safeText(id)}`,
+        kind: "error",
+        at: Date.now()
+      };
+      if (requestRender) this.tui.requestRender();
+      return;
+    }
+    if (isMainTarget(target)) {
+      this.options.close();
+      return;
+    }
+    this.currentId = id;
+    this.state.selectedId = id;
+    const entry = this.state.view(id);
+    entry.lastSeenUpdatedAt = target.updatedAt ?? Date.now();
+    this.stopConfirmId = void 0;
+    this.closePicker();
+    this.feedback = void 0;
+    this.editor?.setText(entry.draft);
+    if (requestRender) this.tui.requestRender();
+  }
+  markCurrentTargetSeen() {
+    if (!this.currentId) return;
+    const target = this.targetById(this.currentId);
+    if (!target?.updatedAt) return;
+    const entry = this.state.view(this.currentId);
+    if (entry.lastSeenUpdatedAt < target.updatedAt) entry.lastSeenUpdatedAt = target.updatedAt;
+  }
+  currentTargets() {
+    return this.options.targets();
+  }
+  nonMainTargets() {
+    return this.currentTargets().filter((target) => !isMainTarget(target));
+  }
+  currentTarget() {
+    return this.currentTargets().find((target) => target.id === this.currentId);
+  }
+  mainTarget() {
+    return this.currentTargets().find((target) => isMainTarget(target));
+  }
+  targetById(id) {
+    return this.currentTargets().find((target) => target.id === id);
+  }
+  terminalRows() {
+    return this.tui.terminal?.rows ?? process.stdout.rows ?? 28;
+  }
+  /**
+   * Respects a configured binding; when an injected manager reports no keys
+   * the binding is unbound (never falls back), and only the default global
+   * manager (no injection) falls back to hard-coded keys.
+   */
+  bindingMatches(data, binding, fallbackKeys) {
+    if (this.options.keybindings) {
+      const keys2 = this.options.keybindings.getKeys(binding);
+      return keys2.length > 0 && this.options.keybindings.matches(data, binding);
+    }
+    const global = getKeybindings2();
+    const keys = global.getKeys(binding);
+    if (keys.length > 0) return global.matches(data, binding);
+    return fallbackKeys.some((key) => matchesKey2(data, key));
+  }
+  bindingHint(binding, fallbackLabel) {
+    const manager = this.options.keybindings ?? getKeybindings2();
+    const keys = manager.getKeys(binding);
+    if (keys.length > 0) return keys.join("/");
+    return this.options.keybindings ? "unbound" : fallbackLabel;
+  }
+  handleConversationInput(data) {
+    const editor = this.editor;
+    if (!editor) return;
+    this.feedback = void 0;
+    if (this.stopConfirmId === void 0 && this.currentQueue()?.handleInput(data)) return;
+    if (this.stopConfirmId !== void 0) {
+      if (matchesKey2(data, Key2.enter)) {
+        const target = this.targetById(this.stopConfirmId);
+        this.stopConfirmId = void 0;
+        if (target) this.dispatchStop(target);
+        return;
+      }
+      if (matchesKey2(data, Key2.escape)) {
+        this.stopConfirmId = void 0;
+        this.feedback = { text: "Stop cancelled", kind: "info", at: Date.now() };
+        return;
+      }
+      this.stopConfirmId = void 0;
+    }
+    if (this.bindingMatches(data, "app.message.followUp", FOLLOW_UP_FALLBACK)) {
+      this.submit("followUp");
+      return;
+    }
+    if (matchesKey2(data, Key2.enter)) {
+      this.submit("steer");
+      return;
+    }
+    if (matchesKey2(data, Key2.ctrl("c"))) {
+      if (editor.getText().length > 0) editor.setText("");
+      return;
+    }
+    if (matchesKey2(data, Key2.escape)) {
+      this.options.close();
+      return;
+    }
+    if (matchesKey2(data, Key2.ctrl("n"))) {
+      this.openPicker();
+      return;
+    }
+    if (matchesKey2(data, "ctrl+tab")) {
+      this.cycleTarget(1);
+      return;
+    }
+    if (matchesKey2(data, "shift+ctrl+tab")) {
+      this.cycleTarget(-1);
+      return;
+    }
+    if (matchesKey2(data, "ctrl+shift+left")) {
+      this.navigateParent();
+      return;
+    }
+    if (matchesKey2(data, "ctrl+shift+right")) {
+      this.navigateFirstChild();
+      return;
+    }
+    if (matchesKey2(data, "alt+left") && editor.getText().length === 0) {
+      this.navigateParent();
+      return;
+    }
+    if (matchesKey2(data, "alt+right") && editor.getText().length === 0) {
+      this.navigateFirstChild();
+      return;
+    }
+    const injectedKeys = this.options.keybindings;
+    const globalKeys = getKeybindings2();
+    const matchesViewport = (data2, action) => (injectedKeys ? injectedKeys.matches(data2, action) : false) || globalKeys.matches(data2, action);
+    if (matchesViewport(data, "tui.editor.jumpBackward")) {
+      this.scrollPrompt(-1);
+      return;
+    }
+    if (matchesViewport(data, "tui.editor.jumpForward")) {
+      this.scrollPrompt(1);
+      return;
+    }
+    if (matchesViewport(data, "tui.editor.cursorUp")) {
+      this.scrollBy(-1);
+      return;
+    }
+    if (matchesViewport(data, "tui.editor.cursorDown")) {
+      this.scrollBy(1);
+      return;
+    }
+    if (matchesViewport(data, "tui.editor.pageUp")) {
+      this.scrollBy(-Math.max(1, this.lastBodyBudget - 2));
+      return;
+    }
+    if (matchesViewport(data, "tui.editor.pageDown")) {
+      this.scrollBy(Math.max(1, this.lastBodyBudget - 2));
+      return;
+    }
+    if (matchesViewport(data, "tui.editor.cursorWordLeft")) {
+      this.scrollBy(-Math.max(1, Math.floor(this.lastBodyBudget / 2)));
+      return;
+    }
+    if (matchesViewport(data, "tui.editor.cursorWordRight")) {
+      this.scrollBy(Math.max(1, Math.floor(this.lastBodyBudget / 2)));
+      return;
+    }
+    if (matchesViewport(data, "tui.editor.cursorLineStart")) {
+      this.scrollToTop();
+      return;
+    }
+    if (matchesViewport(data, "tui.editor.cursorLineEnd")) {
+      this.followLatest();
+      return;
+    }
+    if (this.bindingMatches(data, "app.thinking.toggle", ["ctrl+t"])) {
+      if (this.currentId) {
+        const entry = this.state.view(this.currentId);
+        entry.hideThinking = !(entry.hideThinking ?? this.options.appearance?.hideThinkingBlock ?? false);
+      }
+      return;
+    }
+    if (this.bindingMatches(data, "app.tools.expand", TOOLS_EXPAND_FALLBACK)) {
+      if (this.currentId) {
+        const entry = this.state.view(this.currentId);
+        entry.toolsExpanded = !entry.toolsExpanded;
+      }
+      return;
+    }
+    editor.handleInput(data);
+  }
+  submit(delivery) {
+    const editor = this.editor;
+    const target = this.currentTarget();
+    if (!editor || !target || isMainTarget(target)) return;
+    const raw = editor.getText();
+    if (!raw.trim()) return;
+    if (raw.trim() === "/back") {
+      this.options.close();
+      return;
+    }
+    if (raw.trim() === "/agents") {
+      this.openPicker();
+      return;
+    }
+    if (raw.trim() === "/stop") {
+      if (!target.canStop) {
+        this.feedback = {
+          text: safeText(
+            `Stop unavailable for ${target.name}: the selected target cannot be stopped from here.`
+          ),
+          kind: "error",
+          at: Date.now()
+        };
+        return;
+      }
+      this.stopConfirmId = target.id;
+      this.feedback = {
+        text: safeText(`Press enter again to stop ${target.name} \xB7 esc cancels`),
+        kind: "info",
+        at: Date.now()
+      };
+      return;
+    }
+    if (raw.trim().startsWith("/") || raw.trim().startsWith("!")) {
+      this.feedback = {
+        text: safeText(
+          `Unsupported command "${raw.trim()}" is not forwarded from this view. Supported: /stop /back /agents.`
+        ),
+        kind: "error",
+        at: Date.now()
+      };
+      return;
+    }
+    if (target.readOnlyReason) {
+      this.feedback = {
+        text: safeText(`${target.name} is read-only: ${target.readOnlyReason}`),
+        kind: "error",
+        at: Date.now()
+      };
+      return;
+    }
+    if (delivery === "steer" && !target.canSteer) {
+      this.feedback = {
+        text: safeText(`${target.name} does not accept steering messages right now.`),
+        kind: "error",
+        at: Date.now()
+      };
+      return;
+    }
+    if (delivery === "followUp" && !target.canFollowUp) {
+      this.feedback = {
+        text: safeText(`${target.name} does not accept follow-up messages right now.`),
+        kind: "error",
+        at: Date.now()
+      };
+      return;
+    }
+    const queue = this.currentQueue();
+    if (!queue) return;
+    this.state.queues.sync(target.id, this.options.transcript(target.id, true));
+    if (queue.mode === "extension" && delivery === "followUp" && !isActiveStatus(target.status)) {
+      const parked = queue.park(raw, delivery);
+      if (parked.ok) {
+        this.state.view(target.id).draft = "";
+        editor.setText("");
+      }
+      return;
+    }
+    if (this.state.hasPendingSend(target.id, raw)) return;
+    const pending = { id: target.id, message: raw, delivery };
+    this.state.addPendingSend(pending);
+    const epoch = this.state.epoch;
+    this.feedback = {
+      text: safeText(`Sending ${delivery} \u2192 ${target.name}\u2026`),
+      kind: "info",
+      at: Date.now()
+    };
+    void Promise.resolve().then(() => queue.dispatch(raw, delivery)).then(() => {
+      if (this.state.epoch !== epoch) return;
+      this.state.resolvePendingSend(target.id, raw);
+      if (this.disposed) return;
+      if (this.currentId === target.id && this.editor?.getText() === raw) {
+        this.editor.setText("");
+      }
+      this.feedback = {
+        text: safeText(`Queued ${delivery} \u2192 ${target.name}`),
+        kind: "info",
+        at: Date.now()
+      };
+      this.tui.requestRender();
+    }).catch((error) => {
+      if (this.state.epoch !== epoch) return;
+      this.state.failPendingSend(target.id, raw);
+      if (this.disposed) return;
+      this.feedback = {
+        text: safeText(
+          `Send failed for ${target.name} (${delivery}): ${errorText2(error)}`
+        ),
+        kind: "error",
+        at: Date.now()
+      };
+      this.tui.requestRender();
+    });
+  }
+  dispatchStop(target) {
+    const epoch = this.state.epoch;
+    this.feedback = {
+      text: safeText(`Stopping ${target.name}\u2026`),
+      kind: "info",
+      at: Date.now()
+    };
+    void Promise.resolve().then(() => this.options.stop(target.id)).then(() => {
+      if (this.disposed || epoch !== this.state.epoch) return;
+      this.feedback = {
+        text: safeText(`Stop requested for ${target.name}`),
+        kind: "info",
+        at: Date.now()
+      };
+      this.tui.requestRender();
+    }).catch((error) => {
+      if (this.disposed || epoch !== this.state.epoch) return;
+      this.feedback = {
+        text: safeText(`Stop failed for ${target.name}: ${errorText2(error)}`),
+        kind: "error",
+        at: Date.now()
+      };
+      this.tui.requestRender();
+    });
+  }
+  navigateParent() {
+    const target = this.currentTarget();
+    if (!target) return;
+    const parent = target.parentId ? this.targetById(target.parentId) : void 0;
+    if (parent && !isMainTarget(parent)) {
+      this.applySelection(parent.id, true);
+      return;
+    }
+    this.options.close();
+  }
+  navigateFirstChild() {
+    const target = this.currentTarget();
+    if (!target) return;
+    const child = this.currentTargets().find((candidate) => candidate.parentId === target.id);
+    if (child && !isMainTarget(child)) this.applySelection(child.id, true);
+  }
+  cycleTarget(direction) {
+    const targets = this.nonMainTargets();
+    if (targets.length === 0) return;
+    const index = targets.findIndex((target) => target.id === this.currentId);
+    const nextIndex = index < 0 ? 0 : (index + direction + targets.length) % targets.length;
+    const next = targets[nextIndex];
+    if (next) this.applySelection(next.id, true);
+  }
+  scrollBy(delta) {
+    if (!this.currentId || !Number.isFinite(delta) || delta === 0) return;
+    const entry = this.state.view(this.currentId);
+    const maxScroll = Math.max(0, this.lastBodyLength - this.lastBodyBudget);
+    const position = entry.following ? maxScroll : entry.scroll;
+    const next = position + Math.trunc(delta);
+    entry.following = false;
+    if (next < 0 && this.options.loadOlder(this.currentId)) {
+      entry.pageAnchor = "prepend";
+      entry.anchorLength = this.lastBodyLength;
+      entry.scroll = next;
+      return;
+    }
+    if (next > maxScroll && this.options.loadNewer(this.currentId)) {
+      entry.scroll = next;
+      return;
+    }
+    entry.scroll = Math.max(0, Math.min(next, maxScroll));
+    if (delta > 0 && entry.scroll === maxScroll) entry.following = true;
+  }
+  scrollPrompt(direction) {
+    if (!this.currentId) return;
+    const entry = this.state.view(this.currentId);
+    const position = entry.following ? Math.max(0, this.lastBodyLength - this.lastBodyBudget) : entry.scroll;
+    const prompts = this.lastBody.flatMap((line, index) => line.includes("\x1B]133;A") ? [index] : []);
+    const target = direction < 0 ? prompts.filter((row) => row < position).at(-1) : prompts.find((row) => row > position);
+    this.scrollBy(target === void 0 ? direction * Math.max(1, this.lastBodyBudget) : target - position);
+  }
+  scrollToTop() {
+    if (!this.currentId) return;
+    const entry = this.state.view(this.currentId);
+    entry.following = false;
+    entry.scroll = 0;
+    if (this.options.loadOlder(this.currentId)) entry.pageAnchor = "start";
+  }
+  followLatest() {
+    if (!this.currentId) return;
+    this.options.loadLatest(this.currentId);
+    const entry = this.state.view(this.currentId);
+    entry.following = true;
+    entry.pageAnchor = void 0;
+    entry.anchorLength = void 0;
+  }
+  openPicker() {
+    this.mode = "picker";
+    this.pickerInput = new Input();
+    this.pickerInput.focused = this.focusState;
+    this.pickerInput.onSubmit = () => this.pickSelected();
+    if (this.editor) this.editor.focused = false;
+    this.pickerSelectedId = this.currentId ?? this.nonMainTargets()[0]?.id;
+    this.refreshPicker();
+  }
+  closePicker() {
+    this.mode = "conversation";
+    this.pickerInput = void 0;
+    this.pickerRows = [];
+    this.pickerSelectedId = void 0;
+    if (this.editor) this.editor.focused = this.focusState;
+  }
+  refreshPicker() {
+    const search = this.pickerInput?.getValue() ?? "";
+    const rows = [];
+    const targets = this.currentTargets();
+    const byId = new Map(targets.map((target) => [target.id, target]));
+    const roots = targets.filter(
+      (target) => !target.parentId || !byId.has(target.parentId)
+    );
+    roots.sort(
+      (left, right) => Number(isMainTarget(right)) - Number(isMainTarget(left))
+    );
+    const visited = /* @__PURE__ */ new Set();
+    const pushTree = (target, depth) => {
+      if (visited.has(target.id)) return;
+      visited.add(target.id);
+      rows.push({ target, depth });
+      for (const child of targets) {
+        if (child.parentId === target.id) pushTree(child, depth + 1);
+      }
+    };
+    for (const root of roots) pushTree(root, 0);
+    for (const orphan of targets) {
+      if (!visited.has(orphan.id)) rows.push({ target: orphan, depth: 0 });
+    }
+    const filtered = search.trim() ? fuzzyFilter(rows, search, (row) => `${row.target.kind} ${row.target.name} ${row.target.id}`) : rows;
+    this.pickerRows = filtered;
+    if (!filtered.some((row) => row.target.id === this.pickerSelectedId)) {
+      this.pickerSelectedId = filtered[0]?.target.id;
+    }
+  }
+  pickerSelectedIndex() {
+    const index = this.pickerRows.findIndex((row) => row.target.id === this.pickerSelectedId);
+    return index >= 0 ? index : 0;
+  }
+  movePickerSelection(direction) {
+    if (this.pickerRows.length === 0) return;
+    const index = this.pickerSelectedIndex();
+    const next = (index + direction + this.pickerRows.length) % this.pickerRows.length;
+    this.pickerSelectedId = this.pickerRows[next]?.target.id;
+  }
+  pickSelected() {
+    const row = this.pickerRows.find((candidate) => candidate.target.id === this.pickerSelectedId) ?? this.pickerRows[0];
+    if (!row) {
+      this.closePicker();
+      return;
+    }
+    if (isMainTarget(row.target)) {
+      this.options.close();
+      return;
+    }
+    this.applySelection(row.target.id, true);
+  }
+  handlePickerInput(data) {
+    const input = this.pickerInput;
+    if (!input) {
+      this.closePicker();
+      return;
+    }
+    if (matchesKey2(data, Key2.escape)) {
+      this.closePicker();
+      return;
+    }
+    if (matchesKey2(data, Key2.up)) {
+      this.movePickerSelection(-1);
+      return;
+    }
+    if (matchesKey2(data, Key2.down)) {
+      this.movePickerSelection(1);
+      return;
+    }
+    if (matchesKey2(data, Key2.enter)) {
+      this.pickSelected();
+      return;
+    }
+    input.handleInput(data);
+    this.refreshPicker();
+  }
+  isUnread(target) {
+    if (target.updatedAt === void 0 || target.id === this.currentId) return false;
+    const seen = this.state.peek(target.id)?.lastSeenUpdatedAt ?? 0;
+    return target.updatedAt > seen;
+  }
+  breadcrumbLine(width) {
+    const chain = [];
+    let cursor = this.currentTarget();
+    const guard = /* @__PURE__ */ new Set();
+    while (cursor && !guard.has(cursor.id)) {
+      guard.add(cursor.id);
+      chain.unshift(cursor);
+      cursor = cursor.parentId ? this.targetById(cursor.parentId) : void 0;
+    }
+    if (chain.length === 0) {
+      const main = this.mainTarget();
+      if (main) chain.push(main);
+    }
+    if (chain.length === 0) return truncateToWidth2(this.theme.fg("dim", "Fabric"), width, "");
+    const last = chain[chain.length - 1];
+    const parts = chain.map((target, index) => {
+      const isCurrent = target.id === this.currentId;
+      const name = isMainTarget(target) ? "Main" : safeText(target.name) || target.id;
+      const styled = isCurrent ? this.theme.fg("accent", name) : this.theme.fg("muted", name);
+      return last && index === chain.length - 1 && this.isUnread(last) ? `${styled} \u25CF` : styled;
+    });
+    return truncateToWidth2(parts.join(this.theme.fg("dim", " > ")), width, "");
+  }
+  statusLine(width) {
+    const target = this.currentTarget();
+    if (!target) return "";
+    const parts = [
+      this.theme.fg("muted", target.kind),
+      colorizeStatus(this.theme, target.status)
+    ];
+    if (target.runner) parts.push(this.theme.fg("muted", safeText(target.runner)));
+    if (target.model) parts.push(this.theme.fg("muted", safeText(target.model)));
+    if (target.thinking) parts.push(this.theme.fg("muted", `thinking:${safeText(target.thinking)}`));
+    if (target.readOnlyReason) {
+      parts.push(this.theme.fg("warning", safeText(`read-only: ${target.readOnlyReason}`)));
+    }
+    return truncateToWidth2(parts.join(this.theme.fg("dim", " \xB7 ")), width, "");
+  }
+  currentFeedbackLine(width) {
+    if (this.mode === "picker") return void 0;
+    if (!this.feedback) return void 0;
+    if (Date.now() - this.feedback.at > FEEDBACK_TTL_MS) return void 0;
+    const color = this.feedback.kind === "error" ? "error" : "accent";
+    return truncateToWidth2(this.theme.fg(color, this.feedback.text), width, "");
+  }
+  hintsLine(width) {
+    const followUpKeys = this.bindingHint("app.message.followUp", "alt+enter");
+    const toolsKeys = this.bindingHint("app.tools.expand", "ctrl+o");
+    const hints = this.stopConfirmId !== void 0 ? [this.theme.fg("warning", safeText("enter confirms stop \xB7 esc cancels"))] : [
+      this.theme.fg("dim", "enter"),
+      "steer",
+      this.theme.fg("dim", followUpKeys),
+      "follow-up",
+      this.theme.fg("dim", "ctrl+n"),
+      "targets",
+      this.theme.fg("dim", "pgup/pgdn"),
+      "scroll",
+      this.theme.fg("dim", "esc"),
+      "close"
+    ];
+    const full = [...hints, this.theme.fg("dim", toolsKeys), "tools"].join(" ");
+    return truncateToWidth2(full, width, "");
+  }
+  renderEditorLines(innerWidth) {
+    const editor = this.editor;
+    if (!editor) return [];
+    return [...editor.render(innerWidth)];
+  }
+  currentQueue() {
+    const target = this.currentTarget();
+    if (!target || target.kind === "main" || !this.editor || this.disposed) return void 0;
+    return this.state.queues.attach({
+      targetId: target.id,
+      targetName: target.name,
+      ompEvents: this.options.queueEvents ?? { emit() {
+      } },
+      theme: this.theme,
+      send: (message, delivery) => this.options.send(target.id, message, delivery),
+      editor: {
+        getText: () => this.editor?.getText() ?? "",
+        setText: (text) => this.editor?.setText(text),
+        handleInput: (data) => this.editor?.handleInput(data),
+        render: (width) => [...this.editor?.render(width) ?? []],
+        paddingX: this.options.appearance?.editorPaddingX ?? 0
+      },
+      ...this.options.keybindings ? { keybindings: this.options.keybindings } : {},
+      isIdle: () => !isActiveStatus(this.targetById(target.id)?.status ?? "stopped"),
+      onNotify: (text, kind) => {
+        if (kind === "error" && !this.disposed && this.currentId === target.id) this.feedback = { text: safeText(text), kind, at: Date.now() };
+      },
+      requestRender: () => {
+        if (!this.disposed && this.currentId === target.id) this.tui.requestRender();
+      }
+    });
+  }
+  transcriptLines(innerWidth) {
+    const target = this.currentTarget();
+    if (!target || !this.currentId) return [this.theme.fg("dim", "No target selected.")];
+    const entry = this.state.view(this.currentId);
+    const transcript = this.options.transcript(this.currentId, entry.following);
+    this.state.queues.sync(this.currentId, transcript);
+    return this.renderer.render(transcript, innerWidth, {
+      target,
+      toolsExpanded: entry.toolsExpanded,
+      hideThinking: entry.hideThinking ?? this.options.appearance?.hideThinkingBlock ?? false,
+      showImages: this.options.appearance?.showImages ?? true,
+      outputPad: this.options.appearance?.outputPad ?? 1,
+      ...this.options.appearance?.codeBlockIndent !== void 0 ? { codeBlockIndent: this.options.appearance.codeBlockIndent } : {},
+      codePreviewSettings: this.options.codePreviewSettings
+    });
+  }
+  windowBody(body, budget) {
+    this.lastBodyLength = body.length;
+    this.lastBody = body;
+    this.lastBodyBudget = budget;
+    const entry = this.currentId ? this.state.view(this.currentId) : void 0;
+    if (!entry) return body.slice(0, Math.max(0, budget));
+    const maxScroll = Math.max(0, body.length - budget);
+    if (entry.following) {
+      entry.scroll = maxScroll;
+    } else if (entry.pageAnchor) {
+      entry.scroll = entry.pageAnchor === "prepend" ? entry.scroll + Math.max(0, body.length - (entry.anchorLength ?? body.length)) : entry.pageAnchor === "end" ? maxScroll : 0;
+      entry.pageAnchor = void 0;
+      entry.anchorLength = void 0;
+    }
+    entry.scroll = Math.max(0, Math.min(entry.scroll, maxScroll));
+    return body.slice(entry.scroll, entry.scroll + budget);
+  }
+  pickerLines(innerWidth, budget) {
+    this.refreshPicker();
+    const lines = [this.theme.fg("accent", "Targets \xB7 enter select \xB7 esc cancel")];
+    const input = this.pickerInput;
+    if (input) {
+      for (const line of input.render(innerWidth)) lines.push(line);
+    }
+    const rows = this.pickerRows;
+    const selectedIndex = this.pickerSelectedIndex();
+    const listBudget = Math.max(1, budget - lines.length - 1);
+    const startIndex = Math.max(
+      0,
+      Math.min(selectedIndex - Math.floor(listBudget / 2), rows.length - listBudget)
+    );
+    const endIndex = Math.min(startIndex + listBudget, rows.length);
+    if (rows.length === 0) lines.push(this.theme.fg("muted", "  no matching targets"));
+    for (let i = startIndex; i < endIndex; i++) {
+      const row = rows[i];
+      if (!row) continue;
+      const selected = row.target.id === this.pickerSelectedId;
+      const indent = "  ".repeat(row.depth + 1);
+      const marker = selected ? this.theme.fg("accent", "\u2192 ") : "  ";
+      const unread = this.isUnread(row.target) ? this.theme.fg("accent", " \u25CF") : "";
+      const label = isMainTarget(row.target) ? "Main (native session)" : `${safeText(row.target.name)} ${this.theme.fg("muted", `(${row.target.kind} \xB7 ${row.target.status})`)}`;
+      lines.push(
+        truncateToWidth2(
+          `${indent}${marker}${selected ? this.theme.fg("accent", label) : label}${unread}`,
+          innerWidth,
+          ""
+        )
+      );
+    }
+    if (rows.length > listBudget) {
+      lines.push(this.theme.fg("muted", `  (${selectedIndex + 1}/${rows.length})`));
+    }
+    return lines.slice(0, budget);
+  }
+};
+var colorizeStatus = (theme, status) => {
+  if (status === "completed" || status === "done") return theme.fg("success", status);
+  if (status === "failed" || status === "error" || status === "timed_out") {
+    return theme.fg("error", status);
+  }
+  if (status === "running" || status === "in_progress" || status === "active") {
+    return theme.fg("accent", status);
+  }
+  return theme.fg("muted", status);
+};
+export {
+  FabricConversationState,
+  FabricConversationView
+};
+//# sourceMappingURL=conversation.js.map