@lumea-labs/orchestrator 0.1.0

package/dist/task-workspace-sidebar.js

@@ -0,0 +1,352 @@
+"use client";
+import { useMemo, useState } from "react";
+import {
+  ArrowUpRight,
+  CheckCircle2,
+  ChevronRight,
+  ChevronsLeft,
+  Circle,
+  Clock,
+  LayoutGrid,
+  RotateCcw,
+  Scale,
+  Search,
+  User,
+  XCircle
+} from "lucide-react";
+const defaultTaskWorkspaceSidebarLabels = {
+  title: "Tasks",
+  searchPlaceholder: "Search tasks\u2026",
+  collapseSidebar: "Collapse sidebar",
+  openKanban: "Open kanban",
+  closeKanban: "Close kanban",
+  loading: "Loading\u2026",
+  noTasks: "No tasks yet.",
+  orphanGroup: "Other",
+  draftBadge: "draft",
+  expand: "Expand",
+  collapse: "Collapse"
+};
+function TaskWorkspaceSidebar({
+  tasks,
+  missions,
+  agents,
+  isLoading = false,
+  activeRuntimeId,
+  activePlanRef,
+  activeMissionId,
+  closed,
+  onCollapse,
+  kanbanView,
+  onToggleKanban,
+  runtimeTaskHref,
+  planTaskHref,
+  missionHref,
+  renderLink,
+  parsePlan = defaultParsePlan,
+  labels,
+  className
+}) {
+  const L = useMemo(
+    () => ({ ...defaultTaskWorkspaceSidebarLabels, ...labels }),
+    [labels]
+  );
+  const [query, setQuery] = useState("");
+  const [groupCollapsed, setGroupCollapsed] = useState(
+    {}
+  );
+  const missionByKey = useMemo(() => {
+    const m = /* @__PURE__ */ new Map();
+    for (const mi of missions) {
+      m.set(mi.id, mi);
+      m.set(mi.name, mi);
+    }
+    return m;
+  }, [missions]);
+  const groups = useMemo(() => {
+    const q = query.trim().toLowerCase();
+    const matches = (text) => !q || text.toLowerCase().includes(q);
+    const runtimeTitlesByMission = /* @__PURE__ */ new Map();
+    for (const tk of tasks) {
+      if (!tk.group) continue;
+      if (!runtimeTitlesByMission.has(tk.group))
+        runtimeTitlesByMission.set(tk.group, /* @__PURE__ */ new Set());
+      runtimeTitlesByMission.get(tk.group).add(tk.title);
+    }
+    const map = /* @__PURE__ */ new Map();
+    for (const tk of tasks) {
+      if (!matches(tk.title + " " + (tk.description || ""))) continue;
+      const key = tk.group || "__orphan__";
+      if (!map.has(key)) map.set(key, []);
+      map.get(key).push({ kind: "runtime", task: tk });
+    }
+    for (const m of missions) {
+      const planTasks = parsePlan(m.data);
+      if (planTasks.length === 0) continue;
+      const instantiated = runtimeTitlesByMission.get(m.name) ?? runtimeTitlesByMission.get(m.id) ?? /* @__PURE__ */ new Set();
+      const key = m.id;
+      for (const pt of planTasks) {
+        if (instantiated.has(pt.title)) continue;
+        if (!matches(pt.title + " " + (pt.description || ""))) continue;
+        if (!map.has(key)) map.set(key, []);
+        map.get(key).push({
+          kind: "plan",
+          title: pt.title,
+          description: pt.description,
+          assignTo: pt.assignTo,
+          missionId: m.id
+        });
+      }
+    }
+    for (const list of map.values()) {
+      list.sort((a, b) => {
+        if (a.kind !== b.kind) return a.kind === "runtime" ? -1 : 1;
+        if (a.kind === "runtime" && b.kind === "runtime") {
+          return (b.task.updatedAt || "").localeCompare(a.task.updatedAt || "");
+        }
+        if (a.kind === "plan" && b.kind === "plan") {
+          return a.title.localeCompare(b.title);
+        }
+        return 0;
+      });
+    }
+    return Array.from(map.entries()).sort((a, b) => {
+      const recent = (list) => {
+        const r = list.find((x) => x.kind === "runtime");
+        return r && r.kind === "runtime" ? r.task.updatedAt || "" : "";
+      };
+      return recent(b[1]).localeCompare(recent(a[1]));
+    });
+  }, [tasks, missions, query, parsePlan]);
+  return /* @__PURE__ */ React.createElement(
+    "aside",
+    {
+      "aria-hidden": closed,
+      ...{ inert: closed },
+      className: [
+        "flex h-full min-h-0 min-w-0 flex-col overflow-hidden bg-p-surface",
+        closed ? "border-r-0 pointer-events-none" : "border-r border-p-line",
+        className || ""
+      ].join(" ")
+    },
+    /* @__PURE__ */ React.createElement("div", { className: "flex h-11 shrink-0 items-center justify-between gap-2 px-2.5" }, /* @__PURE__ */ React.createElement("h3", { className: "min-w-0 truncate font-display text-[13px] font-semibold uppercase tracking-[0.08em] text-p-ink-2" }, L.title), /* @__PURE__ */ React.createElement("div", { className: "flex items-center gap-0.5" }, /* @__PURE__ */ React.createElement(
+      "button",
+      {
+        type: "button",
+        onClick: onToggleKanban,
+        "aria-pressed": kanbanView,
+        "aria-label": kanbanView ? L.closeKanban : L.openKanban,
+        title: kanbanView ? L.closeKanban : L.openKanban,
+        className: [
+          "grid size-7 place-items-center rounded-md transition-colors cursor-pointer",
+          kanbanView ? "bg-p-ink text-p-bg hover:bg-p-ink-2" : "bg-transparent text-p-ink-3 hover:bg-p-warm hover:text-p-ink"
+        ].join(" ")
+      },
+      /* @__PURE__ */ React.createElement(LayoutGrid, { className: "size-4" })
+    ), /* @__PURE__ */ React.createElement(
+      "button",
+      {
+        type: "button",
+        onClick: onCollapse,
+        "aria-label": L.collapseSidebar,
+        className: "grid size-7 place-items-center rounded-md bg-transparent text-p-ink-3 transition-colors cursor-pointer hover:bg-p-warm hover:text-p-ink"
+      },
+      /* @__PURE__ */ React.createElement(ChevronsLeft, { className: "size-4" })
+    ))),
+    /* @__PURE__ */ React.createElement("div", { className: "shrink-0 px-2.5 pt-2 pb-2" }, /* @__PURE__ */ React.createElement("div", { className: "relative" }, /* @__PURE__ */ React.createElement(Search, { className: "pointer-events-none absolute left-2.5 top-1/2 size-3.5 -translate-y-1/2 text-p-ink-3" }), /* @__PURE__ */ React.createElement(
+      "input",
+      {
+        value: query,
+        onChange: (e) => setQuery(e.target.value),
+        placeholder: L.searchPlaceholder,
+        className: "h-8 w-full rounded-md border border-p-line bg-p-bg pl-8 pr-2.5 font-body text-[12px] text-p-ink outline-none transition-colors duration-150 placeholder:text-p-ink-3 focus:border-p-ink-3 focus:bg-p-surface"
+      }
+    ))),
+    /* @__PURE__ */ React.createElement("div", { className: "min-h-0 flex-1 overflow-y-auto px-1.5 pt-1 pb-2" }, isLoading ? /* @__PURE__ */ React.createElement("div", { className: "px-3 py-6 text-center text-[12px] text-p-ink-3" }, L.loading) : groups.length === 0 ? /* @__PURE__ */ React.createElement("div", { className: "px-3 py-6 text-center text-[12px] text-p-ink-3" }, L.noTasks) : /* @__PURE__ */ React.createElement("div", { className: "flex flex-col gap-1" }, groups.map(([key, list]) => {
+      const mission = key === "__orphan__" ? null : missionByKey.get(key);
+      const title = mission?.name ?? (key === "__orphan__" ? L.orphanGroup : key);
+      const isCollapsed = groupCollapsed[key] ?? false;
+      return /* @__PURE__ */ React.createElement("div", { key, className: "flex flex-col" }, /* @__PURE__ */ React.createElement(
+        MissionGroupHeader,
+        {
+          title,
+          missionLink: mission ? missionHref(mission.id) : null,
+          active: !!mission && activeMissionId === mission.id,
+          count: list.length,
+          collapsed: isCollapsed,
+          onToggle: () => setGroupCollapsed((c) => ({ ...c, [key]: !isCollapsed })),
+          renderLink,
+          L
+        }
+      ), !isCollapsed && /* @__PURE__ */ React.createElement("div", { className: "mt-1 mb-1.5 ml-3 flex flex-col gap-0.5 border-l border-p-line pl-1.5" }, list.map(
+        (row, i) => row.kind === "runtime" ? /* @__PURE__ */ React.createElement(
+          TaskRow,
+          {
+            key: row.task.id,
+            task: row.task,
+            agents,
+            active: row.task.id === activeRuntimeId,
+            href: runtimeTaskHref(row.task.id),
+            renderLink
+          }
+        ) : /* @__PURE__ */ React.createElement(
+          DraftTaskRow,
+          {
+            key: `plan-${row.missionId}-${row.title}-${i}`,
+            title: row.title,
+            assignTo: row.assignTo,
+            agents,
+            active: activePlanRef?.missionId === row.missionId && activePlanRef.title === row.title,
+            href: planTaskHref(row.missionId, row.title),
+            renderLink,
+            L
+          }
+        )
+      )));
+    })))
+  );
+}
+function MissionGroupHeader({
+  title,
+  missionLink,
+  active,
+  count,
+  collapsed,
+  onToggle,
+  renderLink,
+  L
+}) {
+  const titleContent = /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement("span", { className: "min-w-0 flex-1 truncate text-[12.5px] font-semibold leading-tight" }, title), /* @__PURE__ */ React.createElement("span", { className: "shrink-0 rounded-full bg-p-warm px-2 py-0.5 text-[10px] font-semibold tabular-nums text-p-ink-2" }, count));
+  return /* @__PURE__ */ React.createElement(
+    "div",
+    {
+      className: [
+        "group flex w-full items-center gap-1 rounded-md",
+        active ? "bg-p-warm" : ""
+      ].join(" ")
+    },
+    /* @__PURE__ */ React.createElement(
+      "button",
+      {
+        type: "button",
+        onClick: onToggle,
+        "aria-label": collapsed ? L.expand : L.collapse,
+        className: "grid size-6 shrink-0 place-items-center rounded-md text-p-ink-3 transition-colors cursor-pointer hover:bg-p-warm hover:text-p-ink"
+      },
+      /* @__PURE__ */ React.createElement(
+        ChevronRight,
+        {
+          className: [
+            "size-3.5 transition-transform duration-150",
+            !collapsed ? "rotate-90" : ""
+          ].join(" ")
+        }
+      )
+    ),
+    missionLink ? renderLink({
+      href: missionLink,
+      className: [
+        "group/row flex min-w-0 flex-1 items-center gap-2 rounded-md px-1 py-1 no-underline transition-colors duration-100 cursor-pointer hover:bg-p-warm/60",
+        active ? "text-p-ink font-semibold" : "text-p-ink"
+      ].join(" "),
+      children: /* @__PURE__ */ React.createElement(React.Fragment, null, titleContent, /* @__PURE__ */ React.createElement(ArrowUpRight, { className: "size-3 shrink-0 text-p-ink-3 opacity-0 transition-opacity duration-150 group-hover/row:opacity-100" }))
+    }) : /* @__PURE__ */ React.createElement("div", { className: "flex min-w-0 flex-1 items-center gap-2 rounded-md px-1 py-1 text-p-ink-2" }, titleContent)
+  );
+}
+const TASK_STATUS_COLOR = {
+  draft: "var(--ink-3)",
+  pending: "var(--ink-3)",
+  awaiting_approval: "#D4A017",
+  assigned: "var(--p-accent)",
+  in_progress: "var(--p-accent)",
+  review: "#2B44FF",
+  done: "var(--green)",
+  failed: "#E63946"
+};
+const TASK_STATUS_ICON = {
+  draft: Circle,
+  pending: Clock,
+  awaiting_approval: Clock,
+  assigned: User,
+  in_progress: RotateCcw,
+  review: Scale,
+  done: CheckCircle2,
+  failed: XCircle
+};
+function TaskRow({
+  task,
+  agents,
+  active,
+  href,
+  renderLink
+}) {
+  const agent = agents?.find((a) => a.name === task.assignTo);
+  const color = TASK_STATUS_COLOR[task.status];
+  const Icon = TASK_STATUS_ICON[task.status];
+  return renderLink({
+    href,
+    className: [
+      "group relative flex w-full items-center gap-2 rounded-md px-2.5 py-2 no-underline transition-colors duration-100 cursor-pointer",
+      active ? "bg-p-warm text-p-ink font-semibold" : "text-p-ink-2 hover:bg-p-warm hover:text-p-ink"
+    ].join(" "),
+    children: /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(Icon, { className: "size-3 shrink-0", style: { color } }), /* @__PURE__ */ React.createElement("span", { className: "min-w-0 flex-1 truncate text-[13px] leading-tight" }, task.title), /* @__PURE__ */ React.createElement(MiniAgentAvatar, { agent, fallback: task.assignTo }))
+  });
+}
+function DraftTaskRow({
+  title,
+  assignTo,
+  agents,
+  active,
+  href,
+  renderLink,
+  L
+}) {
+  const agent = assignTo ? agents?.find((a) => a.name === assignTo) : void 0;
+  return renderLink({
+    href,
+    className: [
+      "group relative flex w-full items-center gap-2 rounded-md px-2.5 py-2 no-underline transition-colors duration-100 cursor-pointer",
+      active ? "bg-p-warm text-p-ink font-semibold" : "text-p-ink-3 hover:bg-p-warm hover:text-p-ink-2"
+    ].join(" "),
+    children: /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(Circle, { className: "size-3 shrink-0 text-p-ink-3/60" }), /* @__PURE__ */ React.createElement("span", { className: "min-w-0 flex-1 truncate text-[13px] italic leading-tight" }, title), /* @__PURE__ */ React.createElement("span", { className: "font-mono text-[9px] font-bold uppercase tracking-[0.16em] text-p-ink-3" }, L.draftBadge), assignTo ? /* @__PURE__ */ React.createElement(MiniAgentAvatar, { agent, fallback: assignTo }) : null)
+  });
+}
+function MiniAgentAvatar({
+  agent,
+  fallback
+}) {
+  const ref = agent ?? (fallback ? { name: fallback } : void 0);
+  if (!ref) return null;
+  const display = (ref.displayName ?? ref.name).charAt(0).toUpperCase();
+  return /* @__PURE__ */ React.createElement(
+    "span",
+    {
+      "aria-hidden": true,
+      className: "grid size-4 shrink-0 place-items-center rounded-[3px] font-display text-[9px] font-bold text-white",
+      style: { background: ref.color || "#999" }
+    },
+    ref.glyph || display
+  );
+}
+function defaultParsePlan(raw) {
+  if (!raw || typeof raw !== "string") return [];
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return [];
+    const maybe = parsed.tasks;
+    if (!Array.isArray(maybe)) return [];
+    return maybe.filter(
+      (t) => !!t && typeof t === "object" && typeof t.title === "string"
+    ).map((t) => ({
+      title: t.title,
+      description: t.description,
+      assignTo: t.assignTo
+    }));
+  } catch {
+    return [];
+  }
+}
+export {
+  TaskWorkspaceSidebar,
+  defaultTaskWorkspaceSidebarLabels
+};

package/dist/types.d.ts

@@ -0,0 +1,285 @@
+type SwarmRunStatus = "scheduled" | "pending" | "running" | "review" | "done" | "failed" | "cancelled";
+interface SwarmAgentRef {
+    /** Stable agent name / id. */
+    name: string;
+    displayName?: string;
+    /** Avatar gradient hint. */
+    color?: string;
+    /** Single-character monogram. */
+    glyph?: string;
+    /** One-line role / pitch. */
+    role?: string;
+}
+type SwarmRunEventKind = "phase" | "thought" | "tool_call" | "ask_user" | "user_input" | "output" | "artifact" | "error" | "retry" | "checkpoint" | "score";
+interface BaseEvent {
+    /** Stable id within the run. */
+    id: string;
+    /** ISO 8601 timestamp — the timeline's discriminator. */
+    ts: string;
+    /** Optional: the agent that emitted the event. */
+    agentName?: string;
+}
+type SwarmRunEvent = (BaseEvent & {
+    kind: "phase";
+    phase: string;
+}) | (BaseEvent & {
+    kind: "thought";
+    text: string;
+}) | (BaseEvent & {
+    kind: "tool_call";
+    /** A `ToolCallEvent`-shaped object. Kept opaque (`Record<string, unknown>`-like)
+     *  here so orchestrator doesn't depend on `@lumea-labs/tool-calls` for types;
+     *  the consumer (`<SwarmRunActivityStream/>`'s renderer) can pass it
+     *  through to `<ToolCallChip/>` without conversion. */
+    tool: {
+        id: string;
+        name: string;
+        state: "calling" | "completed" | "error";
+        arguments?: Record<string, unknown>;
+        result?: string;
+        summary?: string;
+    };
+}) | (BaseEvent & {
+    kind: "ask_user";
+    question: string;
+}) | (BaseEvent & {
+    kind: "user_input";
+    text: string;
+}) | (BaseEvent & {
+    kind: "output";
+    text: string;
+    partial?: boolean;
+}) | (BaseEvent & {
+    kind: "artifact";
+    artifact: SwarmArtifact;
+}) | (BaseEvent & {
+    kind: "error";
+    message: string;
+}) | (BaseEvent & {
+    kind: "retry";
+    attempt: number;
+    reason?: string;
+}) | (BaseEvent & {
+    kind: "checkpoint";
+    name: string;
+    verdict: "passed" | "rejected" | "pending";
+    message?: string;
+}) | (BaseEvent & {
+    kind: "score";
+    criterion: string;
+    value: number;
+    scale?: {
+        min: number;
+        max: number;
+    };
+    reasoning?: string;
+});
+/**
+ * Ordered chronological timeline of events for a single Swarm run.
+ * Just an alias for ergonomics — `buildSwarmRunActivity(...)` produces
+ * one of these and `<SwarmRunActivityStream events={...}/>` consumes it.
+ */
+type SwarmRunActivity = SwarmRunEvent[];
+/**
+ * Workspace task — opaque, matches the Polpo SDK `Task` shape but
+ * narrowed to the fields the workspace sidebar needs. The package
+ * doesn't take a hard dep on `@polpo-ai/sdk`; consumer maps as needed.
+ */
+type WorkspaceTaskStatus = "draft" | "pending" | "awaiting_approval" | "assigned" | "in_progress" | "review" | "done" | "failed";
+interface WorkspaceTask {
+    id: string;
+    title: string;
+    description?: string;
+    status: WorkspaceTaskStatus;
+    /** Mission group key — usually mission name or id. */
+    group?: string;
+    assignTo?: string;
+    /** ISO 8601. */
+    updatedAt?: string;
+}
+/**
+ * Workspace mission — opaque, the sidebar uses `id`, `name`, and the
+ * raw `data` blob (JSON-encoded plan) when expanding plan-only tasks.
+ */
+interface WorkspaceMission {
+    id: string;
+    name: string;
+    /** JSON-encoded plan. The sidebar parses it on the fly to surface
+     *  not-yet-instantiated plan tasks alongside runtime tasks. */
+    data?: string;
+    updatedAt?: string;
+}
+/**
+ * Opaque evaluation overlay — structurally compatible with
+ * `JudgeReport` from `@lumea-labs/judge` so consumers can pass the
+ * judge package's own data straight through. Kept as a local type
+ * here so orchestrator doesn't take a hard dep on judge.
+ */
+interface SwarmEvaluation {
+    id: string;
+    evaluatedAt: string;
+    scores: Array<{
+        criterion: string;
+        value: number;
+        scale?: {
+            min: number;
+            max: number;
+        };
+        reasoning?: string;
+        evidence?: string;
+    }>;
+    verdict: {
+        overall: number;
+        scale?: {
+            min: number;
+            max: number;
+        };
+        passed?: boolean;
+        summary?: string;
+    };
+}
+type SwarmArtifactKind = "file" | "url" | "image" | "data" | "note";
+/**
+ * A produced output of a run that's worth surfacing on its own — distinct
+ * from the textual `output` (which is the assistant's reply). Files
+ * created/edited, URLs reached, structured data dropped — these belong
+ * here so consumers can show a file ledger / link list / preview grid.
+ */
+interface SwarmArtifact {
+    id: string;
+    kind: SwarmArtifactKind;
+    /** Short human label (filename, page title, dataset name). */
+    label: string;
+    /** Local-ish path (when `kind === "file"`). */
+    path?: string;
+    /** Absolute URL (when `kind === "url"` / `"image"`). */
+    url?: string;
+    /** One-line description / hover preview. */
+    summary?: string;
+    /** Free-form tags rendered as small chips. */
+    tags?: string[];
+}
+interface SwarmToolCall {
+    id: string;
+    name: string;
+    state: "calling" | "completed" | "error";
+    /** Short human summary — e.g. file path, query, command. */
+    summary?: string;
+    /** Tool input arguments. Optional, but when present this shape is
+     *  compatible with `@lumea-labs/chat`'s `ToolCallEvent`, so the same
+     *  object can be handed to `<ToolCallChip>` for rich rendering
+     *  without conversion. */
+    arguments?: Record<string, unknown>;
+    /** Tool execution result on completion. Same compatibility note as
+     *  `arguments`. */
+    result?: string;
+}
+interface SwarmRun {
+    id: string;
+    agent: SwarmAgentRef;
+    /** Short, scannable label — displayed in lists, cards, kanban tiles,
+     *  timeline rows. Maps to `Task.title` from Polpo. */
+    title: string;
+    /** Full instruction / prompt given to the agent — shown in the run
+     *  detail's goal block. Maps to `Task.description` from Polpo (or
+     *  the `goal` argument passed to `SwarmStartInput.start()`). */
+    goal: string;
+    status: SwarmRunStatus;
+    /** Future ISO timestamp when the run is scheduled to fire. Set on
+     *  runs with status `"scheduled"` (and optionally `"pending"`). */
+    scheduledFor?: string;
+    /** ISO timestamps. */
+    startedAt?: string;
+    finishedAt?: string;
+    /** 0..1 when known, otherwise undefined → indeterminate. */
+    progress?: number;
+    /** Latest log line for the running list view. */
+    lastLog?: string;
+    /** Currently-active or recently-completed tool calls. */
+    toolCalls?: SwarmToolCall[];
+    /** Produced artifacts — files, URLs, datasets. Distinct from `output`,
+     *  which is the textual reply. */
+    artifacts?: SwarmArtifact[];
+    /** Output text on completion. May be Markdown. */
+    output?: string;
+    /** Error message on failure. */
+    error?: string;
+    /** How many retries this run has gone through. */
+    retries?: number;
+    /** Max retries allowed before the run is marked failed. */
+    maxRetries?: number;
+    /** Optional LLM-as-a-judge / G-Eval result for this run. Surface via
+     *  `<SwarmRunDetail renderEvaluation/>` to plug in the consumer's
+     *  preferred view (radar, score grid, full report). */
+    evaluation?: SwarmEvaluation;
+    /** Background runs do not block the user — surfaced in a dedicated
+     *  group. Foreground runs are the ones the user is actively watching. */
+    background?: boolean;
+    /** Parent run when this was spawned by another agent. */
+    parentRunId?: string;
+}
+interface SwarmStartInput {
+    agent: string;
+    goal: string;
+    background?: boolean;
+    /** Future ISO timestamp — when set the adapter creates the run in
+     *  `"scheduled"` state and only flips it to `"running"` when the
+     *  fire-time is reached. */
+    startAt?: string;
+}
+interface SwarmAdapter {
+    list?: () => Promise<SwarmRun[]>;
+    /** Subscribe to live updates of the whole swarm. Return unsubscribe. */
+    subscribe?: (onUpdate: (runs: SwarmRun[]) => void) => () => void;
+    start?: (input: SwarmStartInput) => Promise<SwarmRun>;
+    cancel?: (id: string) => Promise<void>;
+    retry?: (id: string) => Promise<SwarmRun>;
+}
+interface SwarmCapabilities {
+    canList: boolean;
+    canSubscribe: boolean;
+    canStart: boolean;
+    canCancel: boolean;
+    canRetry: boolean;
+}
+declare function deriveSwarmCapabilities(a: SwarmAdapter): SwarmCapabilities;
+interface SwarmCounts {
+    scheduled: number;
+    pending: number;
+    running: number;
+    review: number;
+    done: number;
+    failed: number;
+    cancelled: number;
+    total: number;
+}
+interface SwarmLabels {
+    scheduled: string;
+    pending: string;
+    running: string;
+    review: string;
+    done: string;
+    failed: string;
+    cancelled: string;
+    cancel: string;
+    retry: string;
+    cancelAll: string;
+    retryFailed: string;
+    noRuns: string;
+    /** "Background" group header shown in lists/grids. */
+    backgroundGroup: string;
+    foregroundGroup: string;
+    goal: string;
+    output: string;
+    error: string;
+    log: string;
+    tools: string;
+    /** "X running · Y done · Z failed" row in the status bar. */
+    countsLine: (c: SwarmCounts) => string;
+    /** "Started Xs ago" / "Took Ys" — short relative durations. */
+    startedAgo: (seconds: number) => string;
+    duration: (seconds: number) => string;
+}
+declare const defaultSwarmLabels: SwarmLabels;
+
+export { type SwarmAdapter, type SwarmAgentRef, type SwarmArtifact, type SwarmArtifactKind, type SwarmCapabilities, type SwarmCounts, type SwarmEvaluation, type SwarmLabels, type SwarmRun, type SwarmRunActivity, type SwarmRunEvent, type SwarmRunEventKind, type SwarmRunStatus, type SwarmStartInput, type SwarmToolCall, type WorkspaceMission, type WorkspaceTask, type WorkspaceTaskStatus, defaultSwarmLabels, deriveSwarmCapabilities };

package/dist/types.js

@@ -0,0 +1,44 @@
+function deriveSwarmCapabilities(a) {
+  return {
+    canList: typeof a.list === "function",
+    canSubscribe: typeof a.subscribe === "function",
+    canStart: typeof a.start === "function",
+    canCancel: typeof a.cancel === "function",
+    canRetry: typeof a.retry === "function"
+  };
+}
+const defaultSwarmLabels = {
+  scheduled: "Scheduled",
+  pending: "Pending",
+  running: "Running",
+  review: "In review",
+  done: "Done",
+  failed: "Failed",
+  cancelled: "Cancelled",
+  cancel: "Cancel",
+  retry: "Retry",
+  cancelAll: "Cancel all",
+  retryFailed: "Retry failed",
+  noRuns: "No agents are running. Launch one to get started.",
+  backgroundGroup: "Background",
+  foregroundGroup: "Foreground",
+  goal: "Goal",
+  output: "Output",
+  error: "Error",
+  log: "Log",
+  tools: "Tools",
+  countsLine: (c) => `${c.running} running \xB7 ${c.done} done \xB7 ${c.failed} failed`,
+  startedAgo: (s) => `${formatShort(s)} ago`,
+  duration: (s) => formatShort(s)
+};
+function formatShort(seconds) {
+  if (!Number.isFinite(seconds) || seconds < 0) return "\u2014";
+  if (seconds < 1) return `${Math.round(seconds * 1e3)}ms`;
+  if (seconds < 60) return `${Math.round(seconds)}s`;
+  if (seconds < 3600) return `${Math.round(seconds / 60)}m`;
+  return `${(seconds / 3600).toFixed(1)}h`;
+}
+export {
+  defaultSwarmLabels,
+  deriveSwarmCapabilities
+};