@op1/threads 0.2.1 → 0.2.2

package/tui.js

@@ -0,0 +1,2093 @@
+// @bun
+// tui.ts
+import { Plugin } from "@opencode/plugin/tui";
+import { getComponentCatalogue } from "@opentui/solid/components";
+import { createEffect as createEffect3, createSignal as createSignal3 } from "solid-js";
+import { z as z5 } from "zod";
+
+// src/rpc.ts
+import { Rpc } from "@opencode/plugin/rpc";
+import { z } from "zod";
+var Report = z.object({
+  verdict: z.enum(["PASS", "PASS WITH NOTES", "FAIL", "INCONCLUSIVE"]),
+  summary: z.string().min(1),
+  evidence: z.array(z.string())
+}).strict();
+var WorkerView = z.object({
+  workerID: z.string(),
+  coordinatorID: z.string(),
+  key: z.string(),
+  title: z.string(),
+  directory: z.string(),
+  agent: z.string().nullable(),
+  model: z.object({
+    providerID: z.string(),
+    id: z.string(),
+    variant: z.string().optional()
+  }).nullable(),
+  outcome: z.enum(["succeeded", "failed", "interrupted"]).nullable(),
+  report: Report.nullable(),
+  hidden: z.boolean()
+});
+var ThreadsRpc = Rpc.define({
+  id: "threads",
+  methods: {
+    snapshot: {
+      input: z.object({ coordinatorIDs: z.array(z.string()).max(100) }).strict(),
+      output: z.object({ workers: z.array(WorkerView) }),
+      errors: {}
+    },
+    restore: {
+      input: z.object({ coordinatorIDs: z.array(z.string()).max(100) }).strict(),
+      output: z.object({ workers: z.array(WorkerView) }),
+      errors: {}
+    }
+  },
+  events: {}
+});
+
+// src/activity.ts
+import { z as z2 } from "zod";
+
+// src/activity-model.ts
+function cleanRoleTitle(title, managed) {
+  if (!managed)
+    return title;
+  const remainder = title.replace(/^\[(?:Main|Worker)\] /, "");
+  return remainder.trim() ? remainder : title;
+}
+function activityTime(time) {
+  return time.idle ?? time.updated ?? time.created;
+}
+function activitySubtitle(input) {
+  const folder = (path) => path.replace(/[\\/]+$/, "").split(/[\\/]/).pop() || path;
+  const location = folder(input.directory);
+  const project = input.project?.name?.trim() || (input.project ? folder(input.project.canonical) : location);
+  const parts = [project];
+  if (input.role)
+    parts.push(input.role);
+  if (input.project && input.project.canonical !== input.directory && location !== project)
+    parts.push(location);
+  return parts.join(" \xB7 ");
+}
+function dateGroup(timestamp, now = new Date) {
+  const date = new Date(timestamp);
+  const day = (value) => Date.UTC(value.getFullYear(), value.getMonth(), value.getDate());
+  const age = (day(now) - day(date)) / 86400000;
+  if (age === 0)
+    return "Today";
+  if (age === 1)
+    return "Yesterday";
+  if (age > 1 && age < 7)
+    return date.toLocaleDateString(undefined, { weekday: "long" });
+  return date.toLocaleDateString(undefined, {
+    year: "numeric",
+    month: "short",
+    day: "numeric"
+  });
+}
+function priority(item) {
+  return item.attention ? 3 : item.busy ? 2 : item.unread ? 1 : 0;
+}
+function visible(item) {
+  return !item.hidden || item.open || item.active || item.busy || item.attention;
+}
+function compare(a, b) {
+  return priority(b) - priority(a) || Number(b.pinned) - Number(a.pinned) || b.updated - a.updated || a.id.localeCompare(b.id);
+}
+function activityGroups(items, now = new Date) {
+  const groups = new Map;
+  const ordered = items.filter(visible).sort(compare);
+  for (const item of ordered) {
+    const key = priority(item) ? "Priority" : item.pinned ? "Pinned" : dateGroup(item.updated, now);
+    const group = groups.get(key) ?? [];
+    group.push(item);
+    groups.set(key, group);
+  }
+  return groups;
+}
+function activityThreads(items, now = new Date) {
+  const available = new Map(items.filter(visible).map((item) => [item.id, item]));
+  const children = new Map;
+  const roots = [];
+  for (const item of available.values()) {
+    const parent = item.coordinatorID ? available.get(item.coordinatorID) : undefined;
+    if (parent && parent.id !== item.id && !parent.coordinatorID) {
+      const siblings = children.get(parent.id) ?? [];
+      siblings.push(item);
+      children.set(parent.id, siblings);
+    } else
+      roots.push(item);
+  }
+  const threads = new Map;
+  const summaries = roots.map((item) => {
+    const workers = (children.get(item.id) ?? []).sort(compare);
+    const members = [item, ...workers];
+    const status = {
+      attention: members.some((member) => member.attention),
+      busy: members.some((member) => member.busy),
+      unread: members.some((member) => member.unread === "error") ? "error" : members.find((member) => member.unread)?.unread
+    };
+    threads.set(item.id, { item, children: workers, status });
+    return {
+      ...item,
+      ...status,
+      pinned: members.some((member) => member.pinned),
+      updated: Math.max(...members.map((member) => member.updated))
+    };
+  });
+  return new Map([...activityGroups(summaries, now)].map(([name, group]) => [
+    name,
+    group.flatMap((item) => {
+      const thread = threads.get(item.id);
+      return thread ? [thread] : [];
+    })
+  ]));
+}
+
+// src/activity-rail.ts
+function activityRail(ctx, core, mount) {
+  const { BoxRenderable, ScrollBoxRenderable } = core;
+  let owned;
+  let enabled = true;
+  let dirty = true;
+  let geometry = "";
+  const detach = () => {
+    if (!owned)
+      return;
+    owned.cleanup();
+    if (!owned.content.isDestroyed)
+      owned.content.destroyRecursively();
+    for (const [child, visible2] of owned.restore)
+      if (!child.isDestroyed)
+        child.visible = visible2;
+    owned = undefined;
+  };
+  const find = () => {
+    const matches = [];
+    const queue = [
+      { node: ctx.renderer.root, depth: 0 }
+    ];
+    let count = 0;
+    while (queue.length && count++ < 128) {
+      const entry = queue.shift();
+      if (!entry)
+        break;
+      const children = entry.node.getChildren();
+      for (const child of children) {
+        if (child instanceof BoxRenderable && child.visible && child.screenX === 0 && child.screenY === 0 && child.width >= 24 && child.width <= 60 && child.height === ctx.renderer.height && child.getChildren().some((node) => node instanceof ScrollBoxRenderable) && children.filter((sibling) => sibling !== child && sibling.screenX === child.width && sibling.screenY === 0 && sibling.height === child.height && sibling.width >= 60).length === 1)
+          matches.push(child);
+        if (entry.depth < 4)
+          queue.push({ node: child, depth: entry.depth + 1 });
+      }
+    }
+    return queue.length === 0 && matches.length === 1 ? matches[0] : undefined;
+  };
+  const frame = () => {
+    if (owned?.rail.isDestroyed || owned?.content.isDestroyed) {
+      detach();
+      dirty = true;
+    }
+    const current = `${ctx.renderer.width}:${ctx.renderer.height}:${owned?.rail.width}:${owned?.rail.height}`;
+    if (current !== geometry) {
+      geometry = current;
+      dirty = true;
+    }
+    if (!dirty)
+      return;
+    dirty = false;
+    const rail = enabled && ctx.ui.tabs.enabled() ? find() : undefined;
+    if (owned?.rail !== rail)
+      detach();
+    if (!rail)
+      return;
+    if (!owned) {
+      const content = new BoxRenderable(ctx.renderer, {
+        id: "op-threads-activity",
+        position: "absolute",
+        left: 0,
+        top: 0,
+        width: "100%",
+        height: "100%",
+        paddingLeft: 1,
+        paddingRight: 2,
+        flexDirection: "column",
+        onMouseDown: (event) => event.stopPropagation(),
+        onMouseUp: (event) => event.stopPropagation()
+      });
+      rail.add(content);
+      owned = { rail, content, restore: new Map, cleanup: mount(content) };
+    }
+    for (const child of rail.getChildren()) {
+      if (child === owned.content)
+        continue;
+      if (!owned.restore.has(child))
+        owned.restore.set(child, child.visible);
+      child.visible = false;
+    }
+    for (const child of owned.restore.keys())
+      if (child.isDestroyed)
+        owned.restore.delete(child);
+  };
+  const invalidate = () => {
+    dirty = true;
+    ctx.renderer.requestRender();
+  };
+  const beforeFrame = async () => frame();
+  ctx.renderer.setFrameCallback(beforeFrame);
+  ctx.renderer.on("resize", invalidate);
+  invalidate();
+  return {
+    invalidate,
+    enabled: () => enabled,
+    mounted: () => Boolean(owned && !owned.rail.isDestroyed && !owned.content.isDestroyed),
+    toggle(value = !enabled) {
+      enabled = value;
+      if (!enabled)
+        detach();
+      invalidate();
+    },
+    dispose() {
+      ctx.renderer.removeFrameCallback(beforeFrame);
+      ctx.renderer.off("resize", invalidate);
+      detach();
+    }
+  };
+}
+
+// src/activity-theme.ts
+function themeColor(token, fallback) {
+  return ("base" in token ? token.base : token.default) ?? fallback;
+}
+function themeMuted(token, fallback) {
+  return ("muted" in token ? token.muted : token.subdued) ?? fallback;
+}
+function luminance(color) {
+  const linear = (value) => value <= 0.04045 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4;
+  return 0.2126 * linear(color.r) + 0.7152 * linear(color.g) + 0.0722 * linear(color.b);
+}
+function themeHue(hue, foreground, background) {
+  const target = luminance(foreground);
+  let selected = foreground;
+  let distance = Infinity;
+  for (const color of Object.values(hue ?? {})) {
+    if (!color)
+      continue;
+    const delta = Math.abs(luminance(color) - target);
+    if (delta >= distance)
+      continue;
+    selected = color;
+    distance = delta;
+  }
+  const light = luminance(selected);
+  const base = luminance(background);
+  const contrast = (Math.max(light, base) + 0.05) / (Math.min(light, base) + 0.05);
+  return contrast >= 4.5 ? selected : foreground;
+}
+
+// src/activity-picker.tsx
+import { insert as _$insert } from "@opentui/solid";
+import { effect as _$effect } from "@opentui/solid";
+import { createComponent as _$createComponent } from "@opentui/solid";
+import { use as _$use } from "@opentui/solid";
+import { createTextNode as _$createTextNode } from "@opentui/solid";
+import { insertNode as _$insertNode } from "@opentui/solid";
+import { setProp as _$setProp } from "@opentui/solid";
+import { createElement as _$createElement } from "@opentui/solid";
+import { createEffect, createMemo, createSignal, For, onCleanup, Show } from "solid-js";
+import fuzzysort from "fuzzysort";
+function ActivityPicker(props) {
+  const {
+    ctx
+  } = props;
+  const [query, setQuery] = createSignal("");
+  const [selectedID, setSelectedID] = createSignal(props.current);
+  const [pinning, setPinning] = createSignal(false);
+  const [height, setHeight] = createSignal(ctx.renderer.height);
+  let input;
+  let scroll;
+  let closed = false;
+  const foreground = () => themeColor(ctx.theme.text, props.fallbackColor);
+  const muted = () => themeMuted(ctx.theme.text, foreground());
+  const grouped = createMemo(() => {
+    const items = query() ? fuzzysort.go(query(), props.items(), {
+      keys: ["title", "category"],
+      scoreFn: (result) => result[0].score * 2 + result[1].score
+    }).map((result) => result.obj) : props.items();
+    const groups = new Map;
+    for (const item of items) {
+      const group = groups.get(item.category) ?? [];
+      group.push(item);
+      groups.set(item.category, group);
+    }
+    return [...groups];
+  });
+  const choices = createMemo(() => grouped().flatMap(([, items]) => items));
+  const selected = () => choices().find((item) => item.id === selectedID()) ?? choices()[0];
+  const select = (index) => setSelectedID(choices()[index]?.id);
+  const move = (direction) => {
+    const items = choices();
+    if (!items.length)
+      return;
+    const index = items.findIndex((item) => item.id === selected()?.id);
+    select((index + direction % items.length + items.length) % items.length);
+  };
+  const open = (id = selected()?.id) => {
+    if (!id)
+      return;
+    ctx.ui.dialog.clear();
+    props.open(id);
+  };
+  const togglePin = async () => {
+    const item = selected();
+    if (!item || pinning())
+      return;
+    setSelectedID(item.id);
+    setPinning(true);
+    try {
+      await props.pin(item.id);
+    } finally {
+      if (!closed)
+        setPinning(false);
+    }
+  };
+  ctx.keymap.layer(() => ({
+    mode: "global",
+    target: () => input,
+    priority: 100,
+    commands: [{
+      bind: "up",
+      run: () => move(-1)
+    }, {
+      bind: "ctrl+p",
+      run: () => move(-1)
+    }, {
+      bind: "down",
+      run: () => move(1)
+    }, {
+      bind: "ctrl+n",
+      run: () => move(1)
+    }, {
+      bind: "pageup",
+      run: () => move(-10)
+    }, {
+      bind: "pagedown",
+      run: () => move(10)
+    }, {
+      bind: "home",
+      run: () => {
+        select(0);
+      }
+    }, {
+      bind: "end",
+      run: () => {
+        select(choices().length - 1);
+      }
+    }, {
+      bind: "return",
+      run: () => open()
+    }, {
+      bind: "escape",
+      run: () => ctx.ui.dialog.clear()
+    }, {
+      id: "threads.activity.choose.pin",
+      title: "Pin/unpin highlighted Activity conversation",
+      bind: "ctrl+f",
+      run: togglePin
+    }]
+  }));
+  let scrollTo;
+  createEffect(() => {
+    grouped();
+    scrollTo = selected()?.id;
+  });
+  const reveal = () => {
+    if (!scrollTo || !scroll)
+      return;
+    scroll.scrollChildIntoView(`activity-picker-row-${scrollTo}`);
+    scrollTo = undefined;
+  };
+  const resize = () => setHeight(ctx.renderer.height);
+  ctx.renderer.addPostProcessFn(reveal);
+  ctx.renderer.on("resize", resize);
+  onCleanup(() => {
+    closed = true;
+    ctx.renderer.removePostProcessFn(reveal);
+    ctx.renderer.off("resize", resize);
+  });
+  return (() => {
+    var _el$ = _$createElement("box"), _el$2 = _$createElement("text"), _el$3 = _$createElement("b"), _el$5 = _$createElement("input"), _el$6 = _$createElement("scrollbox"), _el$9 = _$createElement("text");
+    _$insertNode(_el$, _el$2);
+    _$insertNode(_el$, _el$5);
+    _$insertNode(_el$, _el$6);
+    _$insertNode(_el$, _el$9);
+    _$setProp(_el$, "id", "activity-picker");
+    _$setProp(_el$, "paddingX", 2);
+    _$setProp(_el$, "paddingY", 1);
+    _$setProp(_el$, "gap", 1);
+    _$insertNode(_el$2, _el$3);
+    _$insertNode(_el$3, _$createTextNode(`Activity`));
+    _$use((node) => {
+      input = node;
+    }, _el$5);
+    _$setProp(_el$5, "id", "activity-picker-search");
+    _$setProp(_el$5, "focused", true);
+    _$setProp(_el$5, "placeholder", "Search");
+    _$setProp(_el$5, "onInput", (value) => {
+      setQuery(value);
+      setSelectedID(undefined);
+    });
+    _$use((node) => {
+      scroll = node;
+    }, _el$6);
+    _$setProp(_el$6, "scrollX", false);
+    _$setProp(_el$6, "scrollbarOptions", {
+      visible: false
+    });
+    _$insert(_el$6, _$createComponent(For, {
+      get each() {
+        return grouped();
+      },
+      children: ([category, items]) => [(() => {
+        var _el$0 = _$createElement("text");
+        _$setProp(_el$0, "marginTop", 1);
+        _$insert(_el$0, category);
+        _$effect((_$p) => _$setProp(_el$0, "fg", muted(), _$p));
+        return _el$0;
+      })(), _$createComponent(For, {
+        each: items,
+        children: (item) => (() => {
+          var _el$1 = _$createElement("box"), _el$10 = _$createElement("text"), _el$11 = _$createElement("text");
+          _$insertNode(_el$1, _el$10);
+          _$insertNode(_el$1, _el$11);
+          _$setProp(_el$1, "height", 1);
+          _$setProp(_el$1, "flexShrink", 0);
+          _$setProp(_el$1, "flexDirection", "row");
+          _$setProp(_el$1, "onMouseUp", (event) => {
+            event.stopPropagation();
+            if (event.button === 0)
+              open(item.id);
+          });
+          _$setProp(_el$10, "width", "60%");
+          _$setProp(_el$10, "wrapMode", "none");
+          _$setProp(_el$10, "truncate", true);
+          _$insert(_el$10, () => `${selected()?.id === item.id ? ">" : " "} ${item.pinned ? "\u25C6" : "\u25C7"} ${item.title}`);
+          _$setProp(_el$11, "flexGrow", 1);
+          _$setProp(_el$11, "flexShrink", 1);
+          _$setProp(_el$11, "minWidth", 0);
+          _$setProp(_el$11, "wrapMode", "none");
+          _$setProp(_el$11, "truncate", true);
+          _$insert(_el$11, () => `${item.subtitle}${item.closed ? " \xB7 Closed" : ""}`);
+          _$effect((_p$) => {
+            var _v$6 = `activity-picker-row-${item.id}`, _v$7 = selected()?.id === item.id ? ctx.theme.background.raised?.high ?? themeColor(ctx.theme.background, props.fallbackColor) : undefined, _v$8 = `activity-picker-title-${item.id}`, _v$9 = foreground(), _v$0 = muted();
+            _v$6 !== _p$.e && (_p$.e = _$setProp(_el$1, "id", _v$6, _p$.e));
+            _v$7 !== _p$.t && (_p$.t = _$setProp(_el$1, "backgroundColor", _v$7, _p$.t));
+            _v$8 !== _p$.a && (_p$.a = _$setProp(_el$10, "id", _v$8, _p$.a));
+            _v$9 !== _p$.o && (_p$.o = _$setProp(_el$10, "fg", _v$9, _p$.o));
+            _v$0 !== _p$.i && (_p$.i = _$setProp(_el$11, "fg", _v$0, _p$.i));
+            return _p$;
+          }, {
+            e: undefined,
+            t: undefined,
+            a: undefined,
+            o: undefined,
+            i: undefined
+          });
+          return _el$1;
+        })()
+      })]
+    }), null);
+    _$insert(_el$6, _$createComponent(Show, {
+      get when() {
+        return !choices().length;
+      },
+      get children() {
+        var _el$7 = _$createElement("text");
+        _$insertNode(_el$7, _$createTextNode(`No matching conversations`));
+        _$effect((_$p) => _$setProp(_el$7, "fg", muted(), _$p));
+        return _el$7;
+      }
+    }), null);
+    _$setProp(_el$9, "id", "activity-picker-hint");
+    _$insert(_el$9, () => `${ctx.keymap.shortcuts("threads.activity.choose.pin").join(" / ")} ${selected()?.pinned ? "Unpin" : "Pin"} \xB7 enter Open \xB7 esc Close`);
+    _$effect((_p$) => {
+      var _v$ = foreground(), _v$2 = foreground(), _v$3 = foreground(), _v$4 = Math.max(1, Math.min(choices().length + grouped().length * 2, Math.floor(height() / 2) - 6)), _v$5 = muted();
+      _v$ !== _p$.e && (_p$.e = _$setProp(_el$2, "fg", _v$, _p$.e));
+      _v$2 !== _p$.t && (_p$.t = _$setProp(_el$5, "textColor", _v$2, _p$.t));
+      _v$3 !== _p$.a && (_p$.a = _$setProp(_el$5, "focusedTextColor", _v$3, _p$.a));
+      _v$4 !== _p$.o && (_p$.o = _$setProp(_el$6, "height", _v$4, _p$.o));
+      _v$5 !== _p$.i && (_p$.i = _$setProp(_el$9, "fg", _v$5, _p$.i));
+      return _p$;
+    }, {
+      e: undefined,
+      t: undefined,
+      a: undefined,
+      o: undefined,
+      i: undefined
+    });
+    return _el$;
+  })();
+}
+
+// src/activity.ts
+var Link = z2.object({
+  workerID: z2.string(),
+  coordinatorID: z2.string(),
+  key: z2.string(),
+  fingerprint: z2.string(),
+  initialMessageID: z2.string(),
+  reportMessageID: z2.string()
+}).strict();
+function activity(ctx, core, solid, Spinner) {
+  const { BoxRenderable, ScrollBoxRenderable, TextRenderable, TextAttributes } = core;
+  const { createEffect: createEffect2, createSignal: createSignal2 } = solid;
+  const fallbackColor = core.RGBA.fromHex("#808080");
+  const [revision, setRevision] = createSignal2(0);
+  const [pins, savePins] = ctx.storage.store("activity-pins", {
+    initial: { ids: [] }
+  });
+  const [sections, saveSections] = ctx.storage.store("activity-sections", {
+    initial: { collapsed: [] }
+  });
+  const [threadState, saveThreadState] = ctx.storage.store("activity-threads", {
+    initial: { collapsed: [] }
+  });
+  const [dismissed, saveDismissed] = ctx.storage.store("activity-dismissed", {
+    initial: { ids: [] }
+  });
+  const closingRows = new Set;
+  const sessions = new Map;
+  const workers = new Map;
+  const deleted = new Set;
+  const abort = new AbortController;
+  const rpc = ctx.client.rpc(ThreadsRpc);
+  let stopped = false;
+  let loading = false;
+  let lastError;
+  let render = () => {};
+  const changed = () => {
+    if (!stopped)
+      setRevision((value) => value + 1);
+  };
+  const error = (value) => {
+    const detail = z2.object({ message: z2.string() }).safeParse(value);
+    const message = `Activity: ${detail.success ? detail.data.message : String(value)}`;
+    if (!stopped && message !== lastError)
+      ctx.ui.toast.show({ message, variant: "error" });
+    lastError = message;
+  };
+  async function pin(id) {
+    try {
+      await savePins((draft) => {
+        draft.ids = draft.ids.includes(id) ? draft.ids.filter((value) => value !== id) : [...draft.ids, id];
+      });
+      changed();
+    } catch (value) {
+      error(value);
+    }
+  }
+  async function restore(ids) {
+    if (!ids.some((id) => dismissed.ids.includes(id)))
+      return;
+    await saveDismissed((draft) => {
+      draft.ids = draft.ids.filter((id) => !ids.includes(id));
+    });
+    changed();
+  }
+  async function focus(id) {
+    try {
+      await restore([id]);
+      if (!stopped)
+        ctx.ui.tabs.focus(id);
+    } catch (value) {
+      error(value);
+    }
+  }
+  async function close(id) {
+    if (stopped || closingRows.has(id))
+      return;
+    closingRows.add(id);
+    try {
+      if (ctx.ui.tabs.list().some((tab) => tab.sessionID === id) && !ctx.ui.tabs.close(id))
+        return;
+      await saveDismissed((draft) => {
+        if (!draft.ids.includes(id))
+          draft.ids.push(id);
+      });
+    } catch (value) {
+      error(value);
+    } finally {
+      closingRows.delete(id);
+      changed();
+    }
+  }
+  async function toggleSection(name) {
+    try {
+      await saveSections((draft) => {
+        draft.collapsed = draft.collapsed.includes(name) ? draft.collapsed.filter((value) => value !== name) : [...draft.collapsed, name];
+      });
+      changed();
+    } catch (value) {
+      error(value);
+    }
+  }
+  async function toggleThread(id) {
+    try {
+      await saveThreadState((draft) => {
+        draft.collapsed = draft.collapsed.includes(id) ? draft.collapsed.filter((value) => value !== id) : [...draft.collapsed, id];
+      });
+      changed();
+    } catch (value) {
+      error(value);
+    }
+  }
+  function items(includeDismissed = false) {
+    revision();
+    const tabs = new Map(ctx.ui.tabs.list().map((tab) => [tab.sessionID, tab]));
+    const merged = new Map(sessions);
+    for (const id of [
+      ...tabs.keys(),
+      ...pins.ids,
+      ...[...workers.values()].map((worker) => worker.coordinatorID)
+    ]) {
+      const session = ctx.data.session.get(id);
+      if (session)
+        merged.set(id, session);
+    }
+    const result = [];
+    const coordinators = new Set([...workers.values()].map((worker) => worker.coordinatorID));
+    for (const saved of merged.values()) {
+      const session = ctx.data.session.get(saved.id) ?? saved;
+      if (deleted.has(session.id) || session.parentID || session.time.archived)
+        continue;
+      const tab = tabs.get(session.id);
+      const isDismissed = dismissed.ids.includes(session.id);
+      if (!includeDismissed && isDismissed && !tab?.active)
+        continue;
+      const link = Link.safeParse(session.metadata?.opThreads);
+      const worker = workers.get(session.id);
+      const attention = tab ? tab.attention : Boolean(ctx.data.session.permission.list(session.id)?.length || ctx.data.session.form.list(session.id)?.length);
+      const busy = tab ? tab.busy : ctx.data.session.status(session.id) === "running";
+      if (link.success && !tab && !busy && !attention && !(includeDismissed && isDismissed))
+        continue;
+      const role = worker && link.success && link.data.workerID === session.id && link.data.coordinatorID === worker.coordinatorID ? "Worker" : coordinators.has(session.id) ? "Main" : undefined;
+      result.push({
+        id: session.id,
+        title: cleanRoleTitle(tab?.title ?? session.title ?? "Untitled", role !== undefined),
+        subtitle: activitySubtitle({
+          directory: session.location.directory,
+          project: ctx.data.project.get(session.projectID),
+          role
+        }),
+        updated: activityTime(session.time),
+        active: tab?.active ?? false,
+        attention,
+        busy,
+        unread: tab?.unread,
+        pinned: pins.ids.includes(session.id),
+        hidden: includeDismissed && isDismissed ? false : worker?.hidden ?? false,
+        open: Boolean(tab),
+        coordinatorID: role === "Worker" ? worker?.coordinatorID : undefined
+      });
+    }
+    return activityThreads(result);
+  }
+  async function resolveSession(id) {
+    if (stopped || sessions.has(id) || deleted.has(id))
+      return;
+    try {
+      const result = await ctx.client.session.get({ sessionID: id }, { signal: abort.signal });
+      if (!stopped)
+        sessions.set(id, result);
+    } catch (value) {
+      const missing = z2.object({
+        _tag: z2.literal("SessionNotFoundError"),
+        sessionID: z2.string()
+      }).safeParse(value);
+      if (!missing.success || missing.data.sessionID !== id)
+        throw value;
+      deleted.add(id);
+      if (pins.ids.includes(id))
+        await savePins((draft) => {
+          draft.ids = draft.ids.filter((value2) => value2 !== id);
+        });
+      await restore([id]);
+    }
+  }
+  async function load() {
+    if (loading || stopped)
+      return;
+    loading = true;
+    try {
+      const page = await ctx.client.session.list({
+        parentID: null,
+        limit: 100,
+        order: "desc"
+      }, { signal: abort.signal });
+      if (stopped)
+        return;
+      for (const session of page.data)
+        sessions.set(session.id, session);
+      for (const id of new Set([...pins.ids, ...dismissed.ids]))
+        await resolveSession(id);
+      const ids = [
+        ...new Set([...sessions.values()].flatMap((session) => {
+          const link = Link.safeParse(session.metadata?.opThreads);
+          return link.success ? [session.id, link.data.coordinatorID] : [session.id];
+        }))
+      ];
+      for (let index = 0;index < ids.length && !stopped; index += 100) {
+        const result = await rpc.snapshot({ coordinatorIDs: ids.slice(index, index + 100) }, {
+          signal: abort.signal,
+          location: ctx.location ?? ctx.data.location.default()
+        });
+        for (const worker of result.workers)
+          workers.set(worker.workerID, worker);
+      }
+      for (const id of new Set([...workers.values()].map((worker) => worker.coordinatorID))) {
+        await resolveSession(id);
+      }
+      lastError = undefined;
+    } catch (value) {
+      error(value);
+    } finally {
+      loading = false;
+      changed();
+    }
+  }
+  async function actions(item, hasChildren) {
+    const action = await ctx.ui.dialog.select({
+      title: item.title,
+      options: [
+        { title: item.pinned ? "Unpin" : "Pin", value: "pin" },
+        {
+          title: "Close from Activity (keep history)",
+          value: "close"
+        },
+        ...hasChildren ? [{
+          title: threadState.collapsed.includes(item.id) ? "Expand workers" : "Collapse workers",
+          value: "workers"
+        }] : []
+      ]
+    });
+    if (stopped)
+      return;
+    if (action === "pin")
+      await pin(item.id);
+    if (action === "close")
+      await close(item.id);
+    if (action === "workers")
+      await toggleThread(item.id);
+  }
+  const rail = activityRail(ctx, core, (content) => {
+    const runningIndicator = (id) => {
+      if (!Spinner)
+        return;
+      const node = new Spinner(ctx.renderer, {
+        id: `activity-running-${id}`,
+        frames: ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"],
+        interval: 80,
+        color: themeColor(ctx.theme.text, fallbackColor)
+      });
+      if ("color" in node)
+        return node;
+      node.destroy();
+    };
+    const text = (value) => new TextRenderable(ctx.renderer, {
+      content: value,
+      fg: themeColor(ctx.theme.text, fallbackColor),
+      height: 1,
+      flexShrink: 0
+    });
+    const header = text("Activity");
+    header.attributes = TextAttributes.BOLD;
+    content.add(header);
+    const fresh = text("+ New session");
+    fresh.id = "activity-new-session";
+    fresh.marginTop = 1;
+    fresh.marginBottom = 1;
+    fresh.onMouseUp = (event) => {
+      event.stopPropagation();
+      if (event.button === 0)
+        ctx.keymap.dispatch("session.new");
+    };
+    content.add(fresh);
+    const scroll = new ScrollBoxRenderable(ctx.renderer, {
+      flexGrow: 1,
+      scrollY: true,
+      scrollX: false
+    });
+    content.add(scroll);
+    const rows = new Map;
+    const headings = new Map;
+    const help = text("/activities");
+    content.add(help);
+    render = () => {
+      const fg = themeColor(ctx.theme.text, fallbackColor);
+      const muted = themeMuted(ctx.theme.text, fg);
+      const background = ctx.theme.background.raised?.base ?? themeColor(ctx.theme.background, fallbackColor);
+      const accent = themeHue(ctx.theme.hue?.accent, fg, background);
+      const workerColor = themeHue(ctx.theme.hue?.purple, fg, background);
+      const runningColor = themeColor(ctx.theme.text.feedback.info, fg);
+      const attentionColor = themeColor(ctx.theme.text.feedback.warning, fg);
+      header.fg = accent;
+      fresh.fg = accent;
+      help.fg = muted;
+      const desired = [];
+      const keep = new Set;
+      const groups = items();
+      for (const [name, group] of groups) {
+        let heading = headings.get(name);
+        if (!heading) {
+          const box = new BoxRenderable(ctx.renderer, {
+            id: `activity-section-${encodeURIComponent(name)}`,
+            flexDirection: "column",
+            flexShrink: 0,
+            shouldFill: false,
+            onMouseUp(event) {
+              event.stopPropagation();
+              if (event.button === 0)
+                toggleSection(name);
+            }
+          });
+          const label = text("");
+          label.attributes = TextAttributes.BOLD;
+          box.add(label);
+          heading = { box, label };
+          headings.set(name, heading);
+        }
+        const collapsed = sections.collapsed.includes(name);
+        heading.box.border = desired.length ? ["top"] : false;
+        heading.box.borderColor = themeColor(ctx.theme.border, fg);
+        heading.box.height = desired.length ? 3 : 2;
+        heading.label.fg = name === "Priority" ? attentionColor : name === "Pinned" ? workerColor : accent;
+        const count = group.reduce((total, thread) => total + 1 + thread.children.length, 0);
+        heading.label.content = `${collapsed ? "\u25B8" : "\u25BE"} ${name} (${count})`;
+        desired.push(heading.box);
+        if (collapsed)
+          continue;
+        const displayed = group.flatMap((thread) => {
+          const collapsed2 = threadState.collapsed.includes(thread.item.id);
+          return [
+            {
+              item: thread.item,
+              depth: 0,
+              children: thread.children.length,
+              collapsed: collapsed2,
+              status: collapsed2 ? thread.status : thread.item
+            },
+            ...collapsed2 ? [] : thread.children.map((item) => ({
+              item,
+              depth: 1,
+              children: 0,
+              collapsed: false,
+              status: item
+            }))
+          ];
+        });
+        for (const { item, depth, children, collapsed: collapsed2, status } of displayed) {
+          keep.add(item.id);
+          let row = rows.get(item.id);
+          if (!row) {
+            const box = new BoxRenderable(ctx.renderer, {
+              id: `activity-row-${item.id}`,
+              height: 3,
+              flexShrink: 0,
+              flexDirection: "column"
+            });
+            const line = new BoxRenderable(ctx.renderer, {
+              height: 1,
+              flexShrink: 0,
+              flexDirection: "row"
+            });
+            const selected = text("");
+            selected.id = `activity-selected-${item.id}`;
+            selected.width = 2;
+            const status2 = new BoxRenderable(ctx.renderer, {
+              width: 2,
+              height: 1,
+              flexShrink: 0
+            });
+            const marker = text("");
+            marker.id = `activity-marker-${item.id}`;
+            status2.add(marker);
+            const title = text("");
+            title.id = `activity-title-${item.id}`;
+            title.flexShrink = 1;
+            title.minWidth = 0;
+            title.wrapMode = "none";
+            title.truncate = true;
+            const pinButton = text("");
+            pinButton.id = `activity-pin-${item.id}`;
+            pinButton.marginLeft = 2;
+            pinButton.width = 4;
+            const closeButton = text("");
+            closeButton.id = `activity-close-${item.id}`;
+            closeButton.marginLeft = 1;
+            closeButton.width = 4;
+            row = {
+              box,
+              selected,
+              status: status2,
+              marker,
+              spinner: undefined,
+              title,
+              subtitle: text(""),
+              workers: undefined,
+              pin: pinButton,
+              close: closeButton
+            };
+            line.add(selected);
+            line.add(status2);
+            line.add(title);
+            line.add(pinButton);
+            line.add(closeButton);
+            box.add(line);
+            row.subtitle.id = `activity-subtitle-${item.id}`;
+            row.subtitle.wrapMode = "none";
+            row.subtitle.truncate = true;
+            box.add(row.subtitle);
+            rows.set(item.id, row);
+          }
+          row.box.marginLeft = depth * 3;
+          row.box.height = children ? 5 : 3;
+          const running = status.busy && !status.attention;
+          if (running && !row.spinner) {
+            row.spinner = runningIndicator(item.id);
+            if (row.spinner)
+              row.status.add(row.spinner);
+          } else if (!running && row.spinner) {
+            row.spinner.destroy();
+            row.spinner = undefined;
+          }
+          if (row.spinner)
+            row.spinner.color = runningColor;
+          row.selected.content = item.active ? "> " : "  ";
+          row.selected.fg = accent;
+          row.selected.attributes = item.active ? TextAttributes.BOLD : 0;
+          row.marker.content = status.attention ? "?" : running ? "\u280B" : status.unread === "error" ? "!" : status.unread ? "\u2022" : " ";
+          row.marker.visible = !row.spinner;
+          row.marker.fg = status.attention ? attentionColor : running ? runningColor : status.unread === "error" ? themeColor(ctx.theme.text.feedback.error, fg) : accent;
+          row.title.content = item.title;
+          row.title.fg = status.attention ? attentionColor : item.active ? accent : fg;
+          row.subtitle.fg = muted;
+          row.title.attributes = item.active ? TextAttributes.BOLD : 0;
+          row.subtitle.content = `  ${item.subtitle}`;
+          if (children && !row.workers) {
+            row.workers = text("");
+            row.workers.id = `activity-workers-${item.id}`;
+            row.workers.marginLeft = 3;
+            row.workers.marginTop = 1;
+            row.workers.attributes = TextAttributes.BOLD;
+            row.workers.onMouseUp = (event) => {
+              event.stopPropagation();
+              if (event.button === 0)
+                toggleThread(item.id);
+            };
+            row.box.add(row.workers);
+          } else if (!children && row.workers) {
+            row.workers.destroy();
+            row.workers = undefined;
+          }
+          if (row.workers) {
+            row.workers.content = `${collapsed2 ? "\u25B8" : "\u25BE"} Workers (${children})`;
+            row.workers.fg = workerColor;
+          }
+          row.pin.content = item.pinned ? "[\u25C6] " : "[\u25C7] ";
+          row.pin.fg = item.pinned ? workerColor : muted;
+          row.pin.attributes = TextAttributes.BOLD;
+          row.pin.onMouseUp = (event) => {
+            event.stopPropagation();
+            if (event.button === 0)
+              pin(item.id);
+          };
+          row.close.content = "[\xD7] ";
+          row.close.fg = muted;
+          row.close.attributes = TextAttributes.BOLD;
+          row.close.onMouseUp = (event) => {
+            event.stopPropagation();
+            if (event.button === 0)
+              close(item.id);
+          };
+          row.box.onMouseUp = (event) => {
+            event.stopPropagation();
+            if (event.button === 0)
+              focus(item.id);
+            if (event.button === 2)
+              actions(item, children > 0);
+          };
+          desired.push(row.box);
+        }
+      }
+      for (const [id, row] of rows)
+        if (!keep.has(id)) {
+          row.box.destroyRecursively();
+          rows.delete(id);
+        }
+      for (const [name, heading] of headings)
+        if (!groups.has(name)) {
+          heading.box.destroyRecursively();
+          headings.delete(name);
+        }
+      for (const [index, node] of desired.entries())
+        if (scroll.getChildren()[index] !== node)
+          scroll.add(node, index);
+    };
+    render();
+    return () => {
+      render = () => {};
+    };
+  });
+  rail.toggle(ctx.options.activity !== false);
+  let refreshTimer;
+  const stopEvents = ctx.data.listen(({ details }) => {
+    if (!details.type.startsWith("session."))
+      return;
+    if (details.type === "session.deleted") {
+      const sessionID = details.data.sessionID;
+      deleted.add(sessionID);
+      sessions.delete(sessionID);
+      workers.delete(sessionID);
+      restore([sessionID]).catch(error);
+      if (pins.ids.includes(sessionID))
+        savePins((draft) => {
+          draft.ids = draft.ids.filter((id) => id !== sessionID);
+        }).catch(error);
+      changed();
+    }
+    if (details.type === "session.created") {
+      deleted.delete(details.data.sessionID);
+      changed();
+    }
+    if (!refreshTimer)
+      refreshTimer = setTimeout(() => {
+        refreshTimer = undefined;
+        load();
+      }, 1000);
+  });
+  const timer = setInterval(() => {
+    rail.invalidate();
+    changed();
+    load();
+  }, 30000);
+  const removeSlot = ctx.ui.slot({
+    append: "app",
+    render() {
+      let selected;
+      createEffect2(() => {
+        const route = ctx.ui.router.current();
+        const id = route.type === "session" ? route.sessionID : undefined;
+        if (id === selected)
+          return;
+        selected = id;
+        if (id && !closingRows.has(id))
+          restore([id]).catch(error);
+      });
+      createEffect2(() => {
+        ctx.themeMode;
+        themeColor(ctx.theme.text, fallbackColor);
+        themeColor(ctx.theme.border, fallbackColor);
+        sections.collapsed.length;
+        threadState.collapsed.length;
+        items();
+        render();
+        rail.invalidate();
+      });
+      ctx.keymap.layer(() => ({
+        mode: "global",
+        commands: [
+          {
+            id: "threads.activity.threads",
+            title: "Expand/collapse managed workers",
+            palette: true,
+            slash: { name: "activity-threads" },
+            async run() {
+              const id = await ctx.ui.dialog.select({
+                title: "Managed worker stacks",
+                options: [...items().values()].flat().filter((thread) => thread.children.length).map((thread) => ({
+                  title: `${threadState.collapsed.includes(thread.item.id) ? "Expand" : "Collapse"} ${thread.item.title}`,
+                  description: `${thread.children.length} workers`,
+                  value: thread.item.id
+                }))
+              });
+              if (id && !stopped)
+                await toggleThread(id);
+            }
+          },
+          {
+            id: "threads.activity.sections",
+            title: "Expand/collapse Activity section",
+            palette: true,
+            slash: { name: "activity-sections" },
+            async run() {
+              const name = await ctx.ui.dialog.select({
+                title: "Activity sections",
+                options: [...items()].map(([name2, group]) => ({
+                  title: `${sections.collapsed.includes(name2) ? "Expand" : "Collapse"} ${name2}`,
+                  description: `${group.reduce((total, thread) => total + 1 + thread.children.length, 0)} conversations`,
+                  value: name2
+                }))
+              });
+              if (name && !stopped)
+                await toggleSection(name);
+            }
+          },
+          {
+            id: "threads.activity.toggle",
+            title: "Toggle Activity sidebar",
+            palette: true,
+            slash: { name: "activity" },
+            run() {
+              rail.toggle();
+            }
+          },
+          {
+            id: "threads.activity.pin",
+            title: "Pin/unpin current Activity conversation",
+            palette: true,
+            slash: { name: "pin" },
+            async run() {
+              const route = ctx.ui.router.current();
+              if (route.type === "session")
+                await pin(route.sessionID);
+            }
+          },
+          {
+            id: "threads.activity.choose",
+            title: "Choose Activity conversation",
+            palette: true,
+            slash: { name: "activities" },
+            run() {
+              const route = ctx.ui.router.current();
+              ctx.ui.dialog.show(() => ActivityPicker({
+                ctx,
+                fallbackColor,
+                current: route.type === "session" ? route.sessionID : undefined,
+                items: () => [...items(true)].flatMap(([category, group]) => group.flatMap((thread) => [thread.item, ...thread.children]).map((item) => ({
+                  ...item,
+                  category,
+                  closed: dismissed.ids.includes(item.id)
+                }))),
+                pin,
+                open: focus
+              }));
+            }
+          }
+        ]
+      }));
+      return null;
+    }
+  });
+  load();
+  return {
+    mounted: rail.mounted,
+    isDismissed: (id) => closingRows.has(id) || dismissed.ids.includes(id),
+    restore,
+    updateWorkers(values) {
+      for (const worker of values)
+        workers.set(worker.workerID, worker);
+      changed();
+    },
+    dispose() {
+      stopped = true;
+      abort.abort();
+      clearInterval(timer);
+      clearTimeout(refreshTimer);
+      stopEvents();
+      removeSlot();
+      rail.dispose();
+    }
+  };
+}
+
+// src/workflow-ui.tsx
+import { memo as _$memo } from "@opentui/solid";
+import { insert as _$insert2 } from "@opentui/solid";
+import { createComponent as _$createComponent2 } from "@opentui/solid";
+import { createTextNode as _$createTextNode2 } from "@opentui/solid";
+import { insertNode as _$insertNode2 } from "@opentui/solid";
+import { setProp as _$setProp2 } from "@opentui/solid";
+import { createElement as _$createElement2 } from "@opentui/solid";
+import { createEffect as createEffect2, createSignal as createSignal2, For as For2, Show as Show2 } from "solid-js";
+
+// src/workflow-rpc.ts
+import { Rpc as Rpc2 } from "@opencode/plugin/rpc";
+import { z as z4 } from "zod";
+
+// src/workflow-types.ts
+import { z as z3 } from "zod";
+var WORKFLOW_CONTROL_HEADROOM = 64 * 1024;
+var Json = z3.json();
+var WorkflowModel = z3.object({
+  providerID: z3.string(),
+  id: z3.string(),
+  variant: z3.string().optional()
+});
+var WorkflowLimits = z3.object({
+  concurrency: z3.number().int().min(1).max(8).default(3),
+  maxAgents: z3.number().int().min(1).max(1000).default(4),
+  agentTimeoutMs: z3.number().int().min(1000).max(604800000).default(1800000),
+  timeoutMs: z3.number().int().min(1000).max(604800000).default(86400000),
+  tokenBudget: z3.number().int().positive().optional()
+});
+var WorkflowStart = WorkflowLimits.extend({
+  key: z3.string().min(1).max(120),
+  script: z3.string().min(1).max(200000).optional(),
+  name: z3.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,79}$/).optional(),
+  args: Json.default(null)
+}).strict().refine((value) => Boolean(value.script) !== Boolean(value.name), {
+  message: "Supply exactly one of script or saved workflow name"
+});
+var WorkflowAgentInput = z3.object({
+  key: z3.string().min(1).max(120),
+  prompt: z3.string().min(1).max(1e5),
+  agent: z3.string().min(1),
+  label: z3.string().min(1).max(160).optional(),
+  phase: z3.string().min(1).max(160).optional(),
+  schema: z3.record(z3.string(), Json).optional(),
+  access: z3.enum(["read", "write"]).default("read"),
+  isolation: z3.enum(["shared", "worktree"]).default("shared"),
+  directory: z3.string().min(1).optional(),
+  timeoutMs: z3.number().int().min(1000).max(604800000).optional()
+}).strict();
+var WorkflowResult = Report.extend({ result: Json }).strict();
+var WorkflowUsage = z3.object({
+  tokens: z3.number().nonnegative(),
+  cost: z3.number().nonnegative(),
+  measured: z3.boolean()
+});
+var StepBase = z3.object({
+  key: z3.string(),
+  fingerprint: z3.string(),
+  index: z3.number().int().nonnegative(),
+  input: WorkflowAgentInput,
+  workerID: z3.string(),
+  spawnKey: z3.string(),
+  created: z3.number(),
+  phase: z3.string(),
+  directory: z3.string(),
+  model: WorkflowModel,
+  profileFingerprint: z3.string()
+});
+var WorkflowStep = z3.discriminatedUnion("status", [
+  StepBase.extend({ status: z3.literal("prepared") }),
+  StepBase.extend({ status: z3.literal("running"), usage: WorkflowUsage.optional() }),
+  StepBase.extend({
+    status: z3.literal("completed"),
+    completed: z3.number(),
+    report: WorkflowResult,
+    usage: WorkflowUsage
+  }),
+  StepBase.extend({
+    status: z3.literal("failed"),
+    error: z3.string(),
+    retryable: z3.boolean(),
+    usage: WorkflowUsage.optional()
+  })
+]);
+var WorkflowCheckpoint = z3.object({
+  key: z3.string(),
+  prompt: z3.string(),
+  response: Json.optional()
+});
+var WorkflowSettlement = z3.discriminatedUnion("kind", [
+  z3.object({ kind: z3.literal("agent"), key: z3.string(), outcome: z3.enum(["success", "failure"]), error: z3.string().optional() }),
+  z3.object({ kind: z3.literal("checkpoint"), key: z3.string(), response: Json })
+]);
+var WorkflowRun = z3.object({
+  version: z3.literal(1),
+  id: z3.string(),
+  key: z3.string(),
+  ownerID: z3.string(),
+  callerAgent: z3.string(),
+  model: WorkflowModel,
+  projectID: z3.string(),
+  directory: z3.string(),
+  name: z3.string(),
+  description: z3.string(),
+  script: z3.string(),
+  args: Json,
+  fingerprint: z3.string(),
+  limits: WorkflowLimits,
+  status: z3.enum(["running", "pausing", "paused", "stopping", "stopped", "waiting", "interrupted", "failed", "completed"]),
+  created: z3.number(),
+  updated: z3.number(),
+  phase: z3.string(),
+  steps: z3.array(WorkflowStep),
+  logs: z3.array(z3.object({ time: z3.number(), text: z3.string() })),
+  checkpoints: z3.array(WorkflowCheckpoint),
+  settlements: z3.array(WorkflowSettlement).optional(),
+  result: Json.optional(),
+  error: z3.string().optional(),
+  deliveryID: z3.string(),
+  delivered: z3.boolean()
+});
+var WorkflowSummary = WorkflowRun.omit({ script: true, args: true, result: true, steps: true, logs: true, checkpoints: true, settlements: true, fingerprint: true, callerAgent: true, deliveryID: true, delivered: true }).extend({
+  counts: z3.object({ completed: z3.number(), running: z3.number(), failed: z3.number(), total: z3.number() }),
+  usage: WorkflowUsage
+});
+
+// src/workflow-rpc.ts
+var WorkflowControl = z4.object({
+  runID: z4.string().min(1),
+  action: z4.enum(["pause", "resume", "stop"]),
+  checkpointKey: z4.string().optional(),
+  response: Json.optional()
+}).strict();
+var WorkflowsRpc = Rpc2.define({
+  id: "workflows",
+  methods: {
+    snapshot: {
+      input: z4.object({ ownerID: z4.string() }).strict(),
+      output: z4.object({ runs: z4.array(WorkflowSummary) }),
+      errors: {}
+    },
+    inspect: {
+      input: z4.object({ ownerID: z4.string(), runID: z4.string() }).strict(),
+      output: WorkflowRun,
+      errors: {}
+    },
+    control: {
+      input: WorkflowControl.extend({ ownerID: z4.string() }).strict(),
+      output: WorkflowRun,
+      errors: {}
+    },
+    save: {
+      input: z4.object({ ownerID: z4.string(), runID: z4.string(), name: z4.string(), scope: z4.enum(["project", "user"]) }).strict(),
+      output: z4.object({ path: z4.string() }),
+      errors: {}
+    }
+  },
+  events: {
+    updated: { schema: z4.object({ ownerID: z4.string(), runID: z4.string() }) }
+  }
+});
+
+// src/workflow-ui.tsx
+function workflowUI(ctx) {
+  const rpc = ctx.client.rpc(WorkflowsRpc);
+  const [runs, setRuns] = createSignal2([]);
+  const [selected, setSelected] = createSignal2();
+  const [stepIndex, setStepIndex] = createSignal2(0);
+  const [error, setError] = createSignal2("");
+  const abort = new AbortController;
+  let owner = "";
+  let ownerGeneration = 0;
+  let refreshInFlight;
+  const location = () => ctx.location ?? ctx.data.location.default();
+  function ownerID() {
+    const route = ctx.ui.router.current();
+    if (route.type !== "session")
+      return;
+    const session = ctx.data.session.get(route.sessionID);
+    const link = session?.metadata?.opThreads;
+    return link && typeof link === "object" && "coordinatorID" in link && typeof link.coordinatorID === "string" ? link.coordinatorID : route.sessionID;
+  }
+  function synchronizeOwner() {
+    const current = ownerID() ?? "";
+    if (current !== owner) {
+      owner = current;
+      ownerGeneration += 1;
+      setRuns([]);
+      setSelected(undefined);
+    }
+    return current ? {
+      ownerID: current,
+      generation: ownerGeneration
+    } : undefined;
+  }
+  function isCurrent(context) {
+    const current = synchronizeOwner();
+    return !!current && current.ownerID === context.ownerID && current.generation === context.generation && !abort.signal.aborted;
+  }
+  function requestRefresh(context) {
+    let request;
+    request = (async () => {
+      try {
+        const snapshot = await rpc.snapshot({
+          ownerID: context.ownerID
+        }, {
+          location: location(),
+          signal: abort.signal
+        });
+        if (!isCurrent(context))
+          return;
+        setRuns(snapshot.runs);
+        const id = selected()?.id;
+        if (id) {
+          const run = await rpc.inspect({
+            ownerID: context.ownerID,
+            runID: id
+          }, {
+            location: location(),
+            signal: abort.signal
+          });
+          if (!isCurrent(context))
+            return;
+          if (selected()?.id === id)
+            setSelected(run);
+        }
+        setError("");
+        return {
+          context,
+          runs: snapshot.runs
+        };
+      } catch (cause) {
+        if (isCurrent(context))
+          setError(String(cause));
+      } finally {
+        if (refreshInFlight === request)
+          refreshInFlight = undefined;
+      }
+    })();
+    refreshInFlight = request;
+    return request;
+  }
+  function refreshInBackground() {
+    const context = synchronizeOwner();
+    if (!context || refreshInFlight || abort.signal.aborted)
+      return;
+    requestRefresh(context);
+  }
+  async function refreshFresh() {
+    synchronizeOwner();
+    while (refreshInFlight)
+      await refreshInFlight;
+    const context = synchronizeOwner();
+    if (!context || abort.signal.aborted)
+      return;
+    return requestRefresh(context);
+  }
+  async function openRun(id, expected = synchronizeOwner()) {
+    if (!expected || !isCurrent(expected))
+      return;
+    try {
+      const run = await rpc.inspect({
+        ownerID: expected.ownerID,
+        runID: id
+      }, {
+        location: location(),
+        signal: abort.signal
+      });
+      if (!isCurrent(expected))
+        return;
+      setSelected(run);
+      setStepIndex(0);
+      ctx.ui.panel.open("threads.workflows");
+    } catch (cause) {
+      ctx.ui.toast.show({
+        message: String(cause),
+        variant: "error"
+      });
+    }
+  }
+  async function choose() {
+    const fresh = await refreshFresh();
+    if (!fresh || !isCurrent(fresh.context))
+      return;
+    if (!fresh.runs.length) {
+      ctx.ui.toast.show({
+        message: "No workflows yet. Use /workflow-run to describe a task.",
+        variant: "info"
+      });
+      return;
+    }
+    const id = await ctx.ui.dialog.select({
+      title: "Dynamic workflows",
+      options: fresh.runs.map((run) => ({
+        title: `${run.name} \xB7 ${run.status}`,
+        description: `${run.counts.completed}/${run.counts.total} recorded steps \xB7 ${run.phase || "starting"} \xB7 ${run.usage.measured ? "" : "\u2265"}${run.usage.tokens} tokens`,
+        value: run.id
+      }))
+    });
+    if (id && fresh.runs.some((run) => run.id === id) && isCurrent(fresh.context))
+      await openRun(id, fresh.context);
+  }
+  function canControl(action) {
+    const run = selected();
+    const status = run?.status;
+    if (!status || run.ownerID !== ownerID())
+      return false;
+    if (action === "pause")
+      return status === "running";
+    if (action === "resume")
+      return status === "paused" || status === "interrupted" || status === "waiting";
+    return status === "running" || status === "pausing" || status === "paused" || status === "interrupted" || status === "waiting";
+  }
+  async function control(action) {
+    const run = selected();
+    const context = synchronizeOwner();
+    if (!run || !context || run.ownerID !== context.ownerID || !canControl(action))
+      return;
+    try {
+      const checkpoint = run.checkpoints.find((item) => item.response === undefined);
+      let answer;
+      if (action === "resume" && checkpoint) {
+        const text = await ctx.ui.dialog.prompt({
+          title: checkpoint.prompt,
+          placeholder: "JSON response, for example true or a quoted string"
+        });
+        if (text === undefined)
+          return;
+        if (!isCurrent(context) || selected()?.id !== run.id)
+          return;
+        answer = Json.parse(JSON.parse(text));
+      }
+      const result = await rpc.control({
+        ownerID: run.ownerID,
+        runID: run.id,
+        action,
+        ...checkpoint && action === "resume" ? {
+          checkpointKey: checkpoint.key,
+          response: answer
+        } : {}
+      }, {
+        location: location(),
+        signal: abort.signal
+      });
+      if (!isCurrent(context) || selected()?.id !== run.id)
+        return;
+      setSelected(result);
+      await refreshFresh();
+    } catch (cause) {
+      ctx.ui.toast.show({
+        message: String(cause),
+        variant: "error"
+      });
+    }
+  }
+  async function save() {
+    const run = selected();
+    if (!run)
+      return;
+    const name = await ctx.ui.dialog.prompt({
+      title: "Save workflow",
+      placeholder: run.name
+    });
+    if (!name)
+      return;
+    const scope = await ctx.ui.dialog.select({
+      title: "Save location",
+      options: [{
+        title: "Project",
+        value: "project"
+      }, {
+        title: "User",
+        value: "user"
+      }]
+    });
+    if (!scope)
+      return;
+    try {
+      const output = await rpc.save({
+        ownerID: run.ownerID,
+        runID: run.id,
+        name,
+        scope
+      }, {
+        location: location(),
+        signal: abort.signal
+      });
+      ctx.ui.toast.show({
+        message: `Saved ${ctx.ui.format.path(output.path)}`,
+        variant: "success"
+      });
+    } catch (cause) {
+      ctx.ui.toast.show({
+        message: String(cause),
+        variant: "error"
+      });
+    }
+  }
+  const removePanel = ctx.ui.slot({
+    append: "session.panel",
+    render: (panel) => {
+      const moveStep = (delta) => {
+        const length = selected()?.steps.length ?? 0;
+        if (length)
+          setStepIndex((index) => (index + delta + length) % length);
+      };
+      const openStep = () => {
+        const step = selected()?.steps[stepIndex()];
+        if (!step || step.status === "prepared")
+          return;
+        panel.close();
+        ctx.ui.router.navigate({
+          type: "session",
+          sessionID: step.workerID
+        });
+      };
+      ctx.keymap.layer(() => ({
+        commands: panel.name === "threads.workflows" ? [{
+          id: "workflows.pause",
+          bind: "p",
+          title: "Pause workflow",
+          enabled: () => canControl("pause"),
+          run: () => control("pause")
+        }, {
+          id: "workflows.resume",
+          bind: "r",
+          title: "Resume workflow",
+          enabled: () => canControl("resume"),
+          run: () => control("resume")
+        }, {
+          id: "workflows.stop",
+          bind: "x",
+          title: "Stop workflow",
+          enabled: () => canControl("stop"),
+          run: () => control("stop")
+        }, {
+          id: "workflows.save",
+          bind: "s",
+          title: "Save workflow",
+          run: save
+        }, {
+          id: "workflows.previous-step",
+          bind: "up",
+          title: "Previous workflow step",
+          run: () => moveStep(-1)
+        }, {
+          id: "workflows.next-step",
+          bind: "down",
+          title: "Next workflow step",
+          run: () => moveStep(1)
+        }, {
+          id: "workflows.open-step",
+          bind: "return",
+          title: "Open workflow worker",
+          run: openStep
+        }, {
+          id: "workflows.fullscreen",
+          bind: "f",
+          title: "Toggle workflow fullscreen",
+          run: panel.toggleFullscreen
+        }, {
+          id: "workflows.close",
+          bind: "escape",
+          run: panel.close
+        }] : []
+      }));
+      return _$createComponent2(Show2, {
+        get when() {
+          return panel.name === "threads.workflows";
+        },
+        get children() {
+          var _el$ = _$createElement2("scrollbox"), _el$2 = _$createElement2("text"), _el$3 = _$createElement2("b");
+          _$insertNode2(_el$, _el$2);
+          _$setProp2(_el$, "flexGrow", 1);
+          _$setProp2(_el$, "padding", 1);
+          _$insertNode2(_el$2, _el$3);
+          _$insertNode2(_el$3, _$createTextNode2(`Dynamic workflows`));
+          _$insert2(_el$, _$createComponent2(Show2, {
+            get when() {
+              return selected();
+            },
+            children: (run) => (() => {
+              var _el$6 = _$createElement2("box"), _el$7 = _$createElement2("text"), _el$8 = _$createElement2("b"), _el$9 = _$createElement2("text"), _el$0 = _$createElement2("text"), _el$1 = _$createElement2("text"), _el$10 = _$createElement2("text");
+              _$insertNode2(_el$6, _el$7);
+              _$insertNode2(_el$6, _el$9);
+              _$insertNode2(_el$6, _el$0);
+              _$insertNode2(_el$6, _el$1);
+              _$insertNode2(_el$6, _el$10);
+              _$setProp2(_el$6, "flexDirection", "column");
+              _$setProp2(_el$6, "gap", 1);
+              _$insertNode2(_el$7, _el$8);
+              _$insert2(_el$8, () => run().name);
+              _$insert2(_el$7, () => ` \xB7 ${run().status}`, null);
+              _$insert2(_el$9, () => run().description);
+              _$insert2(_el$0, () => `Run: ${run().id}`);
+              _$insert2(_el$1, () => `Phase: ${run().phase || "starting"}`);
+              _$insert2(_el$10, () => [...canControl("pause") ? ["p pause"] : [], ...canControl("resume") ? ["r resume"] : [], ...canControl("stop") ? ["x stop"] : [], "s save", "f fullscreen", "Esc close"].join(" \xB7 "));
+              _$insert2(_el$6, _$createComponent2(Show2, {
+                get when() {
+                  return run().steps.length > 0;
+                },
+                get children() {
+                  var _el$11 = _$createElement2("text");
+                  _$insertNode2(_el$11, _$createTextNode2(`\u2191/\u2193 select step \xB7 Enter open worker`));
+                  return _el$11;
+                }
+              }), null);
+              _$insert2(_el$6, _$createComponent2(Show2, {
+                get when() {
+                  return run().error;
+                },
+                get children() {
+                  var _el$13 = _$createElement2("text");
+                  _$insert2(_el$13, () => `Error: ${run().error}`);
+                  return _el$13;
+                }
+              }), null);
+              _$insert2(_el$6, _$createComponent2(For2, {
+                get each() {
+                  return run().steps;
+                },
+                children: (step, index) => (() => {
+                  var _el$15 = _$createElement2("box"), _el$16 = _$createElement2("text"), _el$17 = _$createElement2("b"), _el$18 = _$createElement2("text"), _el$19 = _$createElement2("text"), _el$20 = _$createElement2("text");
+                  _$insertNode2(_el$15, _el$16);
+                  _$insertNode2(_el$15, _el$18);
+                  _$insertNode2(_el$15, _el$19);
+                  _$insertNode2(_el$15, _el$20);
+                  _$setProp2(_el$15, "flexDirection", "column");
+                  _$setProp2(_el$15, "border", true);
+                  _$setProp2(_el$15, "padding", 1);
+                  _$setProp2(_el$15, "onMouseUp", () => {
+                    setStepIndex(index());
+                    openStep();
+                  });
+                  _$insertNode2(_el$16, _el$17);
+                  _$insert2(_el$16, () => index() === stepIndex() ? "\u203A " : "  ", _el$17);
+                  _$insert2(_el$17, () => step.input.label ?? step.key);
+                  _$insert2(_el$16, () => ` \xB7 ${step.status}`, null);
+                  _$insert2(_el$18, () => `${step.phase} \xB7 ${step.input.agent} \xB7 ${step.model.providerID}/${step.model.id}`);
+                  _$insert2(_el$19, () => ctx.ui.format.path(step.directory));
+                  _$insert2(_el$15, _$createComponent2(Show2, {
+                    get when() {
+                      return step.status === "completed" && step;
+                    },
+                    children: (done) => [(() => {
+                      var _el$21 = _$createElement2("text");
+                      _$insert2(_el$21, () => `${done().report.verdict}: ${done().report.summary}`);
+                      return _el$21;
+                    })(), (() => {
+                      var _el$22 = _$createElement2("text");
+                      _$insert2(_el$22, () => `${done().usage.measured ? "" : "unmeasured \xB7 "}${done().usage.tokens} tokens \xB7 $${done().usage.cost.toFixed(4)}`);
+                      return _el$22;
+                    })(), _$createComponent2(For2, {
+                      get each() {
+                        return done().report.evidence;
+                      },
+                      children: (evidence) => (() => {
+                        var _el$23 = _$createElement2("text");
+                        _$insert2(_el$23, evidence);
+                        return _el$23;
+                      })()
+                    })]
+                  }), _el$20);
+                  _$insert2(_el$15, _$createComponent2(Show2, {
+                    get when() {
+                      return step.status === "failed" && step;
+                    },
+                    children: (failed) => (() => {
+                      var _el$24 = _$createElement2("text");
+                      _$insert2(_el$24, () => failed().error);
+                      return _el$24;
+                    })()
+                  }), _el$20);
+                  _$insert2(_el$20, () => step.status === "prepared" ? "Waiting for worker admission" : "Click or select and press Enter to open worker");
+                  return _el$15;
+                })()
+              }), null);
+              _$insert2(_el$6, _$createComponent2(For2, {
+                get each() {
+                  return run().checkpoints;
+                },
+                children: (checkpoint) => (() => {
+                  var _el$25 = _$createElement2("text");
+                  _$insert2(_el$25, () => `${checkpoint.response === undefined ? "Waiting" : "Answered"}: ${checkpoint.prompt}`);
+                  return _el$25;
+                })()
+              }), null);
+              _$insert2(_el$6, _$createComponent2(For2, {
+                get each() {
+                  return run().logs.slice(-30);
+                },
+                children: (entry) => (() => {
+                  var _el$26 = _$createElement2("text");
+                  _$insert2(_el$26, () => entry.text);
+                  return _el$26;
+                })()
+              }), null);
+              _$insert2(_el$6, _$createComponent2(Show2, {
+                get when() {
+                  return run().result !== undefined;
+                },
+                get children() {
+                  var _el$14 = _$createElement2("text");
+                  _$insert2(_el$14, () => `Result:
+${JSON.stringify(run().result, null, 2)}`);
+                  return _el$14;
+                }
+              }), null);
+              return _el$6;
+            })()
+          }), null);
+          _$insert2(_el$, _$createComponent2(Show2, {
+            get when() {
+              return error();
+            },
+            get children() {
+              var _el$5 = _$createElement2("text");
+              _$insert2(_el$5, error);
+              return _el$5;
+            }
+          }), null);
+          return _el$;
+        }
+      });
+    }
+  });
+  const removeFooter = ctx.ui.slot({
+    append: "session.composer.top",
+    render: () => {
+      createEffect2(() => {
+        ownerID();
+        refreshInBackground();
+      });
+      return _$createComponent2(Show2, {
+        get when() {
+          return runs().find((run) => ["running", "pausing", "waiting"].includes(run.status));
+        },
+        children: (run) => (() => {
+          var _el$27 = _$createElement2("box"), _el$28 = _$createElement2("text");
+          _$insertNode2(_el$27, _el$28);
+          _$setProp2(_el$27, "onMouseUp", () => void openRun(run().id));
+          _$insert2(_el$28, () => `Workflow ${run().name}: ${run().status} \xB7 ${run().counts.completed}/${run().counts.total} recorded steps \xB7 /workflows`);
+          return _el$27;
+        })()
+      });
+    }
+  });
+  const removeCommands = ctx.ui.slot({
+    append: "app",
+    render: () => {
+      ctx.keymap.layer(() => ({
+        mode: "global",
+        commands: [{
+          id: "workflows.open",
+          title: "Open dynamic workflows",
+          palette: true,
+          slash: {
+            name: "workflows"
+          },
+          run: choose
+        }]
+      }));
+      return null;
+    }
+  });
+  const stopEvents = ctx.data.listen(({
+    details
+  }) => {
+    if (details.type.startsWith("session.") || details.type.startsWith("rpc.workflows."))
+      refreshInBackground();
+  });
+  const timer = setInterval(refreshInBackground, 3000);
+  return () => {
+    abort.abort();
+    clearInterval(timer);
+    stopEvents();
+    removePanel();
+    removeFooter();
+    removeCommands();
+  };
+}
+
+// tui.ts
+import {
+  BoxRenderable,
+  ScrollBoxRenderable,
+  TextRenderable,
+  TextAttributes,
+  RGBA
+} from "@opentui/core";
+var CoordinatorRef = z5.object({ coordinatorID: z5.string() });
+var tui_default = Plugin.define({
+  id: "op-threads",
+  setup(ctx) {
+    const stopWorkflows = workflowUI(ctx);
+    const rpc = ctx.client.rpc(ThreadsRpc);
+    const sidebar = activity(ctx, { BoxRenderable, ScrollBoxRenderable, TextRenderable, TextAttributes, RGBA }, { createEffect: createEffect3, createSignal: createSignal3 }, getComponentCatalogue().spinner);
+    const [cleaned, saveCleaned] = ctx.storage.store("role-title-cleanup", {
+      initial: { ids: [] }
+    });
+    const initial = { workerIDs: [] };
+    const [seen, updateSeen] = ctx.storage.memory("seen-workers", { initial });
+    const closing = new Set;
+    const abort = new AbortController;
+    let stopped = false;
+    let running = false;
+    let reopenPending = false;
+    let lastError;
+    let movingFrom;
+    function groupTabs() {
+      if (sidebar.mounted())
+        return;
+      const tabs = ctx.ui.tabs.list().map((tab) => {
+        const projectID = ctx.data.session.get(tab.sessionID)?.projectID;
+        return {
+          sessionID: tab.sessionID,
+          priority: tab.busy || tab.attention,
+          projectID: typeof projectID === "string" && projectID.length > 0 ? projectID : undefined
+        };
+      });
+      const groups = new Map;
+      for (const tab of tabs) {
+        const key = tab.projectID === undefined ? `session:${tab.sessionID}` : `project:${tab.projectID}`;
+        const group = groups.get(key);
+        if (group)
+          group.push(tab);
+        else
+          groups.set(key, [tab]);
+      }
+      const ordered = [...groups.values()].flatMap((group) => group.sort((left, right) => Number(right.priority) - Number(left.priority)).map((tab) => tab.sessionID));
+      const current = tabs.map((tab) => tab.sessionID);
+      const stamp = JSON.stringify(current);
+      if (movingFrom === stamp)
+        return;
+      movingFrom = undefined;
+      for (const [index, sessionID] of ordered.entries()) {
+        if (current[index] === sessionID)
+          continue;
+        if (ctx.ui.tabs.move(sessionID, index))
+          movingFrom = stamp;
+        break;
+      }
+    }
+    async function reconcile(reopen = false) {
+      if (stopped || !ctx.ui.tabs.enabled())
+        return;
+      if (running) {
+        reopenPending ||= reopen;
+        return;
+      }
+      running = true;
+      try {
+        groupTabs();
+        const route = ctx.ui.router.current();
+        const coordinatorIDs = [
+          ...new Set([
+            ...ctx.ui.tabs.list().flatMap((tab) => {
+              const link = CoordinatorRef.safeParse(ctx.data.session.get(tab.sessionID)?.metadata?.opThreads);
+              return link.success ? [tab.sessionID, link.data.coordinatorID] : [tab.sessionID];
+            }),
+            ...route.type === "session" ? [route.sessionID] : []
+          ])
+        ].slice(0, 100);
+        if (!coordinatorIDs.length)
+          return;
+        const { workers } = await (reopen ? rpc.restore : rpc.snapshot)({ coordinatorIDs }, {
+          location: ctx.location ?? ctx.data.location.default(),
+          signal: abort.signal
+        });
+        if (reopen)
+          await sidebar.restore(workers.map((worker) => worker.workerID));
+        sidebar.updateWorkers(workers);
+        for (const worker of workers) {
+          if (stopped)
+            return;
+          if (!reopen && sidebar.isDismissed(worker.workerID))
+            continue;
+          const tab = ctx.ui.tabs.list().find((tab2) => tab2.sessionID === worker.workerID);
+          if (closing.has(worker.workerID) && tab)
+            continue;
+          const closed = closing.delete(worker.workerID);
+          if (worker.hidden && !tab?.active && !tab?.busy && !tab?.attention && ctx.data.session.status(worker.workerID) !== "running") {
+            if (tab) {
+              if (!ctx.ui.tabs.close(worker.workerID))
+                continue;
+              closing.add(worker.workerID);
+            }
+            if (seen.workerIDs.includes(worker.workerID)) {
+              updateSeen((draft) => {
+                draft.workerIDs = draft.workerIDs.filter((id) => id !== worker.workerID);
+              });
+            }
+            continue;
+          }
+          if (!reopen && !closed && seen.workerIDs.includes(worker.workerID))
+            continue;
+          await ctx.data.session.sync(worker.workerID);
+          if (!stopped && ctx.ui.tabs.open(worker.workerID) && !seen.workerIDs.includes(worker.workerID)) {
+            updateSeen((draft) => {
+              draft.workerIDs.push(worker.workerID);
+            });
+          }
+        }
+        if (!stopped && ctx.ui.tabs.enabled()) {
+          const roles = new Map;
+          for (const worker of workers) {
+            roles.set(worker.coordinatorID, "Main");
+            roles.set(worker.workerID, "Worker");
+          }
+          for (const tab of ctx.ui.tabs.list()) {
+            if (stopped)
+              return;
+            const role = roles.get(tab.sessionID);
+            const session = ctx.data.session.get(tab.sessionID);
+            if (!role || !session || cleaned.ids.includes(tab.sessionID))
+              continue;
+            const fresh = await ctx.client.session.get({ sessionID: tab.sessionID }, { signal: abort.signal });
+            if (stopped)
+              return;
+            const title = cleanRoleTitle(fresh.title ?? "", true);
+            if (title && title !== fresh.title)
+              await ctx.client.session.update({ sessionID: tab.sessionID, title }, { signal: abort.signal });
+            if (stopped)
+              return;
+            await saveCleaned((draft) => {
+              if (!draft.ids.includes(tab.sessionID))
+                draft.ids.push(tab.sessionID);
+            });
+          }
+          groupTabs();
+        }
+        lastError = undefined;
+      } catch (error) {
+        const message = `Managed worker tabs: ${String(error)}`;
+        if (!stopped && message !== lastError)
+          ctx.ui.toast.show({ message, variant: "error" });
+        lastError = message;
+      } finally {
+        running = false;
+        if (reopenPending) {
+          reopenPending = false;
+          reconcile(true);
+        }
+      }
+    }
+    const refresh = () => {
+      reconcile();
+    };
+    const stopEvents = ctx.data.listen(({ details }) => {
+      if (details.type.startsWith("session."))
+        refresh();
+    });
+    const timer = setInterval(refresh, 3000);
+    const removeSlot = ctx.ui.slot({
+      append: "app",
+      render: () => {
+        createEffect3(() => {
+          ctx.ui.tabs.list();
+          refresh();
+        });
+        ctx.keymap.layer(() => ({
+          mode: "global",
+          commands: [
+            {
+              id: "threads.reopen",
+              title: "Reopen managed worker tabs",
+              palette: true,
+              slash: { name: "threads" },
+              run: () => reconcile(true)
+            }
+          ]
+        }));
+        return null;
+      }
+    });
+    refresh();
+    return () => {
+      stopWorkflows();
+      stopped = true;
+      abort.abort();
+      sidebar.dispose();
+      clearInterval(timer);
+      stopEvents();
+      removeSlot();
+    };
+  }
+});
+export {
+  tui_default as default
+};