@lumea-labs/orchestrator 0.1.0

package/dist/run-kanban-filter-menu.js

@@ -0,0 +1,152 @@
+"use client";
+import { useEffect, useRef, useState } from "react";
+import { createPortal } from "react-dom";
+import { Check, ChevronDown, Filter } from "lucide-react";
+function RunKanbanFilterMenu({
+  lanes,
+  value,
+  onChange,
+  hideEmpty = false,
+  triggerLabel = "Filter",
+  className
+}) {
+  const [open, setOpen] = useState(false);
+  const triggerRef = useRef(null);
+  const [pos, setPos] = useState(null);
+  const visibleLanes = hideEmpty ? lanes.filter((l) => l.count > 0) : lanes;
+  const allKeys = visibleLanes.map((l) => l.key);
+  const visibleCount = allKeys.filter((k) => value.has(k)).length;
+  const allOn = visibleCount === allKeys.length && allKeys.length > 0;
+  useEffect(() => {
+    if (!open) return;
+    const place = () => {
+      const r = triggerRef.current?.getBoundingClientRect();
+      if (!r) return;
+      const W = 220;
+      const left = Math.min(r.left, window.innerWidth - W - 8);
+      const top = r.bottom + 6;
+      setPos({ top, left });
+    };
+    place();
+    window.addEventListener("resize", place);
+    window.addEventListener("scroll", place, true);
+    return () => {
+      window.removeEventListener("resize", place);
+      window.removeEventListener("scroll", place, true);
+    };
+  }, [open]);
+  useEffect(() => {
+    if (!open) return;
+    const onPointer = (e) => {
+      const t = e.target;
+      if (triggerRef.current?.contains(t)) return;
+      const menu = document.getElementById("run-kanban-filter-menu");
+      if (menu?.contains(t)) return;
+      setOpen(false);
+    };
+    const onKey = (e) => {
+      if (e.key === "Escape") setOpen(false);
+    };
+    window.addEventListener("pointerdown", onPointer, true);
+    window.addEventListener("keydown", onKey);
+    return () => {
+      window.removeEventListener("pointerdown", onPointer, true);
+      window.removeEventListener("keydown", onKey);
+    };
+  }, [open]);
+  const toggle = (key) => {
+    const next = new Set(value);
+    if (next.has(key)) next.delete(key);
+    else next.add(key);
+    onChange(next);
+  };
+  const setAll = () => onChange(new Set(allKeys));
+  const clearAll = () => onChange(/* @__PURE__ */ new Set());
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(
+    "button",
+    {
+      ref: triggerRef,
+      type: "button",
+      onClick: () => setOpen((v) => !v),
+      "aria-haspopup": "menu",
+      "aria-expanded": open,
+      className: [
+        "inline-flex items-center gap-1.5 rounded-md border border-p-line bg-p-surface px-2.5 py-1 font-mono text-[10.5px] font-bold uppercase tracking-[0.16em] text-p-ink-2 transition-colors cursor-pointer hover:border-p-ink-3 hover:text-p-ink",
+        open ? "border-p-ink-3 text-p-ink" : "",
+        className || ""
+      ].join(" ")
+    },
+    /* @__PURE__ */ React.createElement(Filter, { className: "size-3" }),
+    /* @__PURE__ */ React.createElement("span", null, triggerLabel),
+    /* @__PURE__ */ React.createElement("span", { className: "rounded-full bg-p-warm px-1.5 py-px font-mono text-[9.5px] tabular-nums text-p-ink" }, visibleCount, /* @__PURE__ */ React.createElement("span", { className: "text-p-ink-3" }, "/", allKeys.length)),
+    /* @__PURE__ */ React.createElement(
+      ChevronDown,
+      {
+        className: [
+          "size-3 transition-transform",
+          open ? "rotate-180" : ""
+        ].join(" ")
+      }
+    )
+  ), open && pos && typeof document !== "undefined" ? createPortal(
+    /* @__PURE__ */ React.createElement(
+      "div",
+      {
+        id: "run-kanban-filter-menu",
+        role: "menu",
+        style: { left: pos.left, top: pos.top, width: 220 },
+        className: "fixed z-[120] overflow-hidden rounded-md border border-p-line bg-p-surface shadow-[0_12px_40px_-16px_rgba(0,0,0,0.25)]"
+      },
+      /* @__PURE__ */ React.createElement("div", { className: "flex items-center justify-between border-b border-p-line px-2.5 py-1.5" }, /* @__PURE__ */ React.createElement("span", { className: "font-mono text-[9.5px] font-bold uppercase tracking-[0.18em] text-p-ink-3" }, "show lanes"), /* @__PURE__ */ React.createElement(
+        "button",
+        {
+          type: "button",
+          onClick: allOn ? clearAll : setAll,
+          className: "font-mono text-[9.5px] font-bold uppercase tracking-[0.16em] text-p-ink-3 transition-colors cursor-pointer hover:text-p-ink"
+        },
+        allOn ? "clear" : "all"
+      )),
+      /* @__PURE__ */ React.createElement("ul", { className: "max-h-[280px] overflow-y-auto py-1" }, visibleLanes.map((lane) => {
+        const active = value.has(lane.key);
+        return /* @__PURE__ */ React.createElement("li", { key: lane.key }, /* @__PURE__ */ React.createElement(
+          "button",
+          {
+            type: "button",
+            role: "menuitemcheckbox",
+            "aria-checked": active,
+            onClick: () => toggle(lane.key),
+            className: "flex w-full items-center gap-2 border-0 bg-transparent px-2.5 py-1.5 text-left transition-colors cursor-pointer hover:bg-p-warm"
+          },
+          /* @__PURE__ */ React.createElement(
+            "span",
+            {
+              "aria-hidden": true,
+              className: [
+                "grid size-4 shrink-0 place-items-center rounded border",
+                active ? "border-p-ink bg-p-ink text-p-bg" : "border-p-line bg-p-surface text-transparent"
+              ].join(" ")
+            },
+            /* @__PURE__ */ React.createElement(Check, { className: "size-3" })
+          ),
+          lane.dotClassName ? /* @__PURE__ */ React.createElement(
+            "span",
+            {
+              "aria-hidden": true,
+              className: [
+                "size-1.5 shrink-0 rounded-full",
+                lane.dotClassName,
+                active ? "" : "opacity-50"
+              ].join(" ")
+            }
+          ) : null,
+          /* @__PURE__ */ React.createElement("span", { className: "min-w-0 flex-1 truncate font-body text-[12.5px] text-p-ink" }, lane.label),
+          /* @__PURE__ */ React.createElement("span", { className: "font-mono text-[10px] tabular-nums text-p-ink-3" }, lane.count)
+        ));
+      }))
+    ),
+    document.body
+  ) : null);
+}
+export {
+  RunKanbanFilterMenu
+};

package/dist/run-kanban.d.ts

@@ -0,0 +1,61 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { RunKanbanLabels } from './plan-types.js';
+import { SwarmRun, SwarmRunStatus, SwarmLabels } from './types.js';
+
+type RunKanbanGroupBy = "status" | "agent";
+interface RunKanbanProps {
+    runs: SwarmRun[];
+    /** Default `"status"` — lanes are pending / running / done / failed.
+     *  `"agent"` swaps to one lane per agent. */
+    groupBy?: RunKanbanGroupBy;
+    now?: number;
+    renderAvatar?: (agent: SwarmRun["agent"]) => ReactNode;
+    onCancel?: (id: string) => void;
+    onRetry?: (id: string) => void;
+    onOpen?: (id: string) => void;
+    /** Override the default lane order (only relevant for `groupBy="status"`). */
+    statusOrder?: SwarmRunStatus[];
+    /** Lane keys to render. When provided, lanes whose key isn't in
+     *  the set are hidden. Use together with `<RunKanbanFilters>` for a
+     *  Linear-style toggleable filter strip. Omit for "show all". */
+    visibleKeys?: ReadonlySet<string>;
+    labels?: Partial<RunKanbanLabels>;
+    swarmLabels?: Partial<SwarmLabels>;
+    className?: string;
+}
+interface RunKanbanLaneSummary {
+    key: string;
+    label: string;
+    count: number;
+    /** Tailwind class for the dot tone — only set in `groupBy="status"` mode. */
+    dotClassName?: string;
+}
+/**
+ * Project the same lanes the kanban would render — useful to feed
+ * `<RunKanbanFilters>` without recomputing the grouping in the
+ * consumer.
+ */
+declare function summariseRunKanbanLanes(runs: SwarmRun[], opts?: {
+    groupBy?: RunKanbanGroupBy;
+    statusOrder?: SwarmRunStatus[];
+    labels?: Partial<RunKanbanLabels>;
+}): RunKanbanLaneSummary[];
+interface RunKanbanFiltersProps {
+    lanes: RunKanbanLaneSummary[];
+    /** Currently-visible lane keys. */
+    value: ReadonlySet<string>;
+    onChange: (next: Set<string>) => void;
+    /** Show only lanes that have at least one item. Default `false`. */
+    hideEmpty?: boolean;
+    className?: string;
+}
+/**
+ * Linear-style filter strip — one chip per lane with the count and a
+ * checkmark dot. Click toggles the lane's visibility in the kanban.
+ * Pure UI; the consumer holds the visibility set.
+ */
+declare function RunKanbanFilters({ lanes, value, onChange, hideEmpty, className, }: RunKanbanFiltersProps): react.JSX.Element;
+declare function RunKanban({ runs, groupBy, now, renderAvatar, onCancel, onRetry, onOpen, statusOrder, visibleKeys, labels, swarmLabels, className, }: RunKanbanProps): react.JSX.Element;
+
+export { RunKanban, RunKanbanFilters, type RunKanbanFiltersProps, type RunKanbanGroupBy, type RunKanbanLaneSummary, type RunKanbanProps, summariseRunKanbanLanes };

package/dist/run-kanban.js

@@ -0,0 +1,234 @@
+"use client";
+import { useMemo } from "react";
+import {
+  defaultRunKanbanLabels
+} from "./plan-types";
+import {
+  defaultSwarmLabels
+} from "./types";
+import { SwarmRunCard } from "./swarm-run-card";
+function summariseRunKanbanLanes(runs, opts) {
+  const groupBy = opts?.groupBy ?? "status";
+  const statusOrder = opts?.statusOrder ?? DEFAULT_STATUS_ORDER;
+  const L = { ...defaultRunKanbanLabels, ...opts?.labels };
+  if (groupBy === "agent") {
+    const byAgent = /* @__PURE__ */ new Map();
+    for (const r of runs) {
+      const e = byAgent.get(r.agent.name);
+      if (e) e.count += 1;
+      else
+        byAgent.set(r.agent.name, {
+          label: r.agent.displayName ?? r.agent.name,
+          count: 1
+        });
+    }
+    return Array.from(byAgent, ([key, v]) => ({
+      key,
+      label: v.label,
+      count: v.count
+    }));
+  }
+  const counts = /* @__PURE__ */ new Map();
+  for (const s of statusOrder) counts.set(s, 0);
+  for (const r of runs) {
+    counts.set(r.status, (counts.get(r.status) ?? 0) + 1);
+  }
+  return statusOrder.map((s) => ({
+    key: s,
+    label: s === "scheduled" ? L.scheduled : s === "pending" ? L.pending : s === "running" ? L.running : s === "done" ? L.done : s === "failed" ? L.failed : L.cancelled,
+    count: counts.get(s) ?? 0,
+    dotClassName: STATUS_DOT[s]
+  }));
+}
+function RunKanbanFilters({
+  lanes,
+  value,
+  onChange,
+  hideEmpty = false,
+  className
+}) {
+  const visibleLanes = hideEmpty ? lanes.filter((l) => l.count > 0) : lanes;
+  const toggle = (key) => {
+    const next = new Set(value);
+    if (next.has(key)) next.delete(key);
+    else next.add(key);
+    onChange(next);
+  };
+  const allVisible = visibleLanes.every((l) => value.has(l.key));
+  return /* @__PURE__ */ React.createElement(
+    "div",
+    {
+      className: [
+        "flex flex-wrap items-center gap-1.5",
+        className || ""
+      ].join(" ")
+    },
+    /* @__PURE__ */ React.createElement(
+      "button",
+      {
+        type: "button",
+        onClick: () => onChange(allVisible ? /* @__PURE__ */ new Set() : new Set(visibleLanes.map((l) => l.key))),
+        className: "inline-flex items-center gap-1 rounded-full border border-p-line bg-p-surface px-2 py-1 font-mono text-[9.5px] font-bold uppercase tracking-[0.16em] text-p-ink-3 transition-colors cursor-pointer hover:border-p-ink-3 hover:text-p-ink"
+      },
+      allVisible ? "clear" : "all"
+    ),
+    visibleLanes.map((lane) => {
+      const active = value.has(lane.key);
+      return /* @__PURE__ */ React.createElement(
+        "button",
+        {
+          key: lane.key,
+          type: "button",
+          onClick: () => toggle(lane.key),
+          "aria-pressed": active,
+          className: [
+            "inline-flex items-center gap-1.5 rounded-full border px-2 py-1 font-mono text-[10px] font-bold uppercase tracking-[0.14em] transition-colors cursor-pointer",
+            active ? "border-p-ink/20 bg-p-warm text-p-ink" : "border-p-line bg-p-surface text-p-ink-3 hover:border-p-ink-3 hover:text-p-ink"
+          ].join(" ")
+        },
+        lane.dotClassName ? /* @__PURE__ */ React.createElement(
+          "span",
+          {
+            "aria-hidden": true,
+            className: [
+              "size-1.5 rounded-full",
+              lane.dotClassName,
+              active ? "" : "opacity-60"
+            ].join(" ")
+          }
+        ) : null,
+        /* @__PURE__ */ React.createElement("span", null, lane.label),
+        /* @__PURE__ */ React.createElement("span", { className: "tabular-nums opacity-70" }, lane.count)
+      );
+    })
+  );
+}
+const DEFAULT_STATUS_ORDER = [
+  "scheduled",
+  "pending",
+  "running",
+  "done",
+  "failed",
+  "cancelled"
+];
+const STATUS_DOT = {
+  scheduled: "bg-[#7B3FE4]",
+  pending: "bg-p-ink-3",
+  running: "bg-p-accent",
+  review: "bg-[#2B44FF]",
+  done: "bg-p-green",
+  failed: "bg-[#E63946]",
+  cancelled: "bg-p-ink-3/50"
+};
+function RunKanban({
+  runs,
+  groupBy = "status",
+  now,
+  renderAvatar,
+  onCancel,
+  onRetry,
+  onOpen,
+  statusOrder = DEFAULT_STATUS_ORDER,
+  visibleKeys,
+  labels,
+  swarmLabels,
+  className
+}) {
+  const L = { ...defaultRunKanbanLabels, ...labels };
+  const lanes = useMemo(() => {
+    if (groupBy === "agent") {
+      const byAgent = /* @__PURE__ */ new Map();
+      for (const r of runs) {
+        const key = r.agent.name;
+        if (!byAgent.has(key)) byAgent.set(key, { ref: r.agent, runs: [] });
+        byAgent.get(key).runs.push(r);
+      }
+      return Array.from(byAgent.values()).map((a) => ({
+        key: a.ref.name,
+        label: a.ref.displayName ?? a.ref.name,
+        runs: a.runs
+      }));
+    }
+    const byStatus = /* @__PURE__ */ new Map();
+    for (const s of statusOrder) byStatus.set(s, []);
+    for (const r of runs) {
+      if (!byStatus.has(r.status)) byStatus.set(r.status, []);
+      byStatus.get(r.status).push(r);
+    }
+    return statusOrder.map((s) => ({
+      key: s,
+      label: s === "scheduled" ? L.scheduled : s === "pending" ? L.pending : s === "running" ? L.running : s === "done" ? L.done : s === "failed" ? L.failed : L.cancelled,
+      dotClassName: STATUS_DOT[s],
+      status: s,
+      runs: byStatus.get(s) ?? []
+    }));
+  }, [runs, groupBy, statusOrder, L.scheduled, L.pending, L.running, L.done, L.failed, L.cancelled]);
+  const renderedLanes = visibleKeys ? lanes.filter((l) => visibleKeys.has(l.key)) : lanes;
+  return /* @__PURE__ */ React.createElement(
+    "div",
+    {
+      className: [
+        // `h-full` so the kanban fills its container vertically — works
+        // both inside a fixed-height shell (task workspace, mission
+        // control) and in normal flow (the parent caps the height).
+        "flex h-full min-h-0 gap-3 overflow-x-auto pb-2",
+        className || ""
+      ].join(" ")
+    },
+    renderedLanes.map((lane) => /* @__PURE__ */ React.createElement(
+      KanbanLane,
+      {
+        key: lane.key,
+        lane,
+        now,
+        renderAvatar,
+        onCancel,
+        onRetry,
+        onOpen,
+        emptyLabel: L.emptyLane,
+        swarmLabels
+      }
+    ))
+  );
+}
+function KanbanLane({
+  lane,
+  now,
+  renderAvatar,
+  onCancel,
+  onRetry,
+  onOpen,
+  emptyLabel,
+  swarmLabels
+}) {
+  const merged = { ...defaultSwarmLabels, ...swarmLabels };
+  const dot = lane.dotClassName ?? (lane.runs[0]?.agent.color ? "" : "bg-p-ink-3");
+  return /* @__PURE__ */ React.createElement("section", { className: "flex h-full min-h-0 w-[280px] shrink-0 flex-col rounded-2xl border border-p-line bg-p-bg/60" }, /* @__PURE__ */ React.createElement("header", { className: "flex shrink-0 items-center justify-between gap-2 px-3 py-2" }, /* @__PURE__ */ React.createElement("span", { className: "inline-flex items-center gap-2" }, lane.dotClassName ? /* @__PURE__ */ React.createElement(
+    "span",
+    {
+      "aria-hidden": true,
+      className: [
+        "size-1.5 rounded-full",
+        dot,
+        lane.status === "running" ? "animate-pulse" : ""
+      ].join(" ")
+    }
+  ) : null, /* @__PURE__ */ React.createElement("span", { className: "font-mono text-[10px] font-bold uppercase tracking-[0.22em] text-p-ink-2" }, lane.label)), /* @__PURE__ */ React.createElement("span", { className: "font-mono text-[10px] tabular-nums text-p-ink-3" }, String(lane.runs.length).padStart(2, "0"))), /* @__PURE__ */ React.createElement("div", { className: "flex min-h-0 flex-1 flex-col gap-2 overflow-y-auto px-2 pb-2" }, lane.runs.length === 0 ? /* @__PURE__ */ React.createElement("span", { className: "px-2 py-6 text-center font-mono text-[10.5px] uppercase tracking-[0.16em] text-p-ink-3" }, emptyLabel) : lane.runs.map((r) => /* @__PURE__ */ React.createElement(
+    SwarmRunCard,
+    {
+      key: r.id,
+      run: r,
+      now,
+      renderAvatar,
+      onCancel,
+      onRetry,
+      onOpen,
+      labels: merged
+    }
+  ))));
+}
+export {
+  RunKanban,
+  RunKanbanFilters,
+  summariseRunKanbanLanes
+};

package/dist/swarm-agent-badge.d.ts

@@ -0,0 +1,15 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { SwarmAgentRef } from './types.js';
+
+interface SwarmAgentBadgeProps {
+    agent: SwarmAgentRef;
+    /** Optional consumer-rendered avatar — overrides the glyph chip. */
+    avatar?: ReactNode;
+    size?: "sm" | "md";
+    showName?: boolean;
+    className?: string;
+}
+declare function SwarmAgentBadge({ agent, avatar, size, showName, className, }: SwarmAgentBadgeProps): react.JSX.Element;
+
+export { SwarmAgentBadge, type SwarmAgentBadgeProps };

package/dist/swarm-agent-badge.js

@@ -0,0 +1,39 @@
+"use client";
+function SwarmAgentBadge({
+  agent,
+  avatar,
+  size = "md",
+  showName = true,
+  className
+}) {
+  const px = size === "sm" ? 18 : 22;
+  const txt = size === "sm" ? "text-[11px]" : "text-[12px]";
+  const glyph = agent.glyph || (agent.displayName || agent.name).charAt(0).toUpperCase();
+  return /* @__PURE__ */ React.createElement(
+    "span",
+    {
+      className: [
+        "inline-flex items-center gap-2",
+        className || ""
+      ].join(" ")
+    },
+    avatar ?? /* @__PURE__ */ React.createElement(
+      "span",
+      {
+        "aria-hidden": true,
+        className: "grid shrink-0 place-items-center rounded font-display font-bold text-white",
+        style: {
+          width: px,
+          height: px,
+          background: agent.color || "#999",
+          fontSize: px <= 18 ? 10 : 11
+        }
+      },
+      glyph
+    ),
+    showName ? /* @__PURE__ */ React.createElement("span", { className: [txt, "font-semibold text-p-ink truncate"].join(" ") }, agent.displayName || agent.name) : null
+  );
+}
+export {
+  SwarmAgentBadge
+};

package/dist/swarm-run-activity.d.ts

@@ -0,0 +1,39 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { SwarmRunEvent, SwarmRunActivity, SwarmAgentRef, SwarmRun } from './types.js';
+
+interface BuildSwarmRunActivityOptions {
+    /** Extra events (e.g. mapped from log sessions) merged with the run's
+     *  own fields. Sorted with everything else by `ts`. */
+    extras?: SwarmRunEvent[];
+}
+declare function buildSwarmRunActivity(run: SwarmRun, options?: BuildSwarmRunActivityOptions): SwarmRunActivity;
+interface SwarmRunActivityStreamProps {
+    events: SwarmRunActivity;
+    /** Used to label `agentName` references (avatar / displayName lookup). */
+    agents?: SwarmAgentRef[];
+    /** Slot for tool-call rendering — wire `<ToolCallChip variant="task"/>`
+     *  from `@lumea-labs/tool-calls` for the rich card view. When omitted,
+     *  a minimal text row is rendered. */
+    renderToolCall?: (tool: Extract<SwarmRunEvent, {
+        kind: "tool_call";
+    }>["tool"]) => ReactNode;
+    /** Slot for markdown rendering — wire `<MarkdownViewer/>` from
+     *  `@lumea-labs/markdown` for output / thought / user_input bodies.
+     *  Default: pre-formatted plain text. */
+    renderMarkdown?: (text: string) => ReactNode;
+    /** Override the entire rendering for an event. Return `undefined` to
+     *  fall back to the default. Use this for chat-style rendering. */
+    renderEvent?: (event: SwarmRunEvent) => ReactNode | undefined;
+    /** Number of events to show before the "Show N more" footer button.
+     *  Default `6`. Set to `Infinity` to disable the peek behaviour and
+     *  always show every event. The peek shows the LATEST events (the
+     *  tail of the timeline) since that's "what's happening now". */
+    peek?: number;
+    /** Empty-state copy when `events` is empty. */
+    emptyLabel?: string;
+    className?: string;
+}
+declare function SwarmRunActivityStream({ events, agents, renderToolCall, renderMarkdown, renderEvent, peek, emptyLabel, className, }: SwarmRunActivityStreamProps): react.JSX.Element;
+
+export { type BuildSwarmRunActivityOptions, SwarmRunActivityStream, type SwarmRunActivityStreamProps, buildSwarmRunActivity };