@xenosystem/blocks 0.2.2 → 0.4.0

package/dist/ops/index.js

@@ -0,0 +1,3757 @@
+import {
+  XENO_TERMINAL_THEME_KEYS,
+  isLive,
+  measuredSize,
+  readTerminalTheme,
+  statusLabel,
+  terminalThemeVar
+} from "../chunk-WE6A2DTY.js";
+
+// src/ops/console/panel.ts
+import { createElement } from "react";
+import { createRoot } from "react-dom/client";
+import {
+  isRecord,
+  bindConfig
+} from "@xenosystem/panel-sdk";
+
+// src/ops/console/controller.ts
+import { redactForLog } from "@xenosystem/panel-sdk";
+
+// src/ops/console/types.ts
+var LEVEL_ORDER = Object.freeze([
+  "trace",
+  "debug",
+  "info",
+  "warn",
+  "error"
+]);
+function meetsLevel(level, min) {
+  if (!min) return true;
+  return LEVEL_ORDER.indexOf(level) >= LEVEL_ORDER.indexOf(min);
+}
+function matchesSearch(record, term) {
+  if (!term) return true;
+  const needle = term.toLowerCase();
+  return record.message.toLowerCase().includes(needle) || (record.source ?? "").toLowerCase().includes(needle) || (record.scope ?? "").toLowerCase().includes(needle);
+}
+function collapseAdjacent(records) {
+  const out = [];
+  for (const record of records) {
+    const last = out[out.length - 1];
+    if (last && last.level === record.level && last.message === record.message && last.source === record.source && last.scope === record.scope) {
+      out[out.length - 1] = { ...last, ts: record.ts, count: (last.count ?? 1) + 1 };
+      continue;
+    }
+    out.push({ ...record, count: 1 });
+  }
+  return out;
+}
+var REDACTION_CARRY = 1024;
+var MESSAGE_ELISION = "\u2026";
+function spliceRedactedAppend(existing, addition, redact, carry = REDACTION_CARRY) {
+  const window = Math.max(0, carry);
+  const cut = Math.max(0, existing.length - window);
+  const head = existing.slice(0, cut);
+  const tail = existing.slice(cut);
+  return head + redact(tail + addition);
+}
+function truncateLogMessage(text, max) {
+  if (max <= 0 || text.length <= max) return text;
+  if (max <= MESSAGE_ELISION.length) return text.slice(text.length - max);
+  return MESSAGE_ELISION + text.slice(text.length - (max - MESSAGE_ELISION.length));
+}
+function formatRecord(record) {
+  const time = new Date(record.ts).toISOString();
+  const where = [record.source, record.scope].filter(Boolean).join("/");
+  const head = `${time} ${record.level.toUpperCase()}${where ? ` [${where}]` : ""} ${record.message}`;
+  if (record.data === void 0) return head;
+  return `${head}
+${safeJson(record.data)}`;
+}
+function safeJson(value) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  try {
+    return JSON.stringify(
+      value,
+      (_k, v) => {
+        if (v && typeof v === "object") {
+          if (seen.has(v)) return "[circular]";
+          seen.add(v);
+        }
+        return v;
+      },
+      2
+    ) ?? String(value);
+  } catch {
+    return String(value);
+  }
+}
+
+// src/ops/console/controller.ts
+var ConsoleController = class {
+  host;
+  listeners = /* @__PURE__ */ new Set();
+  maxRecords;
+  maxMessageChars;
+  records = [];
+  /**
+   * Record id → ABSOLUTE position, where absolute = array index + {@link origin}.
+   *
+   * Patching by id has to be O(1) or streaming is worse than the thing it replaces: a linear scan
+   * of a 5 000-record buffer per fragment, at a thousand fragments a second, is five million
+   * comparisons a second to update one line. (`runs/src/controller.ts` keeps the same index for the
+   * same reason.)
+   *
+   * The absolute/origin split is what makes the ring buffer cheap. The buffer trims from the FRONT,
+   * so storing raw array indices would mean decrementing every entry on every trim — O(n) per
+   * append once the buffer is full. An offset moves the whole map in one addition instead.
+   *
+   * ⚠️ Records with no id, or an empty one, are not indexed and therefore cannot be patched. That
+   * is the honest outcome: `id` is what "addressed" means here, and there is nothing else to
+   * address them by.
+   */
+  index = /* @__PURE__ */ new Map();
+  /** Absolute position of `records[0]`. */
+  origin = 0;
+  filter;
+  follow;
+  collapse;
+  rev = 0;
+  dropped = 0;
+  droppedPatches = 0;
+  snapshot = null;
+  constructor(options) {
+    this.host = options.host;
+    this.maxRecords = Math.max(1, options.maxRecords ?? 5e3);
+    this.maxMessageChars = Math.max(REDACTION_CARRY * 2, options.maxMessageChars ?? 65536);
+    this.filter = options.initial?.filter ?? {};
+    this.follow = options.initial?.follow ?? options.follow ?? true;
+    this.collapse = options.initial?.collapse ?? options.collapse ?? true;
+  }
+  /* ── Subscription ──────────────────────────────────────────────────────── */
+  subscribe = (listener) => {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  };
+  getState = () => {
+    if (!this.snapshot) {
+      const counts = {
+        trace: 0,
+        debug: 0,
+        info: 0,
+        warn: 0,
+        error: 0
+      };
+      for (const record of this.records) counts[record.level] += 1;
+      this.snapshot = {
+        rows: this.rows(),
+        sources: this.sources(),
+        filter: this.filter,
+        counts,
+        total: this.records.length,
+        follow: this.follow,
+        collapse: this.collapse,
+        dropped: this.dropped,
+        droppedPatches: this.droppedPatches
+      };
+    }
+    return this.snapshot;
+  };
+  notify() {
+    this.snapshot = null;
+    for (const listener of this.listeners) listener();
+  }
+  /* ── Ingest ────────────────────────────────────────────────────────────── */
+  /**
+   * Apply a delta.
+   *
+   * @param delta - Append / patch / replace / clear.
+   * @returns `true` if applied; `false` if dropped as stale.
+   */
+  apply(delta) {
+    if (delta.rev !== void 0 && delta.rev <= this.rev) return false;
+    if (delta.rev !== void 0) this.rev = delta.rev;
+    if (delta.clear) {
+      this.records = delta.source ? this.records.filter((r) => r.source !== delta.source) : [];
+      this.dropped = 0;
+      this.droppedPatches = 0;
+      this.reindex();
+    } else if (delta.replace) {
+      const kept = delta.source ? this.records.filter((r) => r.source !== delta.source) : [];
+      this.records = [...kept, ...delta.replace.map((r) => this.sanitize(r))];
+      this.reindex();
+    }
+    if (delta.append && delta.append.length > 0) {
+      for (const record of delta.append) {
+        const clean = this.sanitize(record);
+        this.records.push(clean);
+        this.remember(clean.id, this.origin + this.records.length - 1);
+      }
+    }
+    if (delta.patch) this.applyPatches(delta.patch);
+    if (this.records.length > this.maxRecords) {
+      const over = this.records.length - this.maxRecords;
+      for (let i = 0; i < over; i += 1) this.forget(this.records[i].id, this.origin + i);
+      this.records.splice(0, over);
+      this.origin += over;
+      this.dropped += over;
+    }
+    this.notify();
+    return true;
+  }
+  /* ── Update by id ──────────────────────────────────────────────────────── */
+  /**
+   * Apply the `patch` map of a delta.
+   *
+   * ⚠️ Every field is checked, not cast. A wire is a user-editable connection, so the wrong shape
+   * arriving is a normal mis-wire rather than an exceptional condition — and the failure mode here
+   * is not a throw but silent corruption: a `level` of `"shout"` would add a key to the level
+   * counts that no filter can ever match and no chip can ever reveal.
+   */
+  applyPatches(patches) {
+    if (typeof patches !== "object" || Array.isArray(patches)) return;
+    for (const [id, patch] of Object.entries(patches)) {
+      if (!patch || typeof patch !== "object" || Array.isArray(patch)) {
+        this.droppedPatches += 1;
+        continue;
+      }
+      const at = this.positionOf(id);
+      if (at < 0) {
+        this.droppedPatches += 1;
+        continue;
+      }
+      this.records[at] = this.merge(this.records[at], patch);
+    }
+  }
+  /**
+   * Fold a patch into a record, redacting what the patch brought in.
+   *
+   * 🔴 The append path redacts across the JOIN, not the fragment — {@link spliceRedactedAppend}
+   * carries the reasoning. Truncation runs last so the cap counts redacted characters; see
+   * {@link truncateLogMessage} for why measuring raw text would make the retained window vary.
+   *
+   * ⚠️ `source` is deliberately NOT redacted, matching `sanitize` on the append path: it is a
+   * stream name the host chose, and redacting it would break the per-source mute chips it keys.
+   */
+  merge(existing, patch) {
+    const secrets = [...this.host.getSecrets?.() ?? []];
+    const redact = (text) => redactForLog(text, secrets);
+    let message = existing.message;
+    if (typeof patch.message === "string") message = redact(patch.message);
+    if (typeof patch.appendMessage === "string" && patch.appendMessage.length > 0) {
+      const carry = Math.max(REDACTION_CARRY, ...secrets.map((s) => s.length));
+      message = spliceRedactedAppend(message, patch.appendMessage, redact, carry);
+    }
+    return {
+      ...existing,
+      // `id` is restated from the EXISTING record, never the patch: it is the virtualized row key
+      // and the argument to recordActivate, and a patch that moved it would remount the row
+      // mid-stream and repoint the host's reveal hook at a different line.
+      id: existing.id,
+      message: truncateLogMessage(message, this.maxMessageChars),
+      level: LEVEL_ORDER.includes(patch.level) ? patch.level : existing.level,
+      ts: Number.isFinite(patch.ts) ? patch.ts : existing.ts,
+      source: typeof patch.source === "string" ? patch.source : existing.source,
+      scope: typeof patch.scope === "string" ? redact(patch.scope) : existing.scope,
+      // One rule for every field: an absent key means "leave it alone". To empty a payload, send
+      // `null` — `{ data: undefined }` is indistinguishable from omitting it.
+      data: patch.data !== void 0 ? redactForLog(patch.data, secrets) : existing.data,
+      // `count` is the panel's, set by collapsing. A patch cannot claim a line repeated.
+      count: existing.count
+    };
+  }
+  /* ── The id index ──────────────────────────────────────────────────────── */
+  /** Array position of `id`, or `-1` when it is unknown or has been evicted. */
+  positionOf(id) {
+    const absolute = this.index.get(id);
+    if (absolute === void 0) return -1;
+    const at = absolute - this.origin;
+    return at >= 0 && at < this.records.length ? at : -1;
+  }
+  /**
+   * Index a record.
+   *
+   * ⚠️ Last-wins when a host re-uses an id, which the contract forbids but nothing prevents. For a
+   * PATCH that is the right answer — a producer that re-used an id is talking about the line it
+   * just wrote, not one that scrolled past — and it also keeps eviction correct, because the ring
+   * trims from the front and so retires the older twin first.
+   */
+  remember(id, absolute) {
+    if (typeof id === "string" && id.length > 0) this.index.set(id, absolute);
+  }
+  /** Drop an index entry, but only if it still points at the position being evicted. */
+  forget(id, absolute) {
+    if (this.index.get(id) === absolute) this.index.delete(id);
+  }
+  /**
+   * Rebuild the whole index.
+   *
+   * Only for `clear` and `replace`, which remove from the middle and so invalidate every position
+   * after the hole. Those are cold paths — a source restarting — and paying O(n) there is what buys
+   * O(1) on the hot ones.
+   */
+  reindex() {
+    this.index = /* @__PURE__ */ new Map();
+    this.origin = 0;
+    for (let i = 0; i < this.records.length; i += 1) this.remember(this.records[i].id, i);
+  }
+  /** Append records directly — sugar for the common case. */
+  append(records) {
+    return this.apply({ append: [...records] });
+  }
+  /**
+   * Redact a record on the way IN.
+   *
+   * Not at render: redacting late leaves the secret in the buffer, in search results, and in
+   * whatever `copy` puts on the clipboard.
+   */
+  sanitize(record) {
+    const secrets = this.host.getSecrets?.() ?? [];
+    return {
+      ...record,
+      /*
+       * 🔴 Truncate on THIS path too, not only on the streaming merge.
+       *
+       * `maxRecords` bounds how many lines are held; nothing bounded how long ONE line is — and
+       * the omission was invisible, because the record count never moves. Measured before this
+       * fix: with `maxMessageChars: 2048`, an appended 1,080,000-character message stored all
+       * 1,080,000, while the same text arriving as `appendMessage` fragments stored 2,048. One
+       * ingest path honoured a documented cap and the other ignored it.
+       *
+       * ⚠️ Order matters: redact, THEN truncate. Truncating first can split a secret across the
+       * elision boundary so neither half matches the registered value, and a redactor that no
+       * longer recognises what it is looking at is worse than no cap.
+       */
+      message: truncateLogMessage(redactForLog(record.message, secrets), this.maxMessageChars),
+      scope: record.scope === void 0 ? void 0 : redactForLog(record.scope, secrets),
+      data: record.data === void 0 ? void 0 : redactForLog(record.data, secrets)
+    };
+  }
+  /* ── Filtering ─────────────────────────────────────────────────────────── */
+  /** Replace the filter. */
+  setFilter(filter) {
+    this.filter = filter;
+    this.notify();
+  }
+  /** Set the search term. */
+  setSearch(search) {
+    this.filter = { ...this.filter, search };
+    this.notify();
+  }
+  /** Set the minimum severity. */
+  setLevel(minLevel) {
+    if (minLevel !== void 0 && !LEVEL_ORDER.includes(minLevel)) return false;
+    this.filter = { ...this.filter, minLevel };
+    this.notify();
+    return true;
+  }
+  /** Show or hide one source. */
+  toggleSource(source, enabled) {
+    const muted = new Set(this.filter.mutedSources ?? []);
+    const next = enabled ?? muted.has(source);
+    if (next) muted.delete(source);
+    else muted.add(source);
+    this.filter = { ...this.filter, mutedSources: [...muted] };
+    this.notify();
+  }
+  /** The visible rows, filtered and (optionally) collapsed. */
+  rows() {
+    const muted = new Set(this.filter.mutedSources ?? []);
+    const search = (this.filter.search ?? "").trim();
+    const visible2 = this.records.filter(
+      (r) => meetsLevel(r.level, this.filter.minLevel) && !muted.has(r.source ?? "") && matchesSearch(r, search)
+    );
+    return this.collapse ? collapseAdjacent(visible2) : visible2.map((r) => ({ ...r, count: 1 }));
+  }
+  /** Every source seen, with its contribution count and current visibility. */
+  sources() {
+    const muted = new Set(this.filter.mutedSources ?? []);
+    const counts = /* @__PURE__ */ new Map();
+    for (const record of this.records) {
+      const id = record.source ?? "";
+      counts.set(id, (counts.get(id) ?? 0) + 1);
+    }
+    return [...counts.entries()].map(([id, count]) => ({
+      id,
+      label: id === "" ? "(unsourced)" : id,
+      enabled: !muted.has(id),
+      count
+    }));
+  }
+  /* ── Interaction ───────────────────────────────────────────────────────── */
+  /** Follow the tail. Auto-disabled by the view when the user scrolls up. */
+  setFollow(follow) {
+    if (this.follow === follow) return;
+    this.follow = follow;
+    this.notify();
+  }
+  /** Collapse adjacent duplicates. */
+  setCollapse(collapse) {
+    if (this.collapse === collapse) return;
+    this.collapse = collapse;
+    this.notify();
+  }
+  /** Drop every record. Emits nothing — clearing a view is not an event a host acts on. */
+  clear() {
+    this.records = [];
+    this.dropped = 0;
+    this.droppedPatches = 0;
+    this.reindex();
+    this.notify();
+  }
+  /**
+   * A record was opened.
+   *
+   * **This is what makes the panel useful in a builder**: clicking a log line tells the host which
+   * node or panel produced it, so it can reveal the offender.
+   */
+  activate(recordId) {
+    const record = this.records.find((r) => r.id === recordId);
+    if (!record) return false;
+    const payload = {
+      recordId,
+      source: record.source,
+      scope: record.scope
+    };
+    this.host.emit("recordActivate", payload);
+    return true;
+  }
+  /** The copyable text of a record — already redacted, because the buffer is. */
+  copyText(recordId) {
+    const record = this.records.find((r) => r.id === recordId);
+    return record ? formatRecord(record) : null;
+  }
+  /** The copyable text of everything currently visible. */
+  copyVisible() {
+    return this.rows().map(formatRecord).join("\n");
+  }
+  /** Ask the host to open a context menu. */
+  requestContextMenu(recordId, x, y) {
+    this.host.emit("contextMenuRequest", { recordId, x, y });
+  }
+  /** The raw buffer, for `get_records`. */
+  all() {
+    return [...this.records];
+  }
+  /* ── Persistence ───────────────────────────────────────────────────────── */
+  /** Serialize. Filter and toggles — **never the records**; a log is not a document. */
+  serialize() {
+    return { filter: this.filter, follow: this.follow, collapse: this.collapse };
+  }
+  /** Restore. Does not emit. */
+  deserialize(state) {
+    if (state.filter) this.filter = state.filter;
+    if (typeof state.follow === "boolean") this.follow = state.follow;
+    if (typeof state.collapse === "boolean") this.collapse = state.collapse;
+    this.notify();
+  }
+  /** Drop listeners and the buffer. */
+  dispose() {
+    this.listeners.clear();
+    this.records = [];
+    this.index = /* @__PURE__ */ new Map();
+    this.origin = 0;
+  }
+};
+
+// src/ops/console/manifest.ts
+var CONSOLE_PANEL_ID = "xeno.core.console";
+var consoleManifest = {
+  id: CONSOLE_PANEL_ID,
+  version: "0.1.0",
+  title: "Console",
+  icon: "terminal",
+  description: "Structured log records from multiplexed sources: severity filters, search, adjacent-duplicate collapsing, follow-tail and virtualization. Every record is redacted on the way in.",
+  defaultSlot: "bottom",
+  inputs: [
+    {
+      id: "records",
+      name: "Records",
+      type: "object",
+      description: "An APPEND-oriented delta: {rev?, append?, patch?, replace?, clear?, source?}. A console that re-pushes its whole buffer per line is a non-starter. `patch` updates records BY ID \u2014 the channel a line that is still being written needs; a patch for an id the buffer does not hold is dropped, never upserted.",
+      // Fan-in by design: multiplexing several streams into one view is the point.
+      multiple: true
+    },
+    {
+      id: "filter",
+      name: "Filter",
+      type: "object",
+      description: "An externally set filter {minLevel?, search?, mutedSources?}.",
+      multiple: false
+    }
+  ],
+  outputs: [
+    {
+      id: "recordActivate",
+      name: "Record Activated",
+      type: "object",
+      description: "{recordId, source?, scope?} \u2014 a log line was opened, so the host can reveal the node or panel that produced it. This is what makes the panel useful in a builder."
+    },
+    {
+      id: "contextMenuRequest",
+      name: "Context Menu Request",
+      type: "object",
+      description: "The host opens its own menu."
+    }
+  ],
+  commands: [
+    {
+      id: "get_records",
+      title: "Get Records",
+      description: "Return the buffer. Already redacted \u2014 the panel never holds an unredacted value.",
+      parameters: {}
+    },
+    {
+      id: "filter",
+      title: "Filter",
+      description: "Set the search term.",
+      parameters: { search: { type: "string", description: "Substring over message/source/scope" } }
+    },
+    {
+      id: "set_level",
+      title: "Set Level",
+      description: "Set the minimum severity. Omit to show everything.",
+      parameters: { level: { type: "string", description: "trace|debug|info|warn|error" } }
+    },
+    { id: "clear", title: "Clear", description: "Drop every record.", parameters: {} },
+    {
+      id: "follow_tail",
+      title: "Follow Tail",
+      description: "Stick to the newest record.",
+      parameters: { follow: { type: "boolean", description: "Desired state" } }
+    },
+    {
+      id: "reveal_source",
+      title: "Reveal Source",
+      description: "Emit recordActivate for a record, so the host can reveal its origin.",
+      parameters: { recordId: { type: "string", description: "Record id", required: true } }
+    }
+  ],
+  config: [
+    {
+      key: "maxRecords",
+      label: "Buffer size",
+      type: "number",
+      defaultValue: 5e3,
+      description: "Ring-buffer capacity. A console is a window on recent output, not an archive.",
+      placeholder: "5000"
+    },
+    {
+      key: "maxMessageChars",
+      label: "Max line length",
+      type: "number",
+      defaultValue: 65536,
+      description: "Cap on ONE record\u2019s message, so a producer streaming into a single line cannot grow without bound while the record count stays still. The newest text is kept.",
+      placeholder: "65536"
+    },
+    {
+      key: "rowHeight",
+      label: "Row height",
+      type: "number",
+      defaultValue: 20,
+      description: "Fixed \u2014 what keeps virtualization O(1). No incumbent virtualizes at all.",
+      placeholder: "20"
+    },
+    {
+      key: "collapse",
+      label: "Collapse duplicates",
+      type: "boolean",
+      defaultValue: true,
+      description: "Collapse ADJACENT identical records into one row with a count. Adjacent-run, not global \u2014 collapsing globally would hide when a recurrence happened."
+    },
+    {
+      key: "follow",
+      label: "Follow tail",
+      type: "boolean",
+      defaultValue: true,
+      description: "Stick to the newest record. Auto-disabled when the user scrolls up."
+    },
+    {
+      key: "minLevel",
+      label: "Minimum level",
+      type: "select",
+      options: [
+        { label: "Trace", value: "trace" },
+        { label: "Debug", value: "debug" },
+        { label: "Info", value: "info" },
+        { label: "Warn", value: "warn" },
+        { label: "Error", value: "error" }
+      ],
+      description: "Hide anything less severe."
+    },
+    {
+      key: "showTimestamps",
+      label: "Timestamps",
+      type: "boolean",
+      defaultValue: true,
+      description: "Render a time column."
+    },
+    {
+      key: "emptyHint",
+      label: "Empty hint",
+      type: "text",
+      description: "Say what would produce output, not that there is none.",
+      placeholder: "Run the graph to see its output here."
+    }
+  ],
+  capabilities: ["storage.local"],
+  sdk: "^1.1.0"
+};
+
+// src/ops/console/react/ConsolePanelView.tsx
+import { useCallback, useEffect, useRef, useState, useSyncExternalStore } from "react";
+import {
+  Badge,
+  EmptyState,
+  IconButton,
+  Row,
+  RowList,
+  ScrollArea,
+  SearchField,
+  SegmentedControl,
+  StatusBar,
+  Toolbar,
+  ToolbarGroup
+} from "@xenosystem/workbench/primitives/react";
+import { computeWindow } from "@xenosystem/tree-core";
+
+// src/ops/console/react/icons.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function Svg({ children }) {
+  return /* @__PURE__ */ jsx(
+    "svg",
+    {
+      width: 11,
+      height: 11,
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "1.5",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      "aria-hidden": "true",
+      children
+    }
+  );
+}
+function CopyGlyph() {
+  return /* @__PURE__ */ jsxs(Svg, { children: [
+    /* @__PURE__ */ jsx("rect", { x: "9", y: "9", width: "12", height: "12", rx: "2" }),
+    /* @__PURE__ */ jsx("path", { d: "M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1" })
+  ] });
+}
+function ClearGlyph() {
+  return /* @__PURE__ */ jsxs(Svg, { children: [
+    /* @__PURE__ */ jsx("rect", { x: "3", y: "3", width: "18", height: "18", rx: "3" }),
+    /* @__PURE__ */ jsx("path", { d: "m6 6 12 12" })
+  ] });
+}
+
+// src/ops/console/react/ConsolePanelView.tsx
+import { Fragment, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var TONE = {
+  trace: "neutral",
+  debug: "neutral",
+  info: "info",
+  warn: "warning",
+  error: "error"
+};
+function ConsolePanelView({
+  controller,
+  rowHeight = 20,
+  showTimestamps = true,
+  emptyHint
+}) {
+  const state = useSyncExternalStore(controller.subscribe, controller.getState, controller.getState);
+  const scrollRef = useRef(null);
+  const [viewport, setViewport] = useState({ height: 0, scrollTop: 0 });
+  const [expanded, setExpanded] = useState(null);
+  useEffect(() => {
+    const element = scrollRef.current;
+    if (!element || typeof ResizeObserver === "undefined") return;
+    const observer = new ResizeObserver(() => setViewport((v) => ({ ...v, height: element.clientHeight })));
+    observer.observe(element);
+    setViewport((v) => ({ ...v, height: element.clientHeight }));
+    return () => observer.disconnect();
+  }, []);
+  useEffect(() => {
+    const element = scrollRef.current;
+    if (!element || !state.follow) return;
+    element.scrollTop = element.scrollHeight;
+  }, [state.rows.length, state.follow]);
+  const onScroll = useCallback(
+    (event) => {
+      const el = event.currentTarget;
+      setViewport((v) => ({ ...v, scrollTop: el.scrollTop }));
+      const atBottom = el.scrollHeight - el.scrollTop - el.clientHeight < rowHeight;
+      if (state.follow && !atBottom) controller.setFollow(false);
+      else if (!state.follow && atBottom) controller.setFollow(true);
+    },
+    [controller, rowHeight, state.follow]
+  );
+  const window = computeWindow({
+    scrollTop: viewport.scrollTop,
+    viewportHeight: viewport.height || rowHeight * 20,
+    rowHeight,
+    rowCount: state.rows.length
+  });
+  const slice = state.rows.slice(window.startIndex, window.endIndex);
+  return /* @__PURE__ */ jsxs2("div", { style: { display: "flex", flexDirection: "column", height: "100%", minHeight: 0 }, children: [
+    /* @__PURE__ */ jsx2(
+      Toolbar,
+      {
+        left: /* @__PURE__ */ jsxs2(Fragment, { children: [
+          /* @__PURE__ */ jsx2(
+            SearchField,
+            {
+              value: state.filter.search ?? "",
+              onChange: (term) => controller.setSearch(term),
+              placeholder: "Filter\u2026"
+            }
+          ),
+          /* @__PURE__ */ jsx2(
+            SegmentedControl,
+            {
+              size: "sm",
+              label: "Minimum level",
+              options: LEVEL_ORDER.map((l) => ({ value: l, label: l.slice(0, 1).toUpperCase() })),
+              value: state.filter.minLevel ?? "trace",
+              onChange: (level) => controller.setLevel(level === "trace" ? void 0 : level)
+            }
+          )
+        ] }),
+        right: /* @__PURE__ */ jsxs2(ToolbarGroup, { end: true, children: [
+          state.counts.error > 0 ? /* @__PURE__ */ jsx2(Badge, { tone: "error", children: String(state.counts.error) }) : null,
+          state.counts.warn > 0 ? /* @__PURE__ */ jsx2(Badge, { tone: "warning", children: String(state.counts.warn) }) : null,
+          /* @__PURE__ */ jsx2(
+            IconButton,
+            {
+              icon: /* @__PURE__ */ jsx2(CopyGlyph, {}),
+              label: "Copy visible",
+              onClick: () => {
+                void navigator?.clipboard?.writeText(controller.copyVisible());
+              }
+            }
+          ),
+          /* @__PURE__ */ jsx2(IconButton, { icon: /* @__PURE__ */ jsx2(ClearGlyph, {}), label: "Clear", onClick: () => controller.clear() })
+        ] })
+      }
+    ),
+    state.sources.length > 1 ? /* @__PURE__ */ jsx2("div", { style: { display: "flex", gap: 4, padding: "2px 6px", flexWrap: "wrap" }, children: state.sources.map((source) => /* @__PURE__ */ jsx2(
+      "span",
+      {
+        onClick: () => controller.toggleSource(source.id),
+        style: { cursor: "pointer", opacity: source.enabled ? 1 : 0.4 },
+        children: /* @__PURE__ */ jsx2(Badge, { title: `${source.count} records`, children: source.label ?? source.id })
+      },
+      source.id
+    )) }) : null,
+    state.rows.length === 0 ? /* @__PURE__ */ jsx2(
+      EmptyState,
+      {
+        title: state.total > 0 ? "No matches" : "No output",
+        hint: state.total > 0 ? "Nothing matches the current filter." : emptyHint ?? "Run something to see its output here."
+      }
+    ) : /* @__PURE__ */ jsx2(ScrollArea, { children: /* @__PURE__ */ jsx2("div", { ref: scrollRef, onScroll, style: { height: "100%", overflow: "auto" }, children: /* @__PURE__ */ jsx2("div", { style: { height: window.totalHeight, position: "relative" }, children: /* @__PURE__ */ jsx2("div", { style: { transform: `translateY(${window.offsetTop}px)` }, children: /* @__PURE__ */ jsx2(RowList, { role: "log", children: slice.map((record) => /* @__PURE__ */ jsx2(
+      LogRow,
+      {
+        record,
+        controller,
+        rowHeight,
+        showTimestamps,
+        expanded: expanded === record.id,
+        onToggle: () => setExpanded(expanded === record.id ? null : record.id)
+      },
+      record.id
+    )) }) }) }) }) }),
+    /* @__PURE__ */ jsx2(
+      StatusBar,
+      {
+        left: `${state.rows.length} of ${state.total}` + (state.dropped > 0 ? ` \xB7 ${state.dropped} dropped` : "") + // A patch that addressed nothing is the one streaming failure with no visible symptom:
+        // the producer sees no line grow, and a mis-keyed wire looks exactly like a dead one.
+        (state.droppedPatches > 0 ? ` \xB7 ${state.droppedPatches} unmatched` : ""),
+        right: state.follow ? "following" : void 0
+      }
+    )
+  ] });
+}
+function LogRow({
+  record,
+  controller,
+  rowHeight,
+  showTimestamps,
+  expanded,
+  onToggle
+}) {
+  return /* @__PURE__ */ jsxs2(Fragment, { children: [
+    /* @__PURE__ */ jsx2(
+      Row,
+      {
+        style: { height: rowHeight, alignItems: "flex-start" },
+        noIcon: true,
+        onClick: () => {
+          if (record.data !== void 0) onToggle();
+          controller.activate(record.id);
+        },
+        onContextMenu: (e) => {
+          e.preventDefault();
+          controller.requestContextMenu(record.id, e.clientX, e.clientY);
+        },
+        label: /* @__PURE__ */ jsxs2("span", { style: { display: "flex", gap: 6, alignItems: "center", minWidth: 0 }, children: [
+          showTimestamps ? /* @__PURE__ */ jsx2("span", { style: { opacity: 0.45, fontVariantNumeric: "tabular-nums", flex: "0 0 auto" }, children: new Date(record.ts).toISOString().slice(11, 23) }) : null,
+          /* @__PURE__ */ jsx2(Badge, { tone: TONE[record.level], children: record.level }),
+          record.source ? /* @__PURE__ */ jsx2("span", { style: { opacity: 0.55 }, children: record.source }) : null,
+          /* @__PURE__ */ jsx2(
+            "span",
+            {
+              style: { overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap", minWidth: 0 },
+              children: record.message
+            }
+          )
+        ] }),
+        trailing: (record.count ?? 1) > 1 ? (
+          // The best feature in any incumbent: a run of identical lines is one row with a count.
+          /* @__PURE__ */ jsx2(Badge, { title: "Repeated consecutively", children: `x${record.count}` })
+        ) : null
+      }
+    ),
+    expanded && record.data !== void 0 ? /* @__PURE__ */ jsx2(
+      "pre",
+      {
+        style: {
+          margin: 0,
+          padding: "2px 10px 6px 24px",
+          fontSize: 10,
+          lineHeight: 1.4,
+          whiteSpace: "pre-wrap",
+          wordBreak: "break-all",
+          opacity: 0.8
+        },
+        children: safeJson(record.data)
+      }
+    ) : null
+  ] });
+}
+
+// src/ops/console/panel.ts
+function createConsolePanel(options = {}) {
+  return {
+    manifest: consoleManifest,
+    activate(host) {
+      const config = host.config ?? {};
+      const controller = new ConsoleController({
+        host: {
+          emit: (portId, value) => host.emit(portId, value),
+          getSecrets: options.getSecrets
+        },
+        maxRecords: numberConfig(config.maxRecords, 5e3),
+        maxMessageChars: numberConfig(config.maxMessageChars, 65536),
+        collapse: config.collapse !== false,
+        follow: config.follow !== false,
+        initial: {
+          filter: typeof config.minLevel === "string" ? { minLevel: config.minLevel } : {}
+        }
+      });
+      const resolve = (config2) => ({
+        rowHeight: numberConfig(config2.rowHeight, 20),
+        showTimestamps: config2.showTimestamps !== false,
+        emptyHint: typeof config2.emptyHint === "string" ? config2.emptyHint : void 0
+      });
+      let renderConfig = resolve(host.config ?? {});
+      let unrender = null;
+      let root = null;
+      let currentEl = null;
+      const draw = (el) => {
+        unrender?.();
+        if (options.render) {
+          unrender = options.render(el, { controller, config: renderConfig });
+          return;
+        }
+        root = createRoot(el);
+        root.render(createElement(ConsolePanelView, { controller, ...renderConfig }));
+        unrender = () => {
+          root?.unmount();
+          root = null;
+        };
+      };
+      const unbindConfig = bindConfig(host, (config2) => {
+        renderConfig = resolve(config2);
+        if (currentEl) draw(currentEl);
+      });
+      return {
+        render(el) {
+          currentEl = el;
+          draw(el);
+        },
+        onInput(portId, value) {
+          if (portId === "records") {
+            if (Array.isArray(value)) controller.apply({ append: value });
+            else if (isRecord(value)) controller.apply(value);
+          } else if (portId === "filter") {
+            if (isRecord(value)) controller.setFilter(value);
+          }
+        },
+        async onCommand(commandId, params) {
+          switch (commandId) {
+            case "get_records":
+              return controller.all();
+            case "filter":
+              controller.setSearch(String(params.search ?? ""));
+              return true;
+            case "set_level":
+              return controller.setLevel(
+                typeof params.level === "string" ? params.level : void 0
+              );
+            case "clear":
+              controller.clear();
+              return true;
+            case "follow_tail":
+              controller.setFollow(params.follow !== false);
+              return true;
+            case "reveal_source":
+              return controller.activate(String(params.recordId));
+            default:
+              return;
+          }
+        },
+        serialize() {
+          return controller.serialize();
+        },
+        deserialize(state) {
+          controller.deserialize(state ?? {});
+        },
+        dispose() {
+          unbindConfig();
+          currentEl = null;
+          unrender?.();
+          unrender = null;
+          controller.dispose();
+        }
+      };
+    }
+  };
+}
+function numberConfig(value, fallback) {
+  const n = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+var consolePanel = createConsolePanel();
+
+// src/ops/runs/panel.ts
+import { createElement as createElement2 } from "react";
+import { createRoot as createRoot2 } from "react-dom/client";
+import {
+  isRecord as isRecord2,
+  bindConfig as bindConfig2
+} from "@xenosystem/panel-sdk";
+
+// src/ops/runs/controller.ts
+import { createThrottle } from "@xenosystem/tree-core";
+
+// src/ops/runs/types.ts
+var RUN_STATUSES = [
+  "requested",
+  "queued",
+  "running",
+  "paused",
+  "blocked",
+  "awaiting-decision",
+  "awaiting-permission",
+  "succeeded",
+  "failed",
+  "cancelled"
+];
+var RUN_LIFECYCLE = {
+  requested: "active",
+  queued: "active",
+  running: "active",
+  paused: "active",
+  blocked: "waiting",
+  "awaiting-decision": "waiting",
+  "awaiting-permission": "waiting",
+  succeeded: "terminal",
+  failed: "terminal",
+  cancelled: "terminal"
+};
+function lifecycleOf(status) {
+  return RUN_LIFECYCLE[status] ?? "waiting";
+}
+var TERMINAL_STATUSES = new Set(
+  RUN_STATUSES.filter((status) => RUN_LIFECYCLE[status] === "terminal")
+);
+function isTerminal(status) {
+  return TERMINAL_STATUSES.has(status);
+}
+function isActive(status) {
+  return lifecycleOf(status) === "active";
+}
+function isWaiting(status) {
+  return lifecycleOf(status) === "waiting";
+}
+var RUN_PATH_SEPARATOR = "\0";
+function encodeRunPath(path) {
+  return path.join(RUN_PATH_SEPARATOR);
+}
+function decodeRunPath(key) {
+  return key.split(RUN_PATH_SEPARATOR);
+}
+var DEFAULT_MAX_STEP_DEPTH = 32;
+var ALL_STATUSES = RUN_STATUSES;
+function canCancel(run) {
+  if (run.canCancel !== void 0) return run.canCancel;
+  return !isTerminal(run.status);
+}
+function canRetry(run) {
+  if (run.canRetry !== void 0) return run.canRetry;
+  if (run.status !== "failed" && run.status !== "cancelled") return false;
+  return run.error?.retryable !== false;
+}
+function durationOf(run, now) {
+  const from = run.executionStartedAt ?? run.startedAt;
+  if (run.endedAt !== void 0) return Math.max(0, run.endedAt - from);
+  if (isTerminal(run.status)) return null;
+  return Math.max(0, now - from);
+}
+function queueDurationOf(run, now) {
+  if (run.executionStartedAt !== void 0) {
+    return Math.max(0, run.executionStartedAt - run.startedAt);
+  }
+  if (isTerminal(run.status)) return null;
+  if (isActive(run.status) && run.status !== "requested" && run.status !== "queued") return null;
+  return Math.max(0, now - run.startedAt);
+}
+function matchesSearch2(run, term) {
+  if (!term) return true;
+  const needle = term.toLowerCase();
+  return run.label.toLowerCase().includes(needle) || (run.source ?? "").toLowerCase().includes(needle) || (run.trigger ?? "").toLowerCase().includes(needle) || (run.error?.code ?? "").toLowerCase().includes(needle);
+}
+function computeStats(runs) {
+  let terminal = 0;
+  let active = 0;
+  let waiting = 0;
+  let succeeded = 0;
+  let failed = 0;
+  let cancelled = 0;
+  let durationSum = 0;
+  let durationCount = 0;
+  for (const run of runs) {
+    if (isTerminal(run.status)) {
+      terminal += 1;
+      if (run.status === "succeeded") succeeded += 1;
+      else if (run.status === "failed") failed += 1;
+      else cancelled += 1;
+      if (run.endedAt !== void 0) {
+        durationSum += Math.max(0, run.endedAt - (run.executionStartedAt ?? run.startedAt));
+        durationCount += 1;
+      }
+    } else if (isActive(run.status)) {
+      active += 1;
+    } else {
+      waiting += 1;
+    }
+  }
+  return {
+    total: runs.length,
+    terminal,
+    active,
+    waiting,
+    succeeded,
+    failed,
+    cancelled,
+    // OVER TERMINAL RUNS ONLY. Counting in-flight runs makes the rate dip every time work starts.
+    successRate: terminal === 0 ? null : succeeded / terminal,
+    meanDurationMs: durationCount === 0 ? null : durationSum / durationCount
+  };
+}
+function formatDuration(ms) {
+  if (ms < 1e3) return `${Math.round(ms)}ms`;
+  const seconds = ms / 1e3;
+  if (seconds < 60) return `${seconds.toFixed(1)}s`;
+  const s = Math.floor(seconds % 60);
+  const m = Math.floor(seconds / 60 % 60);
+  const h = Math.floor(seconds / 3600);
+  const pad = (n) => String(n).padStart(2, "0");
+  return h > 0 ? `${h}h ${pad(m)}m` : `${m}m ${pad(s)}s`;
+}
+
+// src/ops/runs/steps.ts
+function resolveStepPath(steps, path) {
+  if (!steps || path.length === 0) return null;
+  let level = steps;
+  let found = null;
+  for (const id of path) {
+    const next = level?.find((step) => step.id === id);
+    if (!next) return null;
+    found = next;
+    level = next.steps;
+  }
+  return found;
+}
+function patchStepAtPath(steps, path, patch) {
+  if (!steps || path.length === 0) return null;
+  const index = steps.findIndex((step) => step.id === path[0]);
+  if (index < 0) return null;
+  const target = steps[index];
+  let replacement;
+  if (path.length === 1) {
+    replacement = { ...target, ...patch, id: target.id };
+  } else {
+    const children = patchStepAtPath(target.steps, path.slice(1), patch);
+    if (!children) return null;
+    replacement = { ...target, steps: children };
+  }
+  const next = steps.slice();
+  next[index] = replacement;
+  return next;
+}
+function appendStepsAtPath(steps, path, incoming) {
+  if (path.length === 0) return upsert(steps ?? [], incoming);
+  if (!steps) return null;
+  const index = steps.findIndex((step) => step.id === path[0]);
+  if (index < 0) return null;
+  const target = steps[index];
+  const children = appendStepsAtPath(target.steps, path.slice(1), incoming);
+  if (!children) return null;
+  const next = steps.slice();
+  next[index] = { ...target, steps: children };
+  return next;
+}
+function isRunStep(value) {
+  return typeof value === "object" && value !== null && typeof value.id === "string";
+}
+function upsert(existing, incoming) {
+  const next = existing.slice();
+  for (const step of incoming) {
+    if (!isRunStep(step)) continue;
+    const at = next.findIndex((candidate) => isRunStep(candidate) && candidate.id === step.id);
+    if (at >= 0) next[at] = step;
+    else next.push(step);
+  }
+  return next;
+}
+function flattenRunRows(runs, options) {
+  const maxDepth = Math.max(0, options.maxDepth ?? DEFAULT_MAX_STEP_DEPTH);
+  const rows = [];
+  const usedKeys = /* @__PURE__ */ new Set();
+  const keyFor = (path) => {
+    const base = encodeRunPath(path);
+    if (!usedKeys.has(base)) {
+      usedKeys.add(base);
+      return base;
+    }
+    let n = 2;
+    while (usedKeys.has(`${base}#${n}`)) n += 1;
+    const disambiguated = `${base}#${n}`;
+    usedKeys.add(disambiguated);
+    return disambiguated;
+  };
+  for (const run of runs) {
+    const runExpanded = options.expanded.has(encodeRunPath([run.id]));
+    const runHasChildren = (run.steps?.length ?? 0) > 0;
+    const runTruncated = runHasChildren && maxDepth < 1 ? "depth" : void 0;
+    rows.push({
+      kind: "run",
+      key: keyFor([run.id]),
+      runId: run.id,
+      run,
+      depth: 0,
+      stepPath: [],
+      hasChildren: runHasChildren,
+      expanded: runExpanded && runHasChildren && !runTruncated,
+      truncated: runTruncated
+    });
+    if (!runHasChildren || !runExpanded || runTruncated) continue;
+    const ancestors = /* @__PURE__ */ new Set();
+    const walk = (steps, parentPath, depth) => {
+      for (const step of steps) {
+        if (!isRunStep(step)) continue;
+        const stepPath = [...parentPath, step.id];
+        const hasChildren = (step.steps?.length ?? 0) > 0;
+        let truncated;
+        if (hasChildren) {
+          if (ancestors.has(step)) truncated = "cycle";
+          else if (depth >= maxDepth) truncated = "depth";
+        }
+        const open = options.expanded.has(encodeRunPath([run.id, ...stepPath])) && hasChildren && !truncated;
+        rows.push({
+          kind: "step",
+          key: keyFor([run.id, ...stepPath]),
+          runId: run.id,
+          run,
+          depth,
+          stepPath,
+          step,
+          hasChildren,
+          expanded: open,
+          truncated
+        });
+        if (open && step.steps) {
+          ancestors.add(step);
+          walk(step.steps, stepPath, depth + 1);
+          ancestors.delete(step);
+        }
+      }
+    };
+    walk(run.steps ?? [], [], 1);
+  }
+  return rows;
+}
+
+// src/ops/runs/controller.ts
+var RunsController = class {
+  host;
+  listeners = /* @__PURE__ */ new Set();
+  maxRuns;
+  maxDepth;
+  now;
+  notifyThrottled;
+  /** Runs by id — patching by id is O(1), which is the whole point of the delta. */
+  byId = /* @__PURE__ */ new Map();
+  order = [];
+  filter;
+  expanded;
+  rev = 0;
+  dropped = 0;
+  snapshot = null;
+  constructor(options) {
+    this.host = options.host;
+    this.maxRuns = Math.max(1, options.maxRuns ?? 500);
+    this.maxDepth = Math.max(0, options.maxDepth ?? DEFAULT_MAX_STEP_DEPTH);
+    this.now = options.host.now ?? (() => Date.now());
+    this.filter = options.initial?.filter ?? {};
+    this.expanded = new Set(options.initial?.expanded ?? []);
+    const throttleMs = Math.max(0, options.throttleMs ?? 100);
+    this.notifyThrottled = createThrottle(
+      () => this.flush(),
+      throttleMs,
+      options.host.clock
+    );
+  }
+  /* ── Subscription ──────────────────────────────────────────────────────── */
+  subscribe = (listener) => {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  };
+  getState = () => {
+    if (!this.snapshot) {
+      const all = this.all();
+      const counts = Object.fromEntries(RUN_STATUSES.map((s) => [s, 0]));
+      for (const run of all) {
+        counts[run.status] = (counts[run.status] ?? 0) + 1;
+      }
+      const runs = this.visible();
+      this.snapshot = {
+        runs,
+        rows: flattenRunRows(runs, { expanded: this.expanded, maxDepth: this.maxDepth }),
+        sources: this.sources(),
+        filter: this.filter,
+        counts,
+        stats: computeStats(all),
+        expanded: [...this.expanded],
+        total: all.length,
+        dropped: this.dropped
+      };
+    }
+    return this.snapshot;
+  };
+  /** Invalidate and notify immediately. */
+  flush() {
+    this.snapshot = null;
+    for (const listener of this.listeners) listener();
+  }
+  /** Invalidate now, notify on the throttle — the hot path. */
+  notify() {
+    this.snapshot = null;
+    this.notifyThrottled.call();
+  }
+  /** Emit any pending notification immediately. Call before reading in a test. */
+  flushNow() {
+    this.notifyThrottled.flush();
+  }
+  /* ── Ingest ────────────────────────────────────────────────────────────── */
+  /**
+   * Apply a delta.
+   *
+   * @param delta - append / patch / remove / replace / clear.
+   * @returns `true` if applied; `false` if dropped as stale.
+   */
+  apply(delta) {
+    if (delta.rev !== void 0 && delta.rev <= this.rev) return false;
+    if (delta.rev !== void 0) this.rev = delta.rev;
+    if (delta.clear) {
+      if (delta.source) {
+        for (const [id, run] of [...this.byId]) {
+          if (run.source === delta.source) this.byId.delete(id);
+        }
+        this.order = this.order.filter((id) => this.byId.has(id));
+      } else {
+        this.byId.clear();
+        this.order = [];
+      }
+      this.dropped = 0;
+    } else if (delta.replace) {
+      if (delta.source) {
+        for (const [id, run] of [...this.byId]) {
+          if (run.source === delta.source) this.byId.delete(id);
+        }
+        this.order = this.order.filter((id) => this.byId.has(id));
+      } else {
+        this.byId.clear();
+        this.order = [];
+      }
+      for (const run of delta.replace) this.insert(run);
+    }
+    if (delta.remove) {
+      for (const id of delta.remove) this.byId.delete(id);
+      this.order = this.order.filter((id) => this.byId.has(id));
+    }
+    if (delta.append) {
+      for (const run of delta.append) this.insert(run);
+    }
+    if (delta.patch) {
+      for (const [id, patch] of Object.entries(delta.patch)) {
+        const existing = this.byId.get(id);
+        if (!existing) continue;
+        this.byId.set(id, { ...existing, ...patch, id });
+      }
+    }
+    if (Array.isArray(delta.appendSteps)) {
+      for (const entry of delta.appendSteps) {
+        if (!entry || !Array.isArray(entry.steps)) continue;
+        const path = normalizePath(entry.path);
+        if (!path) continue;
+        this.applyStepAppend(entry.runId, path, entry.steps);
+      }
+    }
+    if (Array.isArray(delta.patchSteps)) {
+      for (const entry of delta.patchSteps) {
+        if (!entry || !entry.patch || typeof entry.patch !== "object") continue;
+        const path = normalizePath(entry.path);
+        if (!path) continue;
+        this.applyStepPatch(entry.runId, path, entry.patch);
+      }
+    }
+    this.trim();
+    this.notify();
+    return true;
+  }
+  insert(run) {
+    if (!this.byId.has(run.id)) this.order.push(run.id);
+    this.byId.set(run.id, run);
+  }
+  /**
+   * Merge a patch into one step of one run.
+   *
+   * 🔴 The run object is replaced but its untouched subtrees are SHARED — `patchStepAtPath` copies
+   * only the spine. This is the whole reason per-step addressing exists: the alternative a host had
+   * was resending `steps` wholesale on every tick, which is the array-copy storm the delta was
+   * designed to prevent, reintroduced one level down.
+   *
+   * @returns `true` when the address resolved and the patch landed.
+   */
+  applyStepPatch(runId, path, patch) {
+    const run = this.byId.get(runId);
+    if (!run || path.length === 0) return false;
+    if (path.length > this.maxDepth) return false;
+    const steps = patchStepAtPath(run.steps, path, patch);
+    if (!steps) return false;
+    this.byId.set(runId, { ...run, steps });
+    return true;
+  }
+  /**
+   * Add steps to a run, or to a step inside one.
+   *
+   * An unresolvable PARENT is refused rather than created, for the same reason a patch for an
+   * unknown run is: a parent conjured from an append has no label and no status, so it renders as
+   * a row that will never resolve into anything.
+   *
+   * @returns `true` when the parent resolved and the steps landed.
+   */
+  applyStepAppend(runId, path, incoming) {
+    const run = this.byId.get(runId);
+    if (!run || incoming.length === 0) return false;
+    if (path.length >= this.maxDepth) return false;
+    const steps = appendStepsAtPath(run.steps, path, incoming);
+    if (!steps) return false;
+    this.byId.set(runId, { ...run, steps });
+    return true;
+  }
+  /** Ring-buffer the OLDEST runs away, never the newest. */
+  trim() {
+    if (this.order.length <= this.maxRuns) return;
+    const sorted = this.all();
+    const keep = new Set(sorted.slice(0, this.maxRuns).map((r) => r.id));
+    let removed = 0;
+    for (const id of [...this.byId.keys()]) {
+      if (!keep.has(id)) {
+        this.byId.delete(id);
+        removed += 1;
+      }
+    }
+    this.order = this.order.filter((id) => this.byId.has(id));
+    this.dropped += removed;
+  }
+  /** Every run, newest first. */
+  all() {
+    return this.order.map((id) => this.byId.get(id)).filter((r) => !!r).sort((a, b) => b.startedAt - a.startedAt || (a.id < b.id ? -1 : 1));
+  }
+  /* ── Filtering ─────────────────────────────────────────────────────────── */
+  /** Replace the filter. */
+  setFilter(filter) {
+    this.filter = filter;
+    this.flush();
+  }
+  /** Set the search term. */
+  setSearch(search) {
+    this.filter = { ...this.filter, search };
+    this.flush();
+  }
+  /**
+   * Show only these statuses. Empty/absent shows everything.
+   *
+   * **A dead-letter view is `statuses: ['failed']` plus a search — not a second panel.** That is
+   * exactly how one incumbent ended up maintaining two panels for one archetype.
+   */
+  setStatuses(statuses) {
+    this.filter = { ...this.filter, statuses: [...statuses] };
+    this.flush();
+  }
+  /** Show or hide one source. */
+  toggleSource(source, enabled) {
+    const muted = new Set(this.filter.mutedSources ?? []);
+    const next = enabled ?? muted.has(source);
+    if (next) muted.delete(source);
+    else muted.add(source);
+    this.filter = { ...this.filter, mutedSources: [...muted] };
+    this.flush();
+  }
+  /** The visible runs, newest first. */
+  visible() {
+    const statuses = this.filter.statuses;
+    const wanted = statuses && statuses.length > 0 ? new Set(statuses) : null;
+    const muted = new Set(this.filter.mutedSources ?? []);
+    const search = (this.filter.search ?? "").trim();
+    return this.all().filter(
+      (run) => (!wanted || wanted.has(run.status)) && !muted.has(run.source ?? "") && matchesSearch2(run, search)
+    );
+  }
+  /** Every source seen. */
+  sources() {
+    const muted = new Set(this.filter.mutedSources ?? []);
+    const counts = /* @__PURE__ */ new Map();
+    for (const run of this.byId.values()) {
+      const id = run.source ?? "";
+      counts.set(id, (counts.get(id) ?? 0) + 1);
+    }
+    return [...counts.entries()].map(([id, count]) => ({
+      id,
+      label: id === "" ? "(unsourced)" : id,
+      enabled: !muted.has(id),
+      count
+    }));
+  }
+  /* ── Intents ───────────────────────────────────────────────────────────── */
+  /**
+   * Ask the host to cancel a run.
+   *
+   * Refuses a run that cannot be cancelled, and **does not flip the status locally**: the run
+   * becomes `cancelled` when the host says so, not when the panel asks.
+   */
+  cancel(runId, step) {
+    const run = this.byId.get(runId);
+    if (!run || !canCancel(run)) return false;
+    this.host.emit("action", { runId, action: "cancel", ...targetOf(step) });
+    return true;
+  }
+  /** Ask the host to retry a run. */
+  retry(runId, step) {
+    const run = this.byId.get(runId);
+    if (!run || !canRetry(run)) return false;
+    this.host.emit("action", { runId, action: "retry", ...targetOf(step) });
+    return true;
+  }
+  /**
+   * Clear TERMINAL runs from the view.
+   *
+   * Only terminal ones: clearing a running download would remove the row while the transfer
+   * continues, and the user would have no way back to it.
+   *
+   * @returns How many were removed.
+   */
+  clearTerminal() {
+    let removed = 0;
+    for (const [id, run] of [...this.byId]) {
+      if (isTerminal(run.status)) {
+        this.byId.delete(id);
+        removed += 1;
+      }
+    }
+    if (removed > 0) {
+      this.order = this.order.filter((id) => this.byId.has(id));
+      this.host.emit("action", { runId: "", action: "clear" });
+      this.flush();
+    }
+    return removed;
+  }
+  /** A run was opened — the reveal hook. */
+  activate(runId, step) {
+    const run = this.byId.get(runId);
+    if (!run) return false;
+    this.host.emit("runActivate", {
+      runId,
+      source: run.source,
+      ...targetOf(step)
+    });
+    return true;
+  }
+  /**
+   * Expand or collapse a run, or one step inside it.
+   *
+   * @param runId - The run.
+   * @param stepPath - Address of a step within it. Absent ⇒ the run's own row.
+   * @returns `true` when the target existed and its state flipped.
+   *
+   * ⚠️ The key for a run is its bare id, so a `RunsPanelState` written before step expansion
+   * existed restores unchanged — those stored strings ARE the encoded run-level paths.
+   *
+   * 🔴 A step path is resolved before it is stored. An address that names nothing would otherwise
+   * accumulate in a set that is serialized, so a host with a churning step tree would grow its
+   * persisted state without bound and never be able to tell which entries still meant anything.
+   */
+  toggleExpanded(runId, stepPath) {
+    const run = this.byId.get(runId);
+    if (!run) return false;
+    if (stepPath && stepPath.length > 0 && !resolveStepPath(run.steps, stepPath)) return false;
+    const key = encodeRunPath([runId, ...stepPath ?? []]);
+    if (this.expanded.has(key)) this.expanded.delete(key);
+    else this.expanded.add(key);
+    this.flush();
+    return true;
+  }
+  /** Ask the host to open a context menu. */
+  requestContextMenu(runId, x, y) {
+    this.host.emit("contextMenuRequest", { runId, x, y });
+  }
+  /* ── Persistence ───────────────────────────────────────────────────────── */
+  /** Serialize. Filter and expansion — **never the runs**; an execution log is not a document. */
+  serialize() {
+    return { filter: this.filter, expanded: [...this.expanded] };
+  }
+  /** Restore. Does not emit. */
+  deserialize(state) {
+    if (state.filter) this.filter = state.filter;
+    if (state.expanded) this.expanded = new Set(state.expanded);
+    this.flush();
+  }
+  /** Drop listeners, timers and the buffer. */
+  dispose() {
+    this.notifyThrottled.cancel();
+    this.listeners.clear();
+    this.byId.clear();
+    this.order = [];
+  }
+};
+function normalizePath(path) {
+  if (path === void 0 || path === null) return [];
+  if (!Array.isArray(path)) return null;
+  return path.every((id) => typeof id === "string") ? path : null;
+}
+function targetOf(step) {
+  if (step === void 0) return {};
+  const path = typeof step === "string" ? [step] : [...step];
+  if (path.length === 0) return {};
+  return { stepId: path[path.length - 1], stepPath: path };
+}
+
+// src/ops/runs/manifest.ts
+var RUNS_PANEL_ID = "xeno.core.runs";
+var runsManifest = {
+  id: RUNS_PANEL_ID,
+  // 0.2.0: steps became a TREE, the status union widened, and a step became addressable in a
+  // delta. Every change is additive — a 0.1.0 host that sets none of it behaves identically.
+  version: "0.2.0",
+  title: "Runs",
+  icon: "play-circle",
+  description: "Ordered executions with lifecycle state, progress and per-item actions. Not an undo stack (that is history) and not document snapshots (that is versions).",
+  defaultSlot: "bottom",
+  inputs: [
+    {
+      id: "runs",
+      name: "Runs",
+      type: "object",
+      description: "A delta: {rev?, append?, patch?, appendSteps?, patchSteps?, remove?, replace?, clear?, source?}. `patch` addresses runs BY ID and `patchSteps` addresses one step by PATH ({runId, path: string[], patch}) \u2014 re-pushing the whole list per progress tick, or a run\u2019s whole `steps` array per step tick, is the failure mode this exists to avoid.",
+      // Fan-in: several producers (graph execution, downloads, generation queues) in one view.
+      multiple: true
+    },
+    {
+      id: "filter",
+      name: "Filter",
+      type: "object",
+      description: "An externally set filter {statuses?, mutedSources?, search?}.",
+      multiple: false
+    }
+  ],
+  outputs: [
+    {
+      id: "action",
+      name: "Action",
+      type: "object",
+      description: "{runId, action: cancel|retry|clear, stepId?, stepPath?} \u2014 an INTENT. The panel never executes or cancels anything, and never optimistically flips a status. `stepId` is the last element of `stepPath`; a nested step needs the path, because one step id may occur under several parents."
+    },
+    {
+      id: "runActivate",
+      name: "Run Activated",
+      type: "object",
+      description: "{runId, source?, stepId?, stepPath?} \u2014 a run or one of its steps was opened, so the host can reveal the node, panel or file behind it."
+    },
+    {
+      id: "contextMenuRequest",
+      name: "Context Menu Request",
+      type: "object",
+      description: "The host opens its own menu."
+    }
+  ],
+  commands: [
+    { id: "get_runs", title: "Get Runs", description: "Return every held run, newest first.", parameters: {} },
+    {
+      id: "get_stats",
+      title: "Get Stats",
+      description: "Aggregates. successRate is computed over TERMINAL runs only, and is null when none have finished.",
+      parameters: {}
+    },
+    {
+      id: "filter_runs",
+      title: "Filter",
+      description: "Set the search term.",
+      parameters: { search: { type: "string", description: "Substring over label/source/trigger/error code" } }
+    },
+    {
+      id: "set_statuses",
+      title: "Set Statuses",
+      description: 'Show only these statuses. A dead-letter view is ["failed"] \u2014 not a separate panel.',
+      parameters: { statuses: { type: "array", description: "XenoRunStatus[]; empty shows all", required: true } }
+    },
+    {
+      id: "cancel_run",
+      title: "Cancel Run",
+      description: "Ask the host to cancel. Refused for a terminal run.",
+      parameters: {
+        runId: { type: "string", description: "Run id", required: true },
+        stepId: { type: "string", description: "Target one TOP-LEVEL step. Ambiguous once steps nest \u2014 use stepPath." },
+        stepPath: { type: "array", description: "Step ids from the run down to the target. Wins over stepId when both are given." }
+      }
+    },
+    {
+      id: "retry_run",
+      title: "Retry Run",
+      description: "Ask the host to retry. Refused when the error says it is not retryable.",
+      parameters: {
+        runId: { type: "string", description: "Run id", required: true },
+        stepId: { type: "string", description: "Target one TOP-LEVEL step. Ambiguous once steps nest \u2014 use stepPath." },
+        stepPath: { type: "array", description: "Step ids from the run down to the target. Wins over stepId when both are given." }
+      }
+    },
+    {
+      id: "clear_finished",
+      title: "Clear Finished",
+      description: "Remove TERMINAL runs from the view. Never removes a running one \u2014 the work would continue with no row.",
+      parameters: {}
+    },
+    {
+      id: "reveal_run",
+      title: "Reveal Run",
+      description: "Emit runActivate so the host can reveal the origin.",
+      parameters: { runId: { type: "string", description: "Run id", required: true } }
+    }
+  ],
+  config: [
+    {
+      key: "maxRuns",
+      label: "Buffer size",
+      type: "number",
+      defaultValue: 500,
+      description: "Ring capacity; the oldest are dropped. Recent activity, not an archive.",
+      placeholder: "500"
+    },
+    {
+      key: "throttleMs",
+      label: "Update throttle",
+      type: "number",
+      defaultValue: 100,
+      description: "Minimum ms between re-projections. Twenty rows patching at 60 Hz is 1 200 re-filters a second without it.",
+      placeholder: "100"
+    },
+    {
+      key: "maxDepth",
+      label: "Nesting depth",
+      type: "number",
+      defaultValue: 32,
+      description: "How deep below a run the step tree is rendered. A cut subtree is marked as cut, never silently shown as a leaf.",
+      placeholder: "32"
+    },
+    {
+      key: "rowHeight",
+      label: "Row height",
+      type: "number",
+      defaultValue: 24,
+      description: "Fixed \u2014 what keeps virtualization O(1).",
+      placeholder: "24"
+    },
+    {
+      key: "showStats",
+      label: "Show summary",
+      type: "boolean",
+      defaultValue: true,
+      description: "Render the success-rate and mean-duration strip."
+    },
+    {
+      key: "showProgress",
+      label: "Show progress bars",
+      type: "boolean",
+      defaultValue: true,
+      description: "Render a bar for runs that report progress."
+    },
+    {
+      key: "defaultStatuses",
+      label: "Opening filter",
+      type: "json",
+      description: 'Statuses shown on mount. ["failed"] makes this a dead-letter queue.',
+      placeholder: '["failed"]'
+    },
+    {
+      key: "emptyHint",
+      label: "Empty hint",
+      type: "text",
+      description: "Say what would produce a run, not that there are none.",
+      placeholder: "Run the workflow to see its executions here."
+    }
+  ],
+  capabilities: ["storage.local"],
+  sdk: "^1.1.0"
+};
+
+// src/ops/runs/react/RunsPanelView.tsx
+import { useSyncExternalStore as useSyncExternalStore2 } from "react";
+import {
+  Badge as Badge2,
+  EmptyState as EmptyState2,
+  IconButton as IconButton2,
+  ProportionBar,
+  Row as Row2,
+  RowList as RowList2,
+  ScrollArea as ScrollArea2,
+  SearchField as SearchField2,
+  StatusBar as StatusBar2,
+  TextButton,
+  Toolbar as Toolbar2,
+  ToolbarGroup as ToolbarGroup2
+} from "@xenosystem/workbench/primitives/react";
+
+// src/ops/runs/react/icons.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function Svg2({ children }) {
+  return /* @__PURE__ */ jsx3(
+    "svg",
+    {
+      width: 11,
+      height: 11,
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "1.5",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      "aria-hidden": "true",
+      children
+    }
+  );
+}
+function CancelGlyph() {
+  return /* @__PURE__ */ jsx3(Svg2, { children: /* @__PURE__ */ jsx3("rect", { x: "5", y: "5", width: "14", height: "14", rx: "2" }) });
+}
+function RetryGlyph() {
+  return /* @__PURE__ */ jsxs3(Svg2, { children: [
+    /* @__PURE__ */ jsx3("path", { d: "M21 12a9 9 0 1 1-3.36-7" }),
+    /* @__PURE__ */ jsx3("path", { d: "M21 3v6h-6" })
+  ] });
+}
+
+// src/ops/runs/react/RunsPanelView.tsx
+import { Fragment as Fragment2, jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var TONE2 = {
+  requested: "neutral",
+  queued: "neutral",
+  running: "info",
+  paused: "warning",
+  blocked: "warning",
+  "awaiting-decision": "warning",
+  "awaiting-permission": "warning",
+  succeeded: "success",
+  failed: "error",
+  cancelled: "neutral"
+};
+function toneOf(status) {
+  return TONE2[status] ?? "neutral";
+}
+function RunsPanelView({
+  controller,
+  showStats = true,
+  showProgress = true,
+  emptyHint,
+  now = () => Date.now()
+}) {
+  const state = useSyncExternalStore2(controller.subscribe, controller.getState, controller.getState);
+  const active = new Set(state.filter.statuses ?? []);
+  return /* @__PURE__ */ jsxs4("div", { style: { display: "flex", flexDirection: "column", height: "100%", minHeight: 0 }, children: [
+    /* @__PURE__ */ jsx4(
+      Toolbar2,
+      {
+        left: /* @__PURE__ */ jsx4(
+          SearchField2,
+          {
+            value: state.filter.search ?? "",
+            onChange: (term) => controller.setSearch(term),
+            placeholder: "Filter runs\u2026"
+          }
+        ),
+        right: /* @__PURE__ */ jsx4(ToolbarGroup2, { end: true, children: /* @__PURE__ */ jsx4(TextButton, { onClick: () => controller.clearTerminal(), children: "Clear finished" }) })
+      }
+    ),
+    /* @__PURE__ */ jsxs4("div", { style: { display: "flex", gap: 4, padding: "2px 6px", flexWrap: "wrap" }, children: [
+      ALL_STATUSES.filter((s) => state.counts[s] > 0).map((status) => /* @__PURE__ */ jsx4(
+        "span",
+        {
+          onClick: () => controller.setStatuses(
+            active.has(status) ? [...active].filter((s) => s !== status) : [...active, status]
+          ),
+          style: { cursor: "pointer", opacity: active.size === 0 || active.has(status) ? 1 : 0.4 },
+          children: /* @__PURE__ */ jsx4(Badge2, { tone: TONE2[status], children: `${status} ${state.counts[status]}` })
+        },
+        status
+      )),
+      state.sources.length > 1 ? state.sources.map((source) => /* @__PURE__ */ jsx4(
+        "span",
+        {
+          onClick: () => controller.toggleSource(source.id),
+          style: { cursor: "pointer", opacity: source.enabled ? 1 : 0.4 },
+          children: /* @__PURE__ */ jsx4(Badge2, { title: `${source.count} runs`, children: source.label })
+        },
+        source.id
+      )) : null
+    ] }),
+    state.rows.length === 0 ? /* @__PURE__ */ jsx4(
+      EmptyState2,
+      {
+        title: state.total > 0 ? "No matching runs" : "No runs yet",
+        hint: state.total > 0 ? "Nothing matches the current filter." : emptyHint ?? "Run something to see it here."
+      }
+    ) : /* @__PURE__ */ jsx4(ScrollArea2, { children: /* @__PURE__ */ jsx4(RowList2, { role: "list", children: state.rows.map(
+      (row) => row.kind === "run" ? /* @__PURE__ */ jsx4(RunRow, { row, controller, showProgress, now }, row.key) : /* @__PURE__ */ jsx4(StepRow, { row, controller, showProgress }, row.key)
+    ) }) }),
+    /* @__PURE__ */ jsx4(
+      StatusBar2,
+      {
+        left: `${state.runs.length} of ${state.total}${state.dropped > 0 ? ` \xB7 ${state.dropped} dropped` : ""}`,
+        right: showStats && state.stats.terminal > 0 ? `${Math.round((state.stats.successRate ?? 0) * 100)}% ok${state.stats.meanDurationMs !== null ? ` \xB7 ~${formatDuration(state.stats.meanDurationMs)}` : ""}` : (
+          // `null` success rate is NOT 0% — nothing has finished, which is a different fact.
+          state.stats.active > 0 ? `${state.stats.active} active` : void 0
+        )
+      }
+    )
+  ] });
+}
+function TruncationBadge({ reason }) {
+  return /* @__PURE__ */ jsx4(
+    Badge2,
+    {
+      tone: "warning",
+      title: reason === "cycle" ? "This step is nested inside itself \u2014 the panel stopped here rather than repeat it." : "Nesting is deeper than this panel will render.",
+      children: reason === "cycle" ? "cycle" : "deeper\u2026"
+    }
+  );
+}
+function RowLabel({
+  status,
+  text,
+  trailing
+}) {
+  return /* @__PURE__ */ jsxs4("span", { style: { display: "flex", gap: 6, alignItems: "center", minWidth: 0 }, children: [
+    /* @__PURE__ */ jsx4(Badge2, { tone: toneOf(status), children: status }),
+    /* @__PURE__ */ jsx4("span", { style: { overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" }, children: text }),
+    trailing
+  ] });
+}
+function RunRow({
+  row,
+  controller,
+  showProgress,
+  now
+}) {
+  const run = row.run;
+  const duration = durationOf(run, now());
+  return /* @__PURE__ */ jsxs4(Fragment2, { children: [
+    /* @__PURE__ */ jsx4(
+      Row2,
+      {
+        noIcon: true,
+        onClick: () => {
+          if (row.hasChildren) controller.toggleExpanded(run.id);
+          controller.activate(run.id);
+        },
+        onContextMenu: (e) => {
+          e.preventDefault();
+          controller.requestContextMenu(run.id, e.clientX, e.clientY);
+        },
+        label: /* @__PURE__ */ jsx4(
+          RowLabel,
+          {
+            status: run.status,
+            text: run.label,
+            trailing: /* @__PURE__ */ jsxs4(Fragment2, { children: [
+              run.trigger ? /* @__PURE__ */ jsx4("span", { style: { opacity: 0.5, fontSize: 9 }, children: run.trigger }) : null,
+              (run.retryCount ?? 0) > 0 ? /* @__PURE__ */ jsx4(Badge2, { title: "Retries so far", children: `retry x${run.retryCount}` }) : null,
+              row.truncated ? /* @__PURE__ */ jsx4(TruncationBadge, { reason: row.truncated }) : null
+            ] })
+          }
+        ),
+        meta: showProgress && run.progress !== void 0 ? /* @__PURE__ */ jsx4("span", { style: { width: 48, display: "inline-flex" }, children: /* @__PURE__ */ jsx4(
+          ProportionBar,
+          {
+            label: `${Math.round(run.progress * 100)}%`,
+            segments: [
+              { value: run.progress, opacity: 0.45 },
+              { value: Math.max(0, 1 - run.progress), opacity: 0.06 }
+            ]
+          }
+        ) }) : duration !== null ? /* @__PURE__ */ jsx4("span", { style: { fontVariantNumeric: "tabular-nums", opacity: 0.6 }, children: formatDuration(duration) }) : null,
+        trailing: /* @__PURE__ */ jsxs4(Fragment2, { children: [
+          canCancel(run) ? /* @__PURE__ */ jsx4(
+            IconButton2,
+            {
+              size: "sm",
+              icon: /* @__PURE__ */ jsx4(CancelGlyph, {}),
+              label: `Cancel ${run.label}`,
+              onClick: () => controller.cancel(run.id)
+            }
+          ) : null,
+          canRetry(run) ? /* @__PURE__ */ jsx4(
+            IconButton2,
+            {
+              size: "sm",
+              icon: /* @__PURE__ */ jsx4(RetryGlyph, {}),
+              label: `Retry ${run.label}`,
+              onClick: () => controller.retry(run.id)
+            }
+          ) : null
+        ] })
+      }
+    ),
+    run.error ? /* @__PURE__ */ jsxs4("div", { style: { padding: "0 10px 3px 24px", fontSize: 10, opacity: 0.75 }, children: [
+      /* @__PURE__ */ jsx4(Badge2, { tone: "error", children: run.error.code }),
+      " ",
+      run.error.message
+    ] }) : null
+  ] });
+}
+function StepRow({
+  row,
+  controller,
+  showProgress
+}) {
+  const step = row.step;
+  const elapsed = step.startedAt !== void 0 && step.endedAt !== void 0 ? step.endedAt - step.startedAt : null;
+  return /* @__PURE__ */ jsx4(
+    Row2,
+    {
+      noIcon: true,
+      style: { paddingLeft: 12 + row.depth * 12, opacity: 0.85 },
+      onClick: () => {
+        if (row.hasChildren) controller.toggleExpanded(row.runId, row.stepPath);
+        controller.activate(row.runId, row.stepPath);
+      },
+      label: /* @__PURE__ */ jsx4(
+        RowLabel,
+        {
+          status: step.status,
+          text: step.label,
+          trailing: row.truncated ? /* @__PURE__ */ jsx4(TruncationBadge, { reason: row.truncated }) : null
+        }
+      ),
+      meta: showProgress && step.progress !== void 0 ? /* @__PURE__ */ jsx4("span", { style: { width: 48, display: "inline-flex" }, children: /* @__PURE__ */ jsx4(
+        ProportionBar,
+        {
+          label: `${Math.round(step.progress * 100)}%`,
+          segments: [
+            { value: step.progress, opacity: 0.45 },
+            { value: Math.max(0, 1 - step.progress), opacity: 0.06 }
+          ]
+        }
+      ) }) : elapsed !== null ? /* @__PURE__ */ jsx4("span", { style: { fontVariantNumeric: "tabular-nums", opacity: 0.6 }, children: formatDuration(elapsed) }) : null
+    }
+  );
+}
+
+// src/ops/runs/panel.ts
+function createRunsPanel(options = {}) {
+  return {
+    manifest: runsManifest,
+    activate(host) {
+      const config = host.config ?? {};
+      const defaultStatuses = parseJson(config.defaultStatuses);
+      const controller = new RunsController({
+        host: { emit: (portId, value) => host.emit(portId, value) },
+        maxRuns: numberConfig2(config.maxRuns, 500),
+        throttleMs: numberConfig2(config.throttleMs, 100, true),
+        maxDepth: numberConfig2(config.maxDepth, 32),
+        initial: { filter: defaultStatuses ? { statuses: defaultStatuses } : {}, expanded: [] }
+      });
+      const resolve = (config2) => ({
+        showStats: config2.showStats !== false,
+        showProgress: config2.showProgress !== false,
+        rowHeight: numberConfig2(config2.rowHeight, 24),
+        emptyHint: typeof config2.emptyHint === "string" ? config2.emptyHint : void 0
+      });
+      let renderConfig = resolve(host.config ?? {});
+      let unrender = null;
+      let root = null;
+      let currentEl = null;
+      const draw = (el) => {
+        unrender?.();
+        if (options.render) {
+          unrender = options.render(el, { controller, config: renderConfig });
+          return;
+        }
+        root = createRoot2(el);
+        root.render(
+          createElement2(RunsPanelView, {
+            controller,
+            showStats: renderConfig.showStats,
+            showProgress: renderConfig.showProgress,
+            emptyHint: renderConfig.emptyHint
+          })
+        );
+        unrender = () => {
+          root?.unmount();
+          root = null;
+        };
+      };
+      const unbindConfig = bindConfig2(host, (config2) => {
+        renderConfig = resolve(config2);
+        if (currentEl) draw(currentEl);
+      });
+      return {
+        render(el) {
+          currentEl = el;
+          draw(el);
+        },
+        onInput(portId, value) {
+          if (portId === "runs") {
+            if (Array.isArray(value)) controller.apply({ append: value });
+            else if (isRecord2(value)) controller.apply(value);
+          } else if (portId === "filter") {
+            if (isRecord2(value)) controller.setFilter(value);
+          }
+        },
+        async onCommand(commandId, params) {
+          switch (commandId) {
+            case "get_runs":
+              controller.flushNow();
+              return controller.all();
+            case "get_stats":
+              controller.flushNow();
+              return controller.getState().stats;
+            case "filter_runs":
+              controller.setSearch(String(params.search ?? ""));
+              return true;
+            case "set_statuses":
+              controller.setStatuses(
+                Array.isArray(params.statuses) ? params.statuses : []
+              );
+              return true;
+            case "cancel_run":
+              return controller.cancel(String(params.runId), stepTarget(params));
+            case "retry_run":
+              return controller.retry(String(params.runId), stepTarget(params));
+            case "clear_finished":
+              return controller.clearTerminal();
+            case "reveal_run":
+              return controller.activate(String(params.runId));
+            default:
+              return;
+          }
+        },
+        serialize() {
+          return controller.serialize();
+        },
+        deserialize(state) {
+          controller.deserialize(state ?? {});
+        },
+        dispose() {
+          unbindConfig();
+          currentEl = null;
+          unrender?.();
+          unrender = null;
+          controller.dispose();
+        }
+      };
+    }
+  };
+}
+function stepTarget(params) {
+  if (Array.isArray(params.stepPath)) {
+    const path = params.stepPath.filter((s) => typeof s === "string");
+    if (path.length > 0) return path;
+  }
+  return typeof params.stepId === "string" ? params.stepId : void 0;
+}
+function parseJson(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return void 0;
+  }
+}
+function numberConfig2(value, fallback, allowZero = false) {
+  const n = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(n)) return fallback;
+  return allowZero ? Math.max(0, n) : n > 0 ? n : fallback;
+}
+var runsPanel = createRunsPanel();
+
+// src/ops/terminal/panel.ts
+import { createElement as createElement3 } from "react";
+import { createRoot as createRoot3 } from "react-dom/client";
+import {
+  bindConfig as bindConfig3
+} from "@xenosystem/panel-sdk";
+
+// src/ops/terminal/controller.ts
+var counter = 0;
+var defaultMakeId = () => `term-${Date.now().toString(36)}-${(counter++).toString(36)}`;
+var TerminalController = class {
+  host;
+  makeId;
+  stopOnClose;
+  scrollback;
+  instances = /* @__PURE__ */ new Map();
+  order = [];
+  activeId = null;
+  fontSize;
+  search = null;
+  listeners = /* @__PURE__ */ new Set();
+  snapshot = null;
+  constructor(options) {
+    this.host = options.host;
+    this.makeId = options.host.makeId ?? defaultMakeId;
+    this.scrollback = options.scrollback ?? 5e3;
+    this.fontSize = options.fontSize ?? 12;
+    this.stopOnClose = options.stopOnClose !== false;
+  }
+  /* ── Subscription ──────────────────────────────────────────────────────── */
+  subscribe = (listener) => {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  };
+  getState = () => {
+    if (!this.snapshot) {
+      const instances = this.order.map((id) => this.instances.get(id)).filter((i) => Boolean(i)).map((i) => ({
+        session: i.session,
+        active: i.session.id === this.activeId,
+        cols: i.cols,
+        rows: i.rows
+      }));
+      this.snapshot = {
+        instances,
+        activeId: this.activeId,
+        fontSize: this.fontSize,
+        search: this.search
+      };
+    }
+    return this.snapshot;
+  };
+  notify() {
+    this.snapshot = null;
+    for (const listener of this.listeners) listener();
+  }
+  emit(intent) {
+    this.host.emit("intent", intent);
+  }
+  /* ── Instances ─────────────────────────────────────────────────────────── */
+  /**
+   * Open a terminal instance.
+   *
+   * **No `start` intent is emitted here.** The panel cannot say how big the terminal is until an
+   * emulator has attached and measured, and a PTY started at a guessed size renders its first
+   * screen wrong. `start` goes out from {@link attach}, once.
+   *
+   * @param id - An explicit id, or one is minted.
+   * @param session - Opening session fields.
+   * @returns The instance id.
+   */
+  open(id = this.makeId(), session = {}) {
+    if (this.instances.has(id)) return id;
+    this.instances.set(id, {
+      session: { id, status: "idle", ...session },
+      emulator: null,
+      cols: null,
+      rows: null,
+      pending: [],
+      started: false,
+      unsubscribers: []
+    });
+    this.order.push(id);
+    if (this.activeId === null) this.activeId = id;
+    this.notify();
+    return id;
+  }
+  /**
+   * Close an instance.
+   *
+   * @param id - The instance.
+   * @returns Whether it existed.
+   */
+  close(id) {
+    const instance = this.instances.get(id);
+    if (!instance) return false;
+    this.detach(id);
+    this.instances.delete(id);
+    this.order = this.order.filter((x) => x !== id);
+    if (this.activeId === id) this.activeId = this.order[this.order.length - 1] ?? null;
+    if (this.stopOnClose && instance.started) this.emit({ type: "stop", id });
+    this.notify();
+    return true;
+  }
+  /** Bring an instance to the front. */
+  setActive(id) {
+    if (id !== null && !this.instances.has(id)) return;
+    this.activeId = id;
+    this.notify();
+  }
+  /** Instance ids, in open order. */
+  ids() {
+    return [...this.order];
+  }
+  /* ── The emulator seam ─────────────────────────────────────────────────── */
+  /**
+   * Attach an emulator to an instance and wire it up.
+   *
+   * Emits `start` **only once a real grid has been measured** — the fix for a mistake both
+   * incumbents make in opposite directions (a fixed 80×24 guess, or a synchronous fit before
+   * layout settles).
+   *
+   * @param id - The instance.
+   * @param emulator - The emulator.
+   * @param element - Where it mounts.
+   * @returns A detach function.
+   */
+  attach(id, emulator, element) {
+    const instance = this.instances.get(id);
+    if (!instance) return () => {
+    };
+    this.detach(id);
+    instance.emulator = emulator;
+    emulator.open(element);
+    instance.unsubscribers.push(
+      // Raw pass-through, control characters included. A terminal that interpreted Ctrl+C itself
+      // would be a terminal that cannot interrupt anything.
+      emulator.onData((data) => {
+        if (isLive(instance.session.status)) this.emit({ type: "input", id, data });
+      }),
+      emulator.onResize((size) => {
+        instance.cols = size.cols;
+        instance.rows = size.rows;
+        if (instance.started) this.emit({ type: "resize", id, cols: size.cols, rows: size.rows });
+        this.notify();
+      })
+    );
+    for (const chunk of instance.pending) emulator.write(chunk);
+    instance.pending = [];
+    this.fit(id);
+    return () => this.detach(id);
+  }
+  /**
+   * Re-fit an instance, and start it if it has never been measured before.
+   *
+   * @param id - The instance.
+   * @returns The measured grid, or `null`.
+   */
+  fit(id) {
+    const instance = this.instances.get(id);
+    if (!instance?.emulator) return null;
+    const size = instance.emulator.fit();
+    if (!measuredSize(size)) return null;
+    instance.cols = size.cols;
+    instance.rows = size.rows;
+    if (!instance.started) {
+      instance.started = true;
+      instance.session = { ...instance.session, status: "starting" };
+      this.emit({ type: "start", id, cols: size.cols, rows: size.rows, cwd: instance.session.cwd });
+    } else {
+      this.emit({ type: "resize", id, cols: size.cols, rows: size.rows });
+    }
+    this.notify();
+    return size;
+  }
+  /**
+   * Detach an instance's emulator.
+   *
+   * **Never stops the session.** A panel can unmount because a tab was hidden, a layout changed,
+   * or React StrictMode double-invoked an effect; killing a shell for any of those would lose work
+   * the user did not ask to lose.
+   *
+   * @param id - The instance.
+   */
+  detach(id) {
+    const instance = this.instances.get(id);
+    if (!instance) return;
+    for (const off of instance.unsubscribers) off();
+    instance.unsubscribers = [];
+    instance.emulator?.dispose();
+    instance.emulator = null;
+  }
+  /** Ask the host to replay its buffer — the reattach path. */
+  requestSnapshot(id) {
+    if (!this.instances.has(id)) return false;
+    this.emit({ type: "snapshot", id });
+    return true;
+  }
+  /* ── Host-pushed state ─────────────────────────────────────────────────── */
+  /**
+   * Write host output into a terminal.
+   *
+   * @param payload - `{id, data}`.
+   * @returns Whether the instance exists.
+   */
+  write(payload) {
+    const instance = this.instances.get(payload.id);
+    if (!instance) return false;
+    if (instance.emulator) instance.emulator.write(payload.data);
+    else {
+      instance.pending.push(payload.data);
+      if (instance.pending.length > 512) instance.pending.splice(0, instance.pending.length - 512);
+    }
+    return true;
+  }
+  /**
+   * Update a session's host-reported state.
+   *
+   * The panel never sets `running` or `exited` itself — it asked, and it waits to be told.
+   *
+   * @param session - Fields to merge, keyed by `id`.
+   * @returns Whether the instance exists.
+   */
+  setSession(session) {
+    const instance = this.instances.get(session.id);
+    if (!instance) return false;
+    instance.session = { ...instance.session, ...session };
+    this.notify();
+    return true;
+  }
+  /** Replace a terminal's contents — used when a snapshot arrives. */
+  replace(id, data) {
+    const instance = this.instances.get(id);
+    if (!instance) return false;
+    instance.emulator?.clear();
+    instance.pending = [];
+    return this.write({ id, data });
+  }
+  /* ── View state ────────────────────────────────────────────────────────── */
+  /** Set the font size on every attached emulator. */
+  setFontSize(size) {
+    this.fontSize = Math.max(6, Math.min(32, size));
+    for (const [id, instance] of this.instances) {
+      instance.emulator?.setFontSize?.(this.fontSize);
+      this.fit(id);
+    }
+    this.notify();
+  }
+  /** Open, update, or close the find bar. */
+  setSearch(query) {
+    this.search = query;
+    this.notify();
+  }
+  /** Run a search in the active terminal. */
+  find(direction = "next") {
+    const instance = this.activeId ? this.instances.get(this.activeId) : null;
+    if (!instance?.emulator?.search || !this.search) return false;
+    return instance.emulator.search(this.search, direction);
+  }
+  /** The active instance's session, if any. */
+  active() {
+    return this.activeId ? this.instances.get(this.activeId)?.session ?? null : null;
+  }
+  /* ── Lifecycle ─────────────────────────────────────────────────────────── */
+  /**
+   * Serialize.
+   *
+   * Which tab was in front, and the font size. **Never the scrollback** — terminal output routinely
+   * contains tokens, connection strings and keys that a user pasted or a tool printed, and `.xapp`
+   * is a plain JSON file. `XENO AUTH - SPEC.md` L9 keeps secrets out of exactly this kind of store.
+   */
+  serialize() {
+    return { activeId: this.activeId, fontSize: this.fontSize };
+  }
+  /** Restore view preferences. Sessions are not restored — the host re-declares them. */
+  deserialize(state) {
+    if (!state || typeof state !== "object") return;
+    const s = state;
+    if (typeof s.fontSize === "number") this.fontSize = s.fontSize;
+    if (typeof s.activeId === "string" || s.activeId === null) this.activeId = s.activeId ?? null;
+    this.notify();
+  }
+  /**
+   * Tear down.
+   *
+   * Detaches every emulator and **stops nothing**. Sessions outlive the panel by design; the host
+   * decides when a process dies.
+   */
+  dispose() {
+    for (const id of [...this.instances.keys()]) this.detach(id);
+    this.instances.clear();
+    this.order = [];
+    this.activeId = null;
+    this.listeners.clear();
+  }
+};
+
+// src/ops/terminal/manifest.ts
+import { WELL_KNOWN_PORT_SCHEMAS } from "@xenosystem/panel-sdk";
+var TERMINAL_PANEL_ID = "xeno.core.terminal";
+var terminalManifest = {
+  id: TERMINAL_PANEL_ID,
+  version: "0.1.0",
+  title: "Terminal",
+  icon: "square-terminal",
+  description: "The emulator surface: xterm instance, fit-to-PTY sizing, canonical theme, selection, search and scrollback. The host owns the PTY \u2014 the panel never spawns a process.",
+  defaultSlot: "bottom",
+  inputs: [
+    {
+      id: "data",
+      name: "Data",
+      type: "object",
+      schema: WELL_KNOWN_PORT_SCHEMAS.TERMINAL_DATA,
+      description: "{id, data} \u2014 raw output for one instance, escape sequences intact. Never pre-parsed; the emulator is the parser.",
+      multiple: true
+    },
+    {
+      id: "session",
+      name: "Session",
+      type: "object",
+      description: "{id, status, cwd?, exitCode?, pty?, message?}. The host is authoritative \u2014 the panel never sets `running` or `exited` itself.",
+      multiple: true
+    },
+    {
+      id: "snapshot",
+      name: "Snapshot",
+      type: "object",
+      description: "{id, data} \u2014 a full buffer replay, for reattaching to a session that outlived the panel.",
+      multiple: false
+    }
+  ],
+  outputs: [
+    {
+      id: "intent",
+      name: "Intent",
+      type: "object",
+      schema: WELL_KNOWN_PORT_SCHEMAS.TERMINAL_INTENT,
+      description: "start | input | resize | stop | snapshot, always addressed by instance id. `start` carries a MEASURED grid \u2014 the panel does not ask until it can say how big the terminal is."
+    }
+  ],
+  commands: [
+    {
+      id: "get_sessions",
+      title: "Get Sessions",
+      description: "Return every instance with its status and grid. No output text \u2014 see the note on scrollback in the doc pack.",
+      parameters: {}
+    },
+    {
+      id: "open",
+      title: "Open Terminal",
+      description: "Open a new instance. Starting is still gated on a real measurement.",
+      parameters: { cwd: { type: "string", description: "Working directory" } }
+    },
+    {
+      id: "close",
+      title: "Close Terminal",
+      description: "Close an instance, and ask the host to stop it.",
+      parameters: { id: { type: "string", description: "Instance id", required: true } }
+    },
+    {
+      id: "set_active",
+      title: "Set Active",
+      description: "Bring an instance to the front.",
+      parameters: { id: { type: "string", description: "Instance id", required: true } }
+    },
+    {
+      id: "find",
+      title: "Find",
+      description: "Search the active terminal\u2019s scrollback.",
+      parameters: {
+        query: { type: "string", description: "Text to find", required: true },
+        direction: { type: "string", description: "next | previous" }
+      }
+    }
+    // NOTE: there is deliberately no `input` command. An agent that could write to a terminal
+    // could run any command the shell can run, with the user's credentials, without ever passing
+    // a tool-approval check — the panel would become a hole straight through the agent's own
+    // permission model. Agents drive shells through the agent SDK's tool surface, which is
+    // approvable; this panel is where a HUMAN types.
+  ],
+  config: [
+    {
+      key: "scrollback",
+      label: "Scrollback lines",
+      type: "number",
+      defaultValue: 5e3,
+      description: "Lines the emulator retains."
+    },
+    {
+      key: "fontSize",
+      label: "Font size",
+      type: "number",
+      defaultValue: 12,
+      description: "Terminal font size in px."
+    },
+    {
+      key: "stopOnClose",
+      label: "Stop on close",
+      type: "boolean",
+      defaultValue: true,
+      description: "Ask the host to end a session when its tab is closed. Closing a tab is explicit; unmounting is not, and never stops anything."
+    },
+    {
+      key: "multiInstance",
+      label: "Multiple terminals",
+      type: "boolean",
+      defaultValue: true,
+      description: "Show the tab strip. Both existing implementations need more than one terminal."
+    }
+  ],
+  capabilities: ["storage.local"],
+  sdk: "^1.1.0"
+};
+
+// src/ops/terminal/react/TerminalPanelView.tsx
+import { useEffect as useEffect2, useRef as useRef2, useSyncExternalStore as useSyncExternalStore3 } from "react";
+import {
+  Badge as Badge3,
+  EmptyState as EmptyState3,
+  IconButton as IconButton3,
+  SearchField as SearchField3,
+  StatusBar as StatusBar3,
+  TextButton as TextButton2,
+  Toolbar as Toolbar3,
+  ToolbarGroup as ToolbarGroup3
+} from "@xenosystem/workbench/primitives/react";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function CloseIcon() {
+  return /* @__PURE__ */ jsx5("svg", { width: "10", height: "10", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "1.5", children: /* @__PURE__ */ jsx5("path", { d: "M18 6 6 18M6 6l12 12" }) });
+}
+function PlusIcon() {
+  return /* @__PURE__ */ jsx5("svg", { width: "10", height: "10", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "1.5", children: /* @__PURE__ */ jsx5("path", { d: "M12 5v14M5 12h14" }) });
+}
+function TerminalSurface({
+  id,
+  controller,
+  createEmulator,
+  visible: visible2
+}) {
+  const ref = useRef2(null);
+  useEffect2(() => {
+    const element = ref.current;
+    if (!element) return;
+    let detach = null;
+    let cancelled = false;
+    void createEmulator().then((emulator) => {
+      if (cancelled) {
+        emulator.dispose();
+        return;
+      }
+      detach = controller.attach(id, emulator, element);
+    });
+    const observer = typeof ResizeObserver !== "undefined" ? new ResizeObserver(() => controller.fit(id)) : null;
+    if (observer) observer.observe(element);
+    return () => {
+      cancelled = true;
+      observer?.disconnect();
+      detach?.();
+    };
+  }, [id, controller, createEmulator]);
+  useEffect2(() => {
+    if (visible2) controller.fit(id);
+  }, [visible2, id, controller]);
+  return /* @__PURE__ */ jsx5(
+    "div",
+    {
+      ref,
+      "data-terminal": id,
+      style: {
+        // Hidden, not unmounted: unmounting would dispose the emulator and lose the on-screen
+        // buffer every time the user glanced at another tab.
+        display: visible2 ? "block" : "none",
+        position: "absolute",
+        inset: 0
+      }
+    }
+  );
+}
+function TerminalPanelView({
+  controller,
+  createEmulator,
+  multiInstance = true
+}) {
+  const state = useSyncExternalStore3(controller.subscribe, controller.getState, controller.getState);
+  const active = state.instances.find((i) => i.active);
+  if (!createEmulator) {
+    return /* @__PURE__ */ jsx5(
+      EmptyState3,
+      {
+        title: "No emulator configured",
+        hint: "Pass `createEmulator` (or use `createXtermEmulator`) so the panel has something to render into."
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs5("div", { style: { display: "flex", flexDirection: "column", height: "100%", minHeight: 0 }, children: [
+    multiInstance ? /* @__PURE__ */ jsx5(
+      Toolbar3,
+      {
+        left: /* @__PURE__ */ jsx5("div", { style: { display: "flex", gap: 2, alignItems: "center", overflowX: "auto" }, children: state.instances.map((instance) => {
+          const label = statusLabel(instance.session);
+          return /* @__PURE__ */ jsxs5(
+            "div",
+            {
+              style: { display: "flex", alignItems: "center", gap: 2 },
+              children: [
+                /* @__PURE__ */ jsx5(
+                  TextButton2,
+                  {
+                    strong: instance.active,
+                    onClick: () => controller.setActive(instance.session.id),
+                    children: instance.session.title ?? instance.session.id.slice(0, 8)
+                  }
+                ),
+                label ? /* @__PURE__ */ jsx5(Badge3, { tone: instance.session.status === "failed" ? "error" : "neutral", children: label }) : null,
+                /* @__PURE__ */ jsx5(
+                  IconButton3,
+                  {
+                    label: "Close terminal",
+                    size: "sm",
+                    icon: /* @__PURE__ */ jsx5(CloseIcon, {}),
+                    onClick: () => controller.close(instance.session.id)
+                  }
+                )
+              ]
+            },
+            instance.session.id
+          );
+        }) }),
+        right: /* @__PURE__ */ jsxs5(ToolbarGroup3, { end: true, children: [
+          /* @__PURE__ */ jsx5(IconButton3, { label: "New terminal", icon: /* @__PURE__ */ jsx5(PlusIcon, {}), onClick: () => controller.open() }),
+          /* @__PURE__ */ jsx5(TextButton2, { onClick: () => controller.setSearch(state.search === null ? "" : null), children: "Find" })
+        ] })
+      }
+    ) : null,
+    state.search !== null ? /* @__PURE__ */ jsx5(
+      Toolbar3,
+      {
+        left: /* @__PURE__ */ jsx5(
+          SearchField3,
+          {
+            value: state.search,
+            onChange: (value) => controller.setSearch(value),
+            placeholder: "Find in terminal",
+            autoFocus: true
+          }
+        ),
+        right: /* @__PURE__ */ jsxs5(ToolbarGroup3, { end: true, children: [
+          /* @__PURE__ */ jsx5(TextButton2, { onClick: () => controller.find("previous"), children: "Previous" }),
+          /* @__PURE__ */ jsx5(TextButton2, { onClick: () => controller.find("next"), children: "Next" })
+        ] })
+      }
+    ) : null,
+    /* @__PURE__ */ jsx5("div", { style: { position: "relative", flex: 1, minHeight: 0 }, children: state.instances.length === 0 ? /* @__PURE__ */ jsx5(EmptyState3, { title: "No terminal", hint: "Open one to get a shell." }) : state.instances.map((instance) => /* @__PURE__ */ jsx5(
+      TerminalSurface,
+      {
+        id: instance.session.id,
+        controller,
+        createEmulator,
+        visible: instance.active
+      },
+      instance.session.id
+    )) }),
+    /* @__PURE__ */ jsx5(
+      StatusBar3,
+      {
+        left: active?.session.cwd,
+        right: active && active.cols ? `${active.cols}\xD7${active.rows}` : void 0
+      }
+    )
+  ] });
+}
+
+// src/ops/terminal/panel.ts
+function createTerminalPanel(options = {}) {
+  return {
+    manifest: terminalManifest,
+    activate(host) {
+      const config = host.config ?? {};
+      const controller = new TerminalController({
+        host: { emit: (portId, value) => host.emit(portId, value) },
+        scrollback: typeof config.scrollback === "number" ? config.scrollback : void 0,
+        fontSize: typeof config.fontSize === "number" ? config.fontSize : void 0,
+        stopOnClose: config.stopOnClose !== false
+      });
+      const resolve = (config2) => ({
+        multiInstance: config2.multiInstance !== false
+      });
+      let renderConfig = resolve(host.config ?? {});
+      const createEmulator = options.createEmulator ?? (async () => {
+        const { createXtermEmulator } = await import("../xterm-R3GIKSHA.js");
+        return createXtermEmulator({
+          fontSize: controller.getState().fontSize,
+          scrollback: controller.scrollback
+        });
+      });
+      let unrender = null;
+      let root = null;
+      let currentEl = null;
+      const draw = (el) => {
+        unrender?.();
+        if (options.render) {
+          unrender = options.render(el, { controller, config: renderConfig });
+          return;
+        }
+        root = createRoot3(el);
+        root.render(
+          createElement3(TerminalPanelView, { controller, createEmulator, ...renderConfig })
+        );
+        unrender = () => {
+          root?.unmount();
+          root = null;
+        };
+      };
+      const unbindConfig = bindConfig3(host, (config2) => {
+        renderConfig = resolve(config2);
+        if (currentEl) draw(currentEl);
+      });
+      return {
+        render(el) {
+          currentEl = el;
+          draw(el);
+        },
+        onInput(portId, value) {
+          if (portId === "data") {
+            const payload = value;
+            if (payload?.id && typeof payload.data === "string") controller.write(payload);
+          } else if (portId === "session") {
+            const payload = value;
+            if (typeof payload?.id === "string") {
+              controller.open(payload.id, payload);
+              controller.setSession(payload);
+            }
+          } else if (portId === "snapshot") {
+            const payload = value;
+            if (payload?.id && typeof payload.data === "string") {
+              controller.replace(payload.id, payload.data);
+            }
+          }
+        },
+        async onCommand(commandId, params) {
+          switch (commandId) {
+            case "get_sessions": {
+              const state = controller.getState();
+              return state.instances.map((i) => ({
+                id: i.session.id,
+                status: i.session.status,
+                title: i.session.title,
+                cwd: i.session.cwd,
+                cols: i.cols,
+                rows: i.rows
+              }));
+            }
+            case "open":
+              return controller.open(void 0, {
+                cwd: typeof params.cwd === "string" ? params.cwd : void 0
+              });
+            case "close":
+              return controller.close(String(params.id));
+            case "set_active":
+              controller.setActive(String(params.id));
+              return true;
+            case "find":
+              controller.setSearch(String(params.query ?? ""));
+              return controller.find(params.direction === "previous" ? "previous" : "next");
+            default:
+              return;
+          }
+        },
+        serialize() {
+          return controller.serialize();
+        },
+        deserialize(state) {
+          controller.deserialize(state);
+        },
+        dispose() {
+          unbindConfig();
+          currentEl = null;
+          unrender?.();
+          unrender = null;
+          controller.dispose();
+        }
+      };
+    }
+  };
+}
+var terminalPanel = createTerminalPanel();
+
+// src/ops/diff/panel.ts
+import { createElement as createElement4 } from "react";
+import { createRoot as createRoot4 } from "react-dom/client";
+import {
+  bindConfig as bindConfig4
+} from "@xenosystem/panel-sdk";
+
+// src/ops/diff/types.ts
+function isSettled(state) {
+  return state === "applied";
+}
+function needsAttention(state) {
+  return state === "conflict" || state === "failed";
+}
+function countChanges(file) {
+  if (file.additions !== void 0 && file.deletions !== void 0) {
+    return { additions: file.additions, deletions: file.deletions };
+  }
+  let additions = 0;
+  let deletions = 0;
+  for (const hunk of file.hunks) {
+    for (const line of hunk.lines) {
+      if (line.kind === "added") additions += 1;
+      else if (line.kind === "removed") deletions += 1;
+    }
+  }
+  return { additions, deletions };
+}
+function splitRows(hunk) {
+  const rows = [];
+  let index = 0;
+  while (index < hunk.lines.length) {
+    const line = hunk.lines[index];
+    if (line.kind === "context") {
+      rows.push({ left: line, right: line });
+      index += 1;
+      continue;
+    }
+    const removed = [];
+    const added = [];
+    while (index < hunk.lines.length && hunk.lines[index].kind !== "context") {
+      if (hunk.lines[index].kind === "removed") removed.push(hunk.lines[index]);
+      else added.push(hunk.lines[index]);
+      index += 1;
+    }
+    const height = Math.max(removed.length, added.length);
+    for (let i = 0; i < height; i += 1) {
+      rows.push({ left: removed[i] ?? null, right: added[i] ?? null });
+    }
+  }
+  return rows;
+}
+function flattenHunks(model) {
+  const out = [];
+  for (const file of model.files) {
+    for (const hunk of file.hunks) out.push({ path: file.path, hunkId: hunk.id });
+  }
+  return out;
+}
+function omissionLabel(omission) {
+  switch (omission) {
+    case "binary":
+      return "binary \u2014 not compared";
+    case "tooLarge":
+      return "too large \u2014 not compared";
+    case "unreadable":
+      return "could not be read";
+    case "identical":
+      return "no changes";
+  }
+}
+
+// src/ops/diff/controller.ts
+var EMPTY = { files: [], status: "idle" };
+var DiffController = class {
+  host;
+  reviewEnabled;
+  model = EMPTY;
+  rev = -1;
+  decisions = /* @__PURE__ */ new Map();
+  view;
+  collapsed = /* @__PURE__ */ new Set();
+  wrap = false;
+  showWhitespace = false;
+  cursor = null;
+  listeners = /* @__PURE__ */ new Set();
+  snapshot = null;
+  constructor(options) {
+    this.host = options.host;
+    this.view = options.view ?? "unified";
+    this.reviewEnabled = options.review === true;
+  }
+  /* ── Subscription ──────────────────────────────────────────────────────── */
+  subscribe = (listener) => {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  };
+  getState = () => {
+    if (!this.snapshot) {
+      let additions = 0;
+      let deletions = 0;
+      let hunks = 0;
+      const files = this.model.files.map((file) => {
+        const counts = countChanges(file);
+        additions += counts.additions;
+        deletions += counts.deletions;
+        hunks += file.hunks.length;
+        const fileDecisions = {};
+        for (const hunk of file.hunks) {
+          const decision = this.decisions.get(this.key(file.path, hunk.id));
+          if (decision) fileDecisions[hunk.id] = decision;
+        }
+        return {
+          file,
+          collapsed: this.collapsed.has(file.path),
+          decisions: fileDecisions,
+          additions: counts.additions,
+          deletions: counts.deletions
+        };
+      });
+      const all = [...this.decisions.values()];
+      const status = this.model.status ?? (this.model.files.length > 0 ? "ready" : "idle");
+      this.snapshot = {
+        files,
+        status,
+        message: this.model.message ?? null,
+        view: this.view,
+        wrap: this.wrap,
+        showWhitespace: this.showWhitespace,
+        oldLabel: this.model.oldLabel ?? "Original",
+        newLabel: this.model.newLabel ?? "Modified",
+        totals: { files: this.model.files.length, additions, deletions, hunks },
+        review: this.reviewEnabled && hunks > 0 ? {
+          decided: all.filter((d) => isSettled(d.state)).length,
+          total: hunks,
+          conflicts: all.filter((d) => d.state === "conflict").length,
+          pending: all.filter((d) => d.state === "pending").length
+        } : null,
+        // 🔴 "Nothing changed" is claimed ONLY when the comparison actually ran and every file was
+        // compared. A binary file, a file past the size ceiling and an unreadable one all have zero
+        // hunks and none of them means the content is the same.
+        identical: status === "ready" && hunks === 0 && this.model.files.length > 0 && this.model.files.every((f) => f.omitted === void 0 || f.omitted === "identical"),
+        cursor: this.cursor
+      };
+    }
+    return this.snapshot;
+  };
+  notify() {
+    this.snapshot = null;
+    for (const listener of this.listeners) listener();
+  }
+  key(path, hunkId) {
+    return `${path}\0${hunkId}`;
+  }
+  /* ── Host-pushed state ─────────────────────────────────────────────────── */
+  /**
+   * Install a comparison.
+   *
+   * @param model - The host-computed diff.
+   * @returns Whether it was applied (an older `rev` is ignored).
+   */
+  setModel(model) {
+    if (model.rev !== void 0 && model.rev <= this.rev) return false;
+    if (model.rev !== void 0) this.rev = model.rev;
+    this.model = { ...model, files: model.files ?? [] };
+    const live = /* @__PURE__ */ new Set();
+    for (const file of this.model.files) {
+      for (const hunk of file.hunks) live.add(this.key(file.path, hunk.id));
+    }
+    for (const key of [...this.decisions.keys()]) {
+      if (!live.has(key)) this.decisions.delete(key);
+    }
+    if (this.cursor && !live.has(this.key(this.cursor.path, this.cursor.hunkId))) this.cursor = null;
+    if (!this.cursor) this.cursor = flattenHunks(this.model)[0] ?? null;
+    this.notify();
+    return true;
+  }
+  /** Set the comparison's status without replacing the model. */
+  setStatus(status, message) {
+    this.model = { ...this.model, status, message };
+    if (status === "computing" || status === "failed") {
+      this.model = { ...this.model, files: status === "failed" ? [] : this.model.files };
+    }
+    this.notify();
+  }
+  /**
+   * Record a host-reported decision outcome.
+   *
+   * The **only** way a decision reaches `applied`. The panel writes `pending` when it asks, and
+   * nothing else.
+   *
+   * @param decision - The outcome.
+   * @returns Whether it was recorded.
+   */
+  setDecision(decision) {
+    if (!decision?.hunkId || !decision.path) return false;
+    this.decisions.set(this.key(decision.path, decision.hunkId), decision);
+    this.notify();
+    return true;
+  }
+  /** Record several at once. */
+  setDecisions(decisions) {
+    for (const decision of decisions) {
+      if (decision?.hunkId && decision.path) {
+        this.decisions.set(this.key(decision.path, decision.hunkId), decision);
+      }
+    }
+    this.notify();
+  }
+  /* ── Decisions ─────────────────────────────────────────────────────────── */
+  /**
+   * Decide a hunk.
+   *
+   * Emits an intent and marks the decision `pending`. **It does not apply anything and does not
+   * render as accepted.** The surveyed host runs a two-phase confirm and a checkpointed filesystem
+   * transaction whose outcome may be `applied`, `failed` or `conflict`; a panel that showed a tick
+   * on click would be asserting the outcome of work that has not started.
+   *
+   * @param path - The file.
+   * @param hunkId - The hunk.
+   * @param action - accept, reject or comment.
+   * @param comment - For `comment`, or a note on either.
+   * @returns Whether an intent was emitted.
+   */
+  decide(path, hunkId, action, comment) {
+    if (!this.reviewEnabled) return false;
+    const file = this.model.files.find((f) => f.path === path);
+    if (!file?.hunks.some((h) => h.id === hunkId)) return false;
+    const existing = this.decisions.get(this.key(path, hunkId));
+    if (existing?.state === "pending") return false;
+    this.decisions.set(this.key(path, hunkId), {
+      path,
+      hunkId,
+      action,
+      comment,
+      state: "pending",
+      updatedAt: Date.now()
+    });
+    this.host.emit("decision", { path, hunkId, action, comment });
+    this.notify();
+    return true;
+  }
+  /** Clear a decision locally so it can be re-made — the remedy for a conflict. */
+  clearDecision(path, hunkId) {
+    const removed = this.decisions.delete(this.key(path, hunkId));
+    if (removed) this.notify();
+    return removed;
+  }
+  /** Every recorded decision. */
+  allDecisions() {
+    return [...this.decisions.values()];
+  }
+  /* ── The hunk cursor ───────────────────────────────────────────────────── */
+  /** Move to the next hunk, across file boundaries. */
+  nextHunk() {
+    return this.moveCursor(1);
+  }
+  /** Move to the previous hunk. */
+  previousHunk() {
+    return this.moveCursor(-1);
+  }
+  moveCursor(delta) {
+    const all = flattenHunks(this.model);
+    if (all.length === 0) return null;
+    const at = this.cursor ? all.findIndex((h) => h.path === this.cursor?.path && h.hunkId === this.cursor?.hunkId) : -1;
+    const next = Math.max(0, Math.min(all.length - 1, at + delta));
+    this.cursor = all[next] ?? null;
+    if (this.cursor) this.emitNavigate(this.cursor.path, this.cursor.hunkId);
+    this.notify();
+    return this.cursor;
+  }
+  /** Point at a specific hunk. */
+  focusHunk(path, hunkId) {
+    const file = this.model.files.find((f) => f.path === path);
+    if (!file?.hunks.some((h) => h.id === hunkId)) return false;
+    this.cursor = { path, hunkId };
+    this.emitNavigate(path, hunkId);
+    this.notify();
+    return true;
+  }
+  emitNavigate(path, hunkId) {
+    const file = this.model.files.find((f) => f.path === path);
+    const hunk = file?.hunks.find((h) => h.id === hunkId);
+    this.host.emit("navigate", { path, hunkId, line: hunk?.newStart ?? hunk?.oldStart });
+  }
+  /* ── View state ────────────────────────────────────────────────────────── */
+  /** Unified or split. */
+  setView(view) {
+    this.view = view;
+    this.notify();
+  }
+  /** Collapse or expand a file. */
+  setCollapsed(path, collapsed) {
+    if (collapsed) this.collapsed.add(path);
+    else this.collapsed.delete(path);
+    this.notify();
+  }
+  /** Soft-wrap long lines. */
+  setWrap(wrap) {
+    this.wrap = wrap;
+    this.notify();
+  }
+  /** Render whitespace characters. */
+  setShowWhitespace(show) {
+    this.showWhitespace = show;
+    this.notify();
+  }
+  /** Ask the host for a context menu. */
+  requestContextMenu(path, hunkId, x, y) {
+    this.host.emit("contextMenuRequest", { path, hunkId, x, y });
+  }
+  /* ── Lifecycle ─────────────────────────────────────────────────────────── */
+  /**
+   * Serialize.
+   *
+   * View preferences only. **Never the model and never the decisions** — the model is a comparison
+   * of content that has almost certainly moved on, and a restored decision would claim a review
+   * outcome the host never confirmed.
+   */
+  serialize() {
+    return {
+      view: this.view,
+      collapsed: [...this.collapsed],
+      wrap: this.wrap,
+      showWhitespace: this.showWhitespace
+    };
+  }
+  /** Restore view preferences. */
+  deserialize(state) {
+    if (!state || typeof state !== "object") return;
+    const s = state;
+    if (s.view === "unified" || s.view === "split") this.view = s.view;
+    if (Array.isArray(s.collapsed)) this.collapsed = new Set(s.collapsed);
+    if (typeof s.wrap === "boolean") this.wrap = s.wrap;
+    if (typeof s.showWhitespace === "boolean") this.showWhitespace = s.showWhitespace;
+    this.notify();
+  }
+  /** Tear down. */
+  dispose() {
+    this.listeners.clear();
+    this.model = EMPTY;
+    this.decisions.clear();
+  }
+};
+
+// src/ops/diff/manifest.ts
+import { WELL_KNOWN_PORT_SCHEMAS as WELL_KNOWN_PORT_SCHEMAS2 } from "@xenosystem/panel-sdk";
+var DIFF_PANEL_ID = "xeno.core.diff";
+var diffManifest = {
+  id: DIFF_PANEL_ID,
+  version: "0.1.0",
+  title: "Diff",
+  icon: "file-diff",
+  description: "Renders a host-computed comparison \u2014 unified or split, line or word marks \u2014 with optional hunk-level accept/reject as intents. Bundles no diff engine and no editor.",
+  defaultSlot: "center",
+  inputs: [
+    {
+      id: "model",
+      name: "Model",
+      type: "object",
+      schema: WELL_KNOWN_PORT_SCHEMAS2.DIFF_MODEL,
+      description: "{files[], status?, message?, oldLabel?, newLabel?, rev?}. A file with no hunks carries `omitted` when the reason is not equality \u2014 binary, too large, unreadable.",
+      multiple: false
+    },
+    {
+      id: "decisions",
+      name: "Decisions",
+      type: "array",
+      schema: WELL_KNOWN_PORT_SCHEMAS2.DIFF_DECISION,
+      description: "Host-reported outcomes. The ONLY way a decision reaches `applied`; the panel writes `pending` when it asks and nothing else.",
+      multiple: true
+    },
+    {
+      id: "status",
+      name: "Status",
+      type: "object",
+      description: "{status, message?} \u2014 idle | computing | ready | failed, out of band, so a host never has to express a failed comparison as an empty file list.",
+      multiple: false
+    }
+  ],
+  outputs: [
+    {
+      id: "decision",
+      name: "Decision",
+      type: "object",
+      schema: WELL_KNOWN_PORT_SCHEMAS2.DIFF_DECISION_INTENT,
+      description: "{path, hunkId, action, comment?}. An INTENT \u2014 the host runs its confirm-and-commit and reports back `applied` / `failed` / `conflict`."
+    },
+    {
+      id: "navigate",
+      name: "Navigate",
+      type: "object",
+      description: "{path, hunkId, line?} \u2014 reveal this hunk in the editor."
+    },
+    {
+      id: "contextMenuRequest",
+      name: "Context Menu",
+      type: "object",
+      description: "{path, hunkId, x, y}. Deliberately untagged \u2014 the payload is panel-local."
+    }
+  ],
+  commands: [
+    {
+      id: "get_summary",
+      title: "Get Summary",
+      description: 'Return per-file counts, omission reasons and review progress. Includes `identical` so a caller cannot mistake "not compared" for "unchanged".',
+      parameters: {}
+    },
+    {
+      id: "next_hunk",
+      title: "Next Hunk",
+      description: "Move the cursor to the next hunk. Clamps at the end; never wraps.",
+      parameters: {}
+    },
+    {
+      id: "previous_hunk",
+      title: "Previous Hunk",
+      description: "Move the cursor back.",
+      parameters: {}
+    },
+    {
+      id: "set_view",
+      title: "Set View",
+      description: "unified | split.",
+      parameters: { view: { type: "string", description: "unified | split", required: true } }
+    }
+    // NOTE: `accept` and `reject` are deliberately NOT commands. A hunk decision rewrites the
+    // user's files, and the surveyed host implements it as a two-phase confirm precisely because a
+    // human is meant to be in the loop. An agent-invocable accept would let an agent approve its
+    // OWN patch — the review step exists to check the agent, and the agent must not be able to
+    // operate the thing that checks it.
+  ],
+  config: [
+    {
+      key: "view",
+      label: "Default view",
+      type: "select",
+      defaultValue: "unified",
+      options: [
+        { label: "Unified", value: "unified" },
+        { label: "Split", value: "split" }
+      ],
+      description: "Unified reads better inline; split reads better for wide rewrites."
+    },
+    {
+      key: "review",
+      label: "Allow accept/reject",
+      type: "boolean",
+      defaultValue: false,
+      description: "Offer hunk decisions. Off by default \u2014 most diffs are read-only, and a review surface that appears where nobody can act is worse than none."
+    },
+    {
+      key: "wrap",
+      label: "Wrap long lines",
+      type: "boolean",
+      defaultValue: false,
+      description: "Soft-wrap instead of scrolling horizontally."
+    },
+    {
+      key: "showWhitespace",
+      label: "Show whitespace",
+      type: "boolean",
+      defaultValue: false,
+      description: "Render spaces and tabs \u2014 the only way to read a whitespace-only change."
+    },
+    {
+      key: "contextLines",
+      label: "Context lines",
+      type: "number",
+      defaultValue: 3,
+      description: "Advisory: passed to the host, which computes the hunks."
+    }
+  ],
+  capabilities: ["storage.local"],
+  sdk: "^1.1.0"
+};
+
+// src/ops/diff/react/DiffPanelView.tsx
+import { useSyncExternalStore as useSyncExternalStore4 } from "react";
+import {
+  Badge as Badge4,
+  EmptyState as EmptyState4,
+  ScrollArea as ScrollArea3,
+  SegmentedControl as SegmentedControl2,
+  StatusBar as StatusBar4,
+  TextButton as TextButton3,
+  Toolbar as Toolbar4,
+  ToolbarGroup as ToolbarGroup4
+} from "@xenosystem/workbench/primitives/react";
+import { Fragment as Fragment3, jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+var MARK = {
+  added: { background: "var(--xeno-hover)" },
+  removed: { background: "var(--xeno-border-subtle)" },
+  context: {}
+};
+var SIGIL = { added: "+", removed: "-", context: " " };
+function visible(text, show) {
+  return show ? text.replace(/\t/g, "\u2192   ").replace(/ /g, "\xB7") : text;
+}
+function LineText({
+  line,
+  language,
+  highlighter,
+  showWhitespace
+}) {
+  if (line.segments?.length) {
+    return /* @__PURE__ */ jsx6(Fragment3, { children: line.segments.map((segment, i) => /* @__PURE__ */ jsx6(
+      "span",
+      {
+        style: segment.kind === "equal" ? void 0 : {
+          background: "var(--xeno-border)",
+          borderRadius: 2,
+          textDecoration: segment.kind === "delete" ? "line-through" : void 0
+        },
+        children: visible(segment.text, showWhitespace)
+      },
+      i
+    )) });
+  }
+  const tokens = highlighter?.highlight(line.text, language) ?? null;
+  if (tokens) {
+    return /* @__PURE__ */ jsx6(Fragment3, { children: tokens.map((token, i) => /* @__PURE__ */ jsx6("span", { className: token.token ? `xeno-tok-${token.token}` : void 0, children: visible(token.text, showWhitespace) }, i)) });
+  }
+  return /* @__PURE__ */ jsx6(Fragment3, { children: visible(line.text, showWhitespace) });
+}
+var GUTTER = {
+  display: "inline-block",
+  width: 40,
+  textAlign: "right",
+  paddingRight: 6,
+  opacity: 0.35,
+  fontVariantNumeric: "tabular-nums",
+  userSelect: "none"
+};
+function DecisionChip({ decision }) {
+  if (!decision) return null;
+  if (decision.state === "pending") return /* @__PURE__ */ jsx6(Badge4, { children: "deciding\u2026" });
+  if (decision.state === "conflict") {
+    return /* @__PURE__ */ jsx6(Badge4, { tone: "error", title: decision.message ?? "The file changed since this was reviewed.", children: "conflict \u2014 re-review" });
+  }
+  if (decision.state === "failed") {
+    return /* @__PURE__ */ jsx6(Badge4, { tone: "error", title: decision.message ?? void 0, children: "failed" });
+  }
+  if (isSettled(decision.state)) {
+    return /* @__PURE__ */ jsx6(Badge4, { tone: "success", children: decision.action === "accept" ? "accepted" : "rejected" });
+  }
+  return null;
+}
+function DiffPanelView({ controller, highlighter, review = false }) {
+  const state = useSyncExternalStore4(controller.subscribe, controller.getState, controller.getState);
+  if (state.status === "idle") {
+    return /* @__PURE__ */ jsx6(EmptyState4, { title: "Diff", hint: "Nothing to compare yet." });
+  }
+  if (state.status === "computing") {
+    return /* @__PURE__ */ jsx6(EmptyState4, { title: "Comparing\u2026", hint: "The host is computing the differences." });
+  }
+  if (state.status === "failed") {
+    return /* @__PURE__ */ jsx6(
+      EmptyState4,
+      {
+        title: "Comparison failed",
+        hint: state.message ?? "The host could not compute the differences."
+      }
+    );
+  }
+  if (state.identical) {
+    return /* @__PURE__ */ jsx6(EmptyState4, { title: "No changes", hint: "The two sides are identical." });
+  }
+  const mono = "var(--xeno-font-mono)";
+  const renderLine = (line, file, key) => /* @__PURE__ */ jsxs6(
+    "div",
+    {
+      style: {
+        ...MARK[line.kind],
+        whiteSpace: state.wrap ? "pre-wrap" : "pre",
+        fontFamily: mono,
+        fontSize: 11,
+        lineHeight: "16px"
+      },
+      children: [
+        /* @__PURE__ */ jsx6("span", { style: GUTTER, children: line.oldLineNumber ?? "" }),
+        /* @__PURE__ */ jsx6("span", { style: GUTTER, children: line.newLineNumber ?? "" }),
+        /* @__PURE__ */ jsxs6("span", { style: { opacity: 0.45, userSelect: "none" }, children: [
+          SIGIL[line.kind],
+          " "
+        ] }),
+        /* @__PURE__ */ jsx6(
+          LineText,
+          {
+            line,
+            language: file.file.language,
+            highlighter,
+            showWhitespace: state.showWhitespace
+          }
+        )
+      ]
+    },
+    key
+  );
+  const renderSplitCell = (line, file, side) => /* @__PURE__ */ jsxs6(
+    "div",
+    {
+      style: {
+        flex: 1,
+        minWidth: 0,
+        ...line ? MARK[line.kind] : { opacity: 0.25 },
+        whiteSpace: state.wrap ? "pre-wrap" : "pre",
+        overflow: "hidden",
+        fontFamily: mono,
+        fontSize: 11,
+        lineHeight: "16px"
+      },
+      children: [
+        /* @__PURE__ */ jsx6("span", { style: GUTTER, children: (side === "l" ? line?.oldLineNumber : line?.newLineNumber) ?? "" }),
+        line ? /* @__PURE__ */ jsx6(
+          LineText,
+          {
+            line,
+            language: file.file.language,
+            highlighter,
+            showWhitespace: state.showWhitespace
+          }
+        ) : null
+      ]
+    }
+  );
+  return /* @__PURE__ */ jsxs6("div", { style: { display: "flex", flexDirection: "column", height: "100%", minHeight: 0 }, children: [
+    /* @__PURE__ */ jsx6(
+      Toolbar4,
+      {
+        left: /* @__PURE__ */ jsx6(
+          SegmentedControl2,
+          {
+            label: "View",
+            value: state.view,
+            onChange: (value) => controller.setView(value),
+            options: [
+              { label: "Unified", value: "unified" },
+              { label: "Split", value: "split" }
+            ]
+          }
+        ),
+        right: /* @__PURE__ */ jsxs6(ToolbarGroup4, { end: true, children: [
+          /* @__PURE__ */ jsx6(TextButton3, { onClick: () => controller.setWrap(!state.wrap), children: state.wrap ? "No wrap" : "Wrap" }),
+          /* @__PURE__ */ jsx6(TextButton3, { onClick: () => controller.setShowWhitespace(!state.showWhitespace), children: state.showWhitespace ? "Hide \u2423" : "Show \u2423" }),
+          /* @__PURE__ */ jsx6(TextButton3, { onClick: () => controller.previousHunk(), children: "Prev" }),
+          /* @__PURE__ */ jsx6(TextButton3, { onClick: () => controller.nextHunk(), children: "Next" })
+        ] })
+      }
+    ),
+    state.review && state.review.conflicts > 0 ? /* @__PURE__ */ jsx6("div", { style: { padding: "2px 8px", fontSize: 9 }, children: /* @__PURE__ */ jsxs6(Badge4, { tone: "error", children: [
+      state.review.conflicts,
+      " conflict",
+      state.review.conflicts === 1 ? "" : "s",
+      " \u2014 the file changed since review"
+    ] }) }) : null,
+    /* @__PURE__ */ jsx6(ScrollArea3, { children: state.files.map((file) => /* @__PURE__ */ jsxs6("div", { style: { borderBottom: "1px solid var(--xeno-border-subtle)" }, children: [
+      /* @__PURE__ */ jsxs6(
+        "div",
+        {
+          style: {
+            display: "flex",
+            alignItems: "center",
+            gap: 6,
+            padding: "3px 8px",
+            position: "sticky",
+            top: 0,
+            background: "var(--xeno-surface)",
+            zIndex: 1
+          },
+          children: [
+            /* @__PURE__ */ jsx6(TextButton3, { onClick: () => controller.setCollapsed(file.file.path, !file.collapsed), children: file.collapsed ? "\u25B8" : "\u25BE" }),
+            /* @__PURE__ */ jsx6("span", { style: { fontSize: 11, fontWeight: 600 }, children: file.file.oldPath && file.file.oldPath !== file.file.path ? `${file.file.oldPath} \u2192 ${file.file.path}` : file.file.path }),
+            /* @__PURE__ */ jsx6(Badge4, { children: file.file.status }),
+            /* @__PURE__ */ jsxs6("span", { style: { fontSize: 10, fontVariantNumeric: "tabular-nums", opacity: 0.6 }, children: [
+              "+",
+              file.additions,
+              " \u2212",
+              file.deletions
+            ] })
+          ]
+        }
+      ),
+      file.collapsed ? null : file.file.omitted ? (
+        // 🔴 Never an empty body. "Binary — not compared" and "no changes" are different
+        // facts, and a reviewer who reads the first as the second approves something nobody
+        // looked at.
+        /* @__PURE__ */ jsx6("div", { style: { padding: "6px 12px", fontSize: 10, opacity: 0.6 }, children: omissionLabel(file.file.omitted) })
+      ) : file.file.hunks.map((hunk) => {
+        const decision = file.decisions[hunk.id];
+        const focused = state.cursor?.path === file.file.path && state.cursor.hunkId === hunk.id;
+        return /* @__PURE__ */ jsxs6(
+          "div",
+          {
+            onContextMenu: (event) => {
+              event.preventDefault();
+              controller.requestContextMenu(
+                file.file.path,
+                hunk.id,
+                event.clientX,
+                event.clientY
+              );
+            },
+            style: {
+              borderLeft: focused ? "2px solid var(--xeno-active)" : "2px solid transparent",
+              opacity: isSettled(decision?.state ?? "undecided") ? 0.55 : 1
+            },
+            children: [
+              /* @__PURE__ */ jsxs6(
+                "div",
+                {
+                  style: {
+                    display: "flex",
+                    alignItems: "center",
+                    gap: 6,
+                    padding: "1px 8px",
+                    fontSize: 9,
+                    opacity: 0.55
+                  },
+                  children: [
+                    /* @__PURE__ */ jsx6("span", { style: { fontFamily: mono }, children: hunk.header ?? `@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@` }),
+                    /* @__PURE__ */ jsx6(DecisionChip, { decision }),
+                    review ? /* @__PURE__ */ jsx6("span", { style: { marginLeft: "auto", display: "flex", gap: 4 }, children: needsAttention(decision?.state ?? "undecided") ? /* @__PURE__ */ jsx6(
+                      TextButton3,
+                      {
+                        onClick: () => controller.clearDecision(file.file.path, hunk.id),
+                        children: "Re-review"
+                      }
+                    ) : /* @__PURE__ */ jsxs6(Fragment3, { children: [
+                      /* @__PURE__ */ jsx6(
+                        TextButton3,
+                        {
+                          disabled: decision?.state === "pending",
+                          onClick: () => controller.decide(file.file.path, hunk.id, "accept"),
+                          children: "Accept"
+                        }
+                      ),
+                      /* @__PURE__ */ jsx6(
+                        TextButton3,
+                        {
+                          disabled: decision?.state === "pending",
+                          onClick: () => controller.decide(file.file.path, hunk.id, "reject"),
+                          children: "Reject"
+                        }
+                      )
+                    ] }) }) : null
+                  ]
+                }
+              ),
+              state.view === "unified" ? hunk.lines.map((line, i) => renderLine(line, file, `${hunk.id}-${i}`)) : splitRows(hunk).map((row, i) => /* @__PURE__ */ jsxs6("div", { style: { display: "flex", gap: 1 }, children: [
+                renderSplitCell(row.left, file, "l"),
+                renderSplitCell(row.right, file, "r")
+              ] }, `${hunk.id}-s${i}`))
+            ]
+          },
+          hunk.id
+        );
+      })
+    ] }, file.file.path)) }),
+    /* @__PURE__ */ jsx6(
+      StatusBar4,
+      {
+        left: `${state.totals.files} file${state.totals.files === 1 ? "" : "s"} \xB7 +${state.totals.additions} \u2212${state.totals.deletions}`,
+        right: state.review ? `${state.review.decided}/${state.review.total} reviewed` : `${state.oldLabel} \u2192 ${state.newLabel}`
+      }
+    )
+  ] });
+}
+
+// src/ops/diff/panel.ts
+function createDiffPanel(options = {}) {
+  return {
+    manifest: diffManifest,
+    activate(host) {
+      const config = host.config ?? {};
+      const controller = new DiffController({
+        host: { emit: (portId, value) => host.emit(portId, value) },
+        view: config.view ?? "unified",
+        review: config.review === true
+      });
+      if (config.wrap === true) controller.setWrap(true);
+      if (config.showWhitespace === true) controller.setShowWhitespace(true);
+      const resolve = (config2) => ({ review: config2.review === true });
+      let renderConfig = resolve(host.config ?? {});
+      let unrender = null;
+      let root = null;
+      let currentEl = null;
+      const draw = (el) => {
+        unrender?.();
+        if (options.render) {
+          unrender = options.render(el, { controller, config: renderConfig });
+          return;
+        }
+        root = createRoot4(el);
+        root.render(
+          createElement4(DiffPanelView, {
+            controller,
+            highlighter: options.highlighter,
+            ...renderConfig
+          })
+        );
+        unrender = () => {
+          root?.unmount();
+          root = null;
+        };
+      };
+      const unbindConfig = bindConfig4(host, (config2) => {
+        renderConfig = resolve(config2);
+        if (currentEl) draw(currentEl);
+      });
+      return {
+        render(el) {
+          currentEl = el;
+          draw(el);
+        },
+        onInput(portId, value) {
+          if (portId === "model") {
+            if (value && typeof value === "object" && Array.isArray(value.files)) {
+              controller.setModel(value);
+            }
+          } else if (portId === "decisions") {
+            if (Array.isArray(value)) controller.setDecisions(value);
+            else if (value && typeof value === "object") controller.setDecision(value);
+          } else if (portId === "status") {
+            const payload = value;
+            if (payload?.status) controller.setStatus(payload.status, payload.message);
+          }
+        },
+        async onCommand(commandId, params) {
+          switch (commandId) {
+            case "get_summary": {
+              const state = controller.getState();
+              return {
+                status: state.status,
+                identical: state.identical,
+                totals: state.totals,
+                review: state.review,
+                files: state.files.map((f) => {
+                  const counts = countChanges(f.file);
+                  return {
+                    path: f.file.path,
+                    status: f.file.status,
+                    omitted: f.file.omitted,
+                    hunks: f.file.hunks.length,
+                    ...counts
+                  };
+                })
+              };
+            }
+            case "next_hunk":
+              return controller.nextHunk();
+            case "previous_hunk":
+              return controller.previousHunk();
+            case "set_view":
+              controller.setView(params.view === "split" ? "split" : "unified");
+              return true;
+            default:
+              return;
+          }
+        },
+        serialize() {
+          return controller.serialize();
+        },
+        deserialize(state) {
+          controller.deserialize(state);
+        },
+        dispose() {
+          unbindConfig();
+          currentEl = null;
+          unrender?.();
+          unrender = null;
+          controller.dispose();
+        }
+      };
+    }
+  };
+}
+var diffPanel = createDiffPanel();
+export {
+  ALL_STATUSES,
+  CONSOLE_PANEL_ID,
+  ConsoleController,
+  ConsolePanelView,
+  DEFAULT_MAX_STEP_DEPTH,
+  DIFF_PANEL_ID,
+  DiffController,
+  DiffPanelView,
+  LEVEL_ORDER,
+  MESSAGE_ELISION,
+  REDACTION_CARRY,
+  RUNS_PANEL_ID,
+  RUN_PATH_SEPARATOR,
+  RUN_STATUSES,
+  RunsController,
+  RunsPanelView,
+  TERMINAL_PANEL_ID,
+  TERMINAL_STATUSES,
+  TerminalController,
+  TerminalPanelView,
+  XENO_TERMINAL_THEME_KEYS,
+  appendStepsAtPath,
+  canCancel,
+  canRetry,
+  collapseAdjacent,
+  computeStats,
+  consoleManifest,
+  consolePanel,
+  countChanges,
+  createConsolePanel,
+  createDiffPanel,
+  createRunsPanel,
+  createTerminalPanel,
+  decodeRunPath,
+  diffManifest,
+  diffPanel,
+  durationOf,
+  encodeRunPath,
+  flattenHunks,
+  flattenRunRows,
+  formatDuration,
+  formatRecord,
+  isActive,
+  isLive,
+  isSettled,
+  isTerminal,
+  isWaiting,
+  lifecycleOf,
+  matchesSearch2 as matchesRunSearch,
+  matchesSearch,
+  measuredSize,
+  meetsLevel,
+  needsAttention,
+  omissionLabel,
+  patchStepAtPath,
+  queueDurationOf,
+  readTerminalTheme,
+  resolveStepPath,
+  runsManifest,
+  runsPanel,
+  safeJson,
+  spliceRedactedAppend,
+  splitRows,
+  statusLabel,
+  terminalManifest,
+  terminalPanel,
+  terminalThemeVar,
+  truncateLogMessage
+};