@arbidocs/blocks 0.4.135 → 0.4.137

package/dist/{chunk-2PNNCEPH.js → chunk-ATJUVHVB.js}

@@ -1,13 +1,21 @@
 "use client";
 import { UploadDropzone } from './chunk-EVUEIBNU.js';
-import { FoldSection } from './chunk-XD2M6LIG.js';
-import { workflowSteps, canAssign, nextAction, validateStep, assigneeName, runFieldsOf, failedUpstream, stepPhase, useElementSize, sendBackTargets, formatDate, shownValue, stepKindOf, stepLevels, waitingDocuments, stepDependencies, reviewInstructions, splitDocRef, isPersonStep, eventWaitingDocuments, waitingForDocumentsText, StepBadgeMark, StepChip, STEP_KIND_ICONS, DEFAULT_STEP_KIND_LABELS, composeStepPrompt, isRunFinished, runFields, isWorkflowScope } from './chunk-2DFDFOM7.js';
+import { DocumentPicker, TriStateFilterMenu } from './chunk-KSHKTOY2.js';
+import { EmptyState } from './chunk-P6GHJSLR.js';
+import { FoldSection, QuickActionDialogHeader, AddFilesFirst, StartTiles, ScopePicker } from './chunk-3RJN2VTL.js';
+import { SelectionBar, SelectionBarAction } from './chunk-NUNKSZKU.js';
+import { FilterInput } from './chunk-YU2KUMGE.js';
+import { GridView } from './chunk-N5YEF3LC.js';
+import { TabHeader } from './chunk-4WWM3GQ5.js';
+import { defaultInputs, validateInputs, workflowSteps, canAssign, fieldToFrontmatter, workflowFromFrontmatter, nextAction, validateStep, assigneeName, runFieldsOf, failedUpstream, stepPhase, useElementSize, sendBackTargets, formatDate, shownValue, stepKindOf, stepLevels, waitingDocuments, stepDependencies, reviewInstructions, splitDocRef, isPersonStep, eventWaitingDocuments, waitingForDocumentsText, StepBadgeMark, StepChip, buildLaunch, STEP_KIND_ICONS, DEFAULT_STEP_KIND_LABELS, composeStepPrompt, isRunFinished, runFields, isWorkflowScope } from './chunk-YOMPLCP6.js';
 import { TONE_DOT, TONE_SURFACE, TONE_SOLID_BORDER, TONE_BORDER } from './chunk-AUS3KBHJ.js';
 import { testIdOr, prefixedTestId } from './chunk-7F6CBP3Z.js';
-import { useState, useRef, useEffect, useCallback, useMemo } from 'react';
-import { Loader2, UserRound, CornerUpLeft, ShieldCheck, MessageSquare, Check, Hourglass, Clock, PenLine, X, ExternalLink, Mail, Table2, CheckCircle2, ArrowLeft, ArrowRight, RotateCw, GitBranch, AlertTriangle, ChevronLeft, ChevronRight, FileText, ArrowUpRight, BellRing, Flag, RotateCcw, Play, Disc, Phone, UserRoundCog, Sparkles, MessageSquareReply, Square, KeyRound, Lock } from 'lucide-react';
-import { cn, Popover, PopoverTrigger, PopoverContent, Button, Textarea, Card, Label, Input, Select, SelectTrigger, SelectValue, SelectContent, SelectItem, Switch } from '@arbidocs/react/ui';
+import { initials } from './chunk-OXF2IFXG.js';
+import { useState, useRef, useCallback, useId, useMemo, useEffect } from 'react';
+import { Loader2, Play, FolderPlus, ImageIcon, X, UserRound, CornerUpLeft, ShieldCheck, MessageSquare, Check, Hourglass, Clock, PenLine, ExternalLink, Mail, Table2, CheckCircle2, ArrowLeft, ArrowRight, RotateCw, GitBranch, AlertTriangle, MoreHorizontal, History, Pencil, Trash2, Workflow, ChevronLeft, ChevronRight, FileText, Link2, Bell, MousePointerClick, ArrowUpRight, BellRing, Flag, RotateCcw, Disc, Phone, UserRoundCog, Sparkles, MessageSquareReply, Square, KeyRound, Lock } from 'lucide-react';
+import { cn, Label, Select, SelectTrigger, SelectValue, SelectContent, SelectItem, Dialog, DialogContent, Button, getEntityColor, Popover, PopoverTrigger, PopoverContent, Textarea, Card, UserEntity, getEntityColorStyles, DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuItem, DropdownMenuSeparator, badgeVariants, VisibilityToggle, Switch, Input } from '@arbidocs/react/ui';
 import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+import { unzip, strFromU8 } from 'fflate';
 
 var DEFAULT_SCHEMA_FORM_LABELS = {
   optional: "(optional)",
@@ -318,6 +326,610 @@ function SchemaForm({
     )
   ] });
 }
+function useControllableState(value, defaultValue, onChange) {
+  const [inner, setInner] = useState(defaultValue);
+  const isControlled = value !== void 0;
+  const current = isControlled ? value : inner;
+  const onChangeRef = useRef(onChange);
+  onChangeRef.current = onChange;
+  const set = useCallback(
+    (next) => {
+      if (!isControlled) setInner(next);
+      onChangeRef.current?.(next);
+    },
+    [isControlled]
+  );
+  return [current, set];
+}
+var DEFAULT_AGENT_SELECT_LABELS = {
+  label: "Run as",
+  myAssistant: "My assistant"
+};
+var ME = "__me__";
+function AgentSelect({
+  agents,
+  value,
+  defaultValue = "",
+  onValueChange,
+  hideLabel,
+  disabled,
+  className,
+  labels,
+  testId,
+  optionTestId
+}) {
+  const l = { ...DEFAULT_AGENT_SELECT_LABELS, ...labels };
+  const triggerId = useId();
+  const [current, setCurrent] = useControllableState(value, defaultValue, onValueChange);
+  return /* @__PURE__ */ jsxs("div", { className: cn("flex flex-col gap-1.5", className), "data-slot": "agent-select", children: [
+    /* @__PURE__ */ jsx(Label, { htmlFor: triggerId, className: hideLabel ? "sr-only" : void 0, children: l.label }),
+    /* @__PURE__ */ jsxs(
+      Select,
+      {
+        value: current === "" ? ME : current,
+        onValueChange: (v) => setCurrent(v === ME ? "" : v),
+        disabled,
+        children: [
+          /* @__PURE__ */ jsx(
+            SelectTrigger,
+            {
+              id: triggerId,
+              "data-testid": testIdOr(testId, { testId: "agent-select" }),
+              className: "pointer-coarse:min-h-11",
+              children: /* @__PURE__ */ jsx(SelectValue, {})
+            }
+          ),
+          /* @__PURE__ */ jsxs(SelectContent, { children: [
+            /* @__PURE__ */ jsx(
+              SelectItem,
+              {
+                value: ME,
+                "data-testid": prefixedTestId(optionTestId, "me", {
+                  testId: "agent-select-option-me"
+                }),
+                children: l.myAssistant
+              }
+            ),
+            agents.map((agent) => /* @__PURE__ */ jsx(
+              SelectItem,
+              {
+                value: agent.id,
+                "data-testid": prefixedTestId(optionTestId, agent.id, {
+                  testId: `agent-select-option-${agent.id}`
+                }),
+                children: /* @__PURE__ */ jsxs("span", { className: "flex items-center gap-2", children: [
+                  agent.avatar,
+                  /* @__PURE__ */ jsx("span", { children: agent.label }),
+                  agent.description && /* @__PURE__ */ jsx("span", { className: "text-xs text-muted-foreground", children: agent.description })
+                ] })
+              },
+              agent.id
+            ))
+          ] })
+        ]
+      }
+    )
+  ] });
+}
+var DEFAULT_WORKFLOW_CONFIG_DIALOG_LABELS = {
+  start: "Start",
+  starting: "Starting\u2026",
+  addFilesReason: "This reads your files, and there is nothing to read yet.",
+  agentLabel: "Run as"
+};
+function WorkflowConfigDialog({
+  workflow,
+  open,
+  onOpenChange,
+  onLaunch,
+  initialInputs,
+  inputs: inputsProp,
+  onInputsChange,
+  scopeSource,
+  renderScope,
+  renderDocuments,
+  renderIcon,
+  addFilesAction,
+  agents,
+  agentId: agentIdProp,
+  onAgentChange,
+  isLaunching,
+  submitLabel,
+  fieldPlaceholder,
+  renderNotice,
+  labels,
+  formLabels,
+  agentLabels,
+  testId,
+  startTestId,
+  className
+}) {
+  const l = { ...DEFAULT_WORKFLOW_CONFIG_DIALOG_LABELS, ...labels };
+  const initialKey = JSON.stringify(initialInputs ?? {});
+  const seedKey = JSON.stringify({ ...defaultInputs(workflow), ...JSON.parse(initialKey) });
+  const seed = useMemo(() => JSON.parse(seedKey), [seedKey]);
+  const [inputs, setInputs] = useControllableState(inputsProp, seed, onInputsChange);
+  const [agentId, setAgentId] = useControllableState(
+    agentIdProp,
+    workflow.defaultAgentId ?? "",
+    onAgentChange
+  );
+  useEffect(() => {
+    if (open && inputsProp === void 0) setInputs(seed);
+  }, [open, seed]);
+  const setField = (name, value) => setInputs({ ...inputs, [name]: value });
+  const errors = validateInputs(workflow, inputs);
+  const valid = Object.keys(errors).length === 0;
+  const visibleErrors = Object.fromEntries(
+    Object.entries(errors).filter(([, e]) => e !== "required")
+  );
+  const scopeField = workflow.inputs.find((f) => f.type === "scope");
+  const rawScope = scopeField ? inputs[scopeField.name] : void 0;
+  const scopeValue = rawScope && typeof rawScope === "object" ? rawScope : { folders: [], labels: [] };
+  const matchedCount = scopeSource && scopeField ? scopeSource.countMatching(scopeValue) : null;
+  const noFiles = Boolean(workflow.requiresFiles && scopeSource && scopeSource.totalCount === 0);
+  const blockedByScope = matchedCount !== null && matchedCount === 0 && Boolean(workflow.requiresFiles);
+  const showAgent = workflow.run.kind === "prompt" && workflow.options?.agent !== false && agents !== void 0 && agents.length > 0;
+  const launch = (values) => {
+    Promise.resolve(onLaunch(buildLaunch(workflow, values, agentId))).catch(() => {
+    });
+  };
+  const submit = () => {
+    if (!valid || noFiles || blockedByScope || isLaunching) return;
+    launch(inputs);
+  };
+  const fields = useMemo(
+    () => workflow.inputs.map((f) => {
+      const placeholder = fieldPlaceholder?.(f, inputs, workflow);
+      return placeholder === void 0 ? f : { ...f, placeholder };
+    }),
+    [workflow, fieldPlaceholder, inputs]
+  );
+  const id = testIdOr(testId, { testId: "workflow-dialog" });
+  const formRef = useRef(null);
+  const firstField = workflow.inputs.find((f) => !f.advanced);
+  const focusPromptFirst = firstField?.type === "text" || firstField?.type === "longtext";
+  const defaultScopeRender = scopeSource ? (_field, value, onChange) => /* @__PURE__ */ jsx(
+    ScopePicker,
+    {
+      folders: scopeSource.folders,
+      unfiledCount: scopeSource.unfiledCount,
+      labels: scopeSource.labels,
+      totalCount: scopeSource.totalCount,
+      matchedCount: scopeSource.countMatching(value),
+      scope: value,
+      onScopeChange: onChange
+    }
+  ) : void 0;
+  return /* @__PURE__ */ jsx(Dialog, { open, onOpenChange, children: /* @__PURE__ */ jsxs(
+    DialogContent,
+    {
+      presentation: "sheet",
+      className: `max-h-[calc(100dvh-2rem)] overflow-y-auto sm:max-w-xl ${className ?? ""}`,
+      "data-testid": id,
+      "data-workflow": workflow.id,
+      onOpenAutoFocus: (event) => {
+        if (!focusPromptFirst || !firstField) return;
+        const control = formRef.current?.querySelector(
+          `[data-testid="${id}-field-${firstField.name}"]`
+        );
+        if (!control) return;
+        event.preventDefault();
+        control.focus();
+        if (control instanceof HTMLInputElement || control instanceof HTMLTextAreaElement) {
+          const end = control.value.length;
+          control.setSelectionRange(end, end);
+        }
+      },
+      children: [
+        /* @__PURE__ */ jsx(
+          QuickActionDialogHeader,
+          {
+            icon: workflow.icon && renderIcon ? renderIcon(workflow.icon) : null,
+            title: workflow.title,
+            description: workflow.details ?? workflow.description,
+            descriptionTestId: `${id}-description`
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "form",
+          {
+            ref: formRef,
+            className: "mt-2 flex flex-col gap-4",
+            onSubmit: (event) => {
+              event.preventDefault();
+              submit();
+            },
+            children: noFiles ? /* @__PURE__ */ jsx(
+              AddFilesFirst,
+              {
+                reason: l.addFilesReason,
+                action: addFilesAction,
+                testId: `${id}-empty-state`
+              }
+            ) : /* @__PURE__ */ jsxs(Fragment, { children: [
+              /* @__PURE__ */ jsx(
+                SchemaForm,
+                {
+                  fields,
+                  values: inputs,
+                  onChange: setField,
+                  errors: visibleErrors,
+                  renderScope: renderScope ?? defaultScopeRender,
+                  renderDocuments,
+                  renderIcon,
+                  labels: formLabels,
+                  onEnterSubmit: submit,
+                  testIdPrefix: `${id}-field`
+                }
+              ),
+              renderNotice?.({ workflow, inputs }),
+              /* @__PURE__ */ jsxs(
+                "div",
+                {
+                  className: "flex flex-col gap-3 border-t border-border pt-3 sm:flex-row sm:items-end sm:justify-between",
+                  "data-slot": "workflow-footer",
+                  children: [
+                    showAgent ? /* @__PURE__ */ jsx(
+                      AgentSelect,
+                      {
+                        agents: agents ?? [],
+                        value: agentId,
+                        onValueChange: setAgentId,
+                        labels: { label: l.agentLabel, ...agentLabels },
+                        testId: `${id}-agent`,
+                        className: "sm:w-56"
+                      }
+                    ) : /* @__PURE__ */ jsx("span", {}),
+                    /* @__PURE__ */ jsxs(
+                      Button,
+                      {
+                        type: "submit",
+                        className: "gap-1.5 px-5 pointer-coarse:min-h-11",
+                        disabled: !valid || blockedByScope || isLaunching,
+                        "data-testid": testIdOr(startTestId, { testId: "workflow-start-button" }),
+                        children: [
+                          isLaunching ? /* @__PURE__ */ jsx(Loader2, { className: "size-4 animate-spin" }) : /* @__PURE__ */ jsx(Play, { className: "size-4" }),
+                          isLaunching ? l.starting : submitLabel?.({ workflow, inputs, matchedCount }) ?? workflow.startLabel ?? l.start
+                        ]
+                      }
+                    )
+                  ]
+                }
+              )
+            ] })
+          }
+        )
+      ]
+    }
+  ) });
+}
+function WorkflowLauncher({
+  workflows,
+  tileWorkflows,
+  onLaunch,
+  showTiles = true,
+  caption,
+  captionTestId,
+  tileTestId,
+  disabledReason,
+  activeId: activeIdProp,
+  onActiveIdChange,
+  initialInputsFor,
+  testId,
+  extraTiles = [],
+  className,
+  children,
+  renderIcon,
+  ...dialog
+}) {
+  const [activeId, setActiveId] = useControllableState(
+    activeIdProp,
+    null,
+    onActiveIdChange
+  );
+  const [isLaunching, setIsLaunching] = useState(false);
+  const active = workflows.find((w) => w.id === activeId) ?? null;
+  const run = async (launch) => {
+    setIsLaunching(true);
+    try {
+      await onLaunch(launch);
+      setActiveId(null);
+    } finally {
+      setIsLaunching(false);
+    }
+  };
+  const select = (workflow) => {
+    if (workflow.run.kind === "operation" && workflow.inputs.length === 0) {
+      const inputs = defaultInputs(workflow);
+      if (Object.keys(validateInputs(workflow, inputs)).length === 0) {
+        Promise.resolve(onLaunch(buildLaunch(workflow, inputs, void 0))).catch(() => {
+        });
+        return;
+      }
+    }
+    setActiveId(workflow.id);
+  };
+  const tiles = (tileWorkflows ?? workflows).map((workflow) => {
+    const reason = disabledReason?.(workflow);
+    return {
+      id: workflow.id,
+      iconNode: workflow.icon && renderIcon ? renderIcon(workflow.icon) : void 0,
+      title: workflow.title,
+      description: workflow.description,
+      onSelect: () => select(workflow),
+      disabled: reason !== void 0,
+      disabledReason: reason,
+      testId: tileTestId?.(workflow) ?? `workflow-tile-${workflow.id}`
+    };
+  });
+  return /* @__PURE__ */ jsxs("div", { className, "data-slot": "workflow-launcher", children: [
+    showTiles && /* @__PURE__ */ jsx(
+      StartTiles,
+      {
+        items: [...tiles, ...extraTiles],
+        caption,
+        captionTestId,
+        testId
+      }
+    ),
+    children,
+    active && /* @__PURE__ */ jsx(
+      WorkflowConfigDialog,
+      {
+        ...dialog,
+        renderIcon,
+        workflow: active,
+        open: true,
+        onOpenChange: (open) => !open && setActiveId(null),
+        onLaunch: run,
+        isLaunching,
+        initialInputs: initialInputsFor?.(active)
+      }
+    )
+  ] });
+}
+function documentScopeLabels(tags) {
+  return tags.filter((tag) => {
+    if (tag.kind === "search") return false;
+    const onDocs = (tag.doctag_count ?? 0) > 0;
+    const onFacts = (tag.facttag_count ?? 0) > 0;
+    return onDocs || !onFacts;
+  });
+}
+var canonical = (path) => (path ?? "").split("/").map((part) => part.trim()).filter(Boolean).join("/");
+function matchWorkflowScope(docs, scope) {
+  if (scope.documents?.length) {
+    const ids = new Set(scope.documents);
+    return docs.filter((doc) => ids.has(doc.external_id));
+  }
+  if (!scope.folders.length && !scope.labels.length) return docs;
+  const folders = scope.folders.map(canonical);
+  const labels = new Set(scope.labels);
+  return docs.filter((doc) => {
+    const folder = canonical(doc.folder);
+    return folders.some(
+      (path) => path === "" ? folder === "" : folder === path || folder.startsWith(`${path}/`)
+    ) || doc.doctags?.some((tag) => labels.has(tag.tag_ext_id));
+  });
+}
+function buildWorkflowScopeSource(docs, labels = []) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const doc of docs) {
+    const parts = canonical(doc.folder).split("/").filter(Boolean);
+    for (let i = 1; i <= parts.length; i++) {
+      const path = parts.slice(0, i).join("/");
+      counts.set(path, (counts.get(path) ?? 0) + 1);
+    }
+  }
+  return {
+    folders: [...counts].sort(([a], [b]) => a.localeCompare(b)).map(([path, count]) => ({
+      path,
+      count,
+      label: path.split("/").at(-1),
+      depth: path.split("/").length - 1
+    })),
+    unfiledCount: docs.filter((doc) => !canonical(doc.folder)).length,
+    labels: labels.map((label) => ({
+      id: label.external_id,
+      name: label.name,
+      color: label.color ?? getEntityColor(label.external_id, "medium"),
+      count: docs.filter((doc) => doc.doctags?.some((tag) => tag.tag_ext_id === label.external_id)).length
+    })),
+    totalCount: docs.length,
+    countMatching: (scope) => matchWorkflowScope(docs, scope).length,
+    resolveDocuments: (scope) => matchWorkflowScope(docs, scope).map((doc) => doc.external_id)
+  };
+}
+var DEFAULT_WORKFLOW_DOCUMENTS_FIELD_LABELS = {
+  pickOne: "Pick a file",
+  pickMany: "Pick files",
+  allDocuments: "All documents",
+  addFiles: "Add files",
+  adding: "Adding\u2026",
+  empty: "No files in this workspace yet. Drop one here, or add it.",
+  remove: (name) => `Remove ${name}`,
+  pending: (name, status) => `${name}: ${status}. You can still pick it.`,
+  status: {
+    queued: "Queued",
+    uploading: "Uploading",
+    encrypting: "Encrypting",
+    processing: "Processing",
+    parsing: "Processing",
+    indexing: "Indexing",
+    analysing: "Analysing"
+  }
+};
+var isReady = (status) => !status || ["completed", "done", "ready", "success"].includes(status.toLowerCase());
+var byTitle = (a, b) => a.title.toLowerCase().localeCompare(b.title.toLowerCase());
+function WorkflowDocumentsField({
+  field,
+  value,
+  onChange,
+  documents,
+  loaded = true,
+  thumbnailOf,
+  onAddFiles,
+  adding,
+  labels
+}) {
+  const l = { ...DEFAULT_WORKFLOW_DOCUMENTS_FIELD_LABELS, ...labels };
+  const ids = value.documents ?? [];
+  const max = field.max ?? 1;
+  const multiple = max > 1;
+  const [isOver, setIsOver] = useState(false);
+  const docOf = (id) => documents.find((d) => d.id === id);
+  const nameOf = (id) => docOf(id)?.title || id;
+  const set = (next) => onChange({ ...value, documents: next });
+  const toggle = (id) => set(ids.includes(id) ? ids.filter((d) => d !== id) : [...ids, id].slice(-max));
+  const offered = useMemo(
+    () => field.accept === "image" ? documents.filter((d) => d.isImage) : documents,
+    [documents, field.accept]
+  );
+  const awaitingAdd = useRef(false);
+  const known = useRef(null);
+  const latest = useRef({ ids, set });
+  latest.current = { ids, set };
+  useEffect(() => {
+    if (!loaded) return;
+    const current = new Set(documents.map((d) => d.id));
+    const before = known.current;
+    known.current = current;
+    if (!before || !awaitingAdd.current) return;
+    const fresh = [...current].filter((id) => !before.has(id));
+    if (fresh.length === 0) return;
+    awaitingAdd.current = false;
+    latest.current.set([...latest.current.ids, ...fresh].slice(-max));
+  }, [documents, loaded, max]);
+  const addFiles = (files) => {
+    if (!onAddFiles) return;
+    awaitingAdd.current = true;
+    onAddFiles(files?.length ? files : void 0);
+  };
+  const dropProps = onAddFiles ? {
+    onDragOver: (e) => {
+      e.preventDefault();
+      setIsOver(true);
+    },
+    onDragLeave: () => setIsOver(false),
+    onDrop: (e) => {
+      e.preventDefault();
+      setIsOver(false);
+      const files = Array.from(e.dataTransfer?.files ?? []);
+      if (files.length) addFiles(files);
+    }
+  } : {};
+  const dropClass = isOver ? "ring-2 ring-primary" : "";
+  const addButton = (className, variant = "outline") => onAddFiles && /* @__PURE__ */ jsx(
+    Button,
+    {
+      type: "button",
+      size: "sm",
+      variant,
+      className,
+      disabled: adding,
+      onClick: () => addFiles(),
+      "data-testid": "workflow-add-files",
+      children: adding ? l.adding : l.addFiles
+    }
+  );
+  if (loaded && documents.length === 0) {
+    return /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: cn(
+          "flex flex-col items-center gap-2 rounded-lg border border-dashed border-border bg-muted/40 px-4 py-6 text-center",
+          dropClass
+        ),
+        "data-testid": "workflow-documents-empty",
+        ...dropProps,
+        children: [
+          /* @__PURE__ */ jsx(FolderPlus, { className: "size-5 text-muted-foreground", "aria-hidden": true }),
+          /* @__PURE__ */ jsx("p", { className: "text-sm text-muted-foreground", children: l.empty }),
+          addButton(void 0, "default")
+        ]
+      }
+    );
+  }
+  const pending = ids.flatMap((id) => {
+    const status = docOf(id)?.status;
+    return isReady(status) ? [] : [{ id, label: l.status[String(status).toLowerCase()] ?? String(status) }];
+  });
+  const selected = multiple ? void 0 : docOf(ids[0] ?? "");
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: cn("flex flex-col gap-3 rounded-lg", dropClass),
+      "data-testid": `workflow-documents-${field.name}`,
+      ...dropProps,
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+          /* @__PURE__ */ jsx("div", { className: "min-w-0 flex-1", children: /* @__PURE__ */ jsx(
+            DocumentPicker,
+            {
+              groups: [{ id: "all", heading: l.allDocuments, docs: [...offered].sort(byTitle) }],
+              value: multiple ? "" : ids[0] ?? "",
+              onValueChange: (id) => multiple ? toggle(id) : set([id]),
+              selected,
+              selectedIds: multiple ? ids : void 0,
+              labels: { placeholder: field.placeholder ?? (multiple ? l.pickMany : l.pickOne) }
+            }
+          ) }),
+          addButton("shrink-0 pointer-coarse:h-11")
+        ] }),
+        pending.map((p) => /* @__PURE__ */ jsx(
+          "p",
+          {
+            className: "text-xs text-muted-foreground",
+            "data-testid": `workflow-document-status-${p.id}`,
+            children: l.pending(nameOf(p.id), p.label)
+          },
+          p.id
+        )),
+        multiple && ids.length > 0 && /* @__PURE__ */ jsx(
+          "div",
+          {
+            className: "grid grid-cols-2 gap-3 sm:grid-cols-3",
+            "data-testid": "workflow-documents-gallery",
+            children: ids.map((id) => {
+              const thumbnail = thumbnailOf?.(id);
+              return /* @__PURE__ */ jsxs(
+                "figure",
+                {
+                  className: "relative overflow-hidden rounded-lg border border-border bg-muted/40",
+                  "data-testid": `workflow-document-${id}`,
+                  children: [
+                    thumbnail ? /* @__PURE__ */ jsx(
+                      "img",
+                      {
+                        src: thumbnail,
+                        alt: nameOf(id),
+                        className: "aspect-square w-full object-cover"
+                      }
+                    ) : /* @__PURE__ */ jsx("div", { className: "flex aspect-square w-full items-center justify-center text-muted-foreground/50", children: /* @__PURE__ */ jsx(ImageIcon, { className: "size-8" }) }),
+                    /* @__PURE__ */ jsx("figcaption", { className: "truncate bg-background/90 px-2 py-1 text-xs text-muted-foreground", children: nameOf(id) }),
+                    /* @__PURE__ */ jsx(
+                      "button",
+                      {
+                        type: "button",
+                        onClick: () => toggle(id),
+                        "aria-label": l.remove(nameOf(id)),
+                        className: "absolute right-1 top-1 flex size-6 items-center justify-center rounded-full bg-background/80 text-muted-foreground hover:text-foreground pointer-coarse:size-11",
+                        "data-testid": `workflow-document-remove-${id}`,
+                        children: /* @__PURE__ */ jsx(X, { className: "size-3.5" })
+                      }
+                    )
+                  ]
+                },
+                id
+              );
+            })
+          }
+        )
+      ]
+    }
+  );
+}
 
 // src/agents/workflows/planSteps.ts
 function toPlanAssignee(a) {
@@ -569,6 +1181,47 @@ function fromStepField(f) {
     ...f.max != null ? { max: f.max } : {}
   };
 }
+
+// src/agents/workflows/skillMarkdown.ts
+var JSON_KEYS = /* @__PURE__ */ new Set(["inputs"]);
+var oneLine = (text) => text.replace(/\s*\n\s*/g, " ").trim();
+var skillSlug = (raw) => raw.toLowerCase().replace(/[^a-z0-9-]/g, "");
+function workflowToSkillMarkdown(workflow) {
+  const { run } = workflow;
+  if (run.kind !== "prompt") throw new Error("Only skills that start a chat can be copied");
+  const lines = [
+    "---",
+    `name: ${skillSlug(workflow.id)}`,
+    `description: ${oneLine(workflow.description)}`
+  ];
+  if (workflow.icon) lines.push(`icon: ${workflow.icon}`);
+  if (workflow.landing !== "chat") lines.push(`landing: ${workflow.landing}`);
+  if (workflow.requiresFiles) lines.push("requires_files: true");
+  if (workflow.inputs.length > 0) {
+    lines.push(`inputs: ${JSON.stringify(workflow.inputs.map(fieldToFrontmatter))}`);
+  }
+  lines.push("---", "", run.promptTemplate.trim(), "");
+  return lines.join("\n");
+}
+function workflowFromSkillMarkdown(id, text) {
+  const match = /^---\n([\s\S]*?)\n---\n?([\s\S]*)$/.exec(text);
+  const frontmatter = {};
+  const body = match ? match[2] : text;
+  for (const line of (match ? match[1] : "").split("\n")) {
+    const i = line.indexOf(":");
+    if (i < 1) continue;
+    const key = line.slice(0, i).trim();
+    const value = line.slice(i + 1).trim();
+    if (JSON_KEYS.has(key)) {
+      try {
+        frontmatter[key] = JSON.parse(value);
+      } catch {
+      }
+    } else if (value === "true" || value === "false") frontmatter[key] = value === "true";
+    else frontmatter[key] = value;
+  }
+  return workflowFromFrontmatter(id, frontmatter, body);
+}
 var errorMessage = (e) => e instanceof Error ? e.message : typeof e === "string" ? e : "Something went wrong.";
 function firstOpen(steps, states) {
   const open = steps.find((s) => !["done", "skipped"].includes(states[s.id]?.status ?? "pending"));
@@ -2319,6 +2972,890 @@ function StepNotices({
     ))
   ] });
 }
+
+// src/agents/skills/skillFiles.ts
+var SKILL_TYPES = ["markdown", "python", "shell", "javascript", "typescript"];
+var SKILL_MAIN_FILENAME = "SKILL.md";
+var MAIN_NAMES = /* @__PURE__ */ new Set(["skill.md", "skill.py", "skill.sh", "skill.js", "skill.ts"]);
+function isMainSkillFile(filename, skillName) {
+  const lower = filename.toLowerCase();
+  if (MAIN_NAMES.has(lower)) return true;
+  const stem = lower.includes(".") ? lower.slice(0, lower.lastIndexOf(".")) : lower;
+  return stem === skillName;
+}
+function detectTypeFromContent(content, filename) {
+  if (filename) {
+    const lower = filename.toLowerCase();
+    if (lower.endsWith(".py")) return "python";
+    if (lower.endsWith(".sh")) return "shell";
+    if (lower.endsWith(".js")) return "javascript";
+    if (lower.endsWith(".ts")) return "typescript";
+  }
+  if (content) {
+    const firstLine = content.split("\n", 1)[0].trim();
+    if (firstLine.startsWith("#!")) {
+      if (firstLine.includes("python")) return "python";
+      if (firstLine.includes("bash") || firstLine.includes("/sh")) return "shell";
+      if (firstLine.includes("ts-node")) return "typescript";
+      if (firstLine.includes("node")) return "javascript";
+    }
+  }
+  return "markdown";
+}
+function parseSkillFrontmatter(raw, filename = "") {
+  const config = {};
+  let name = "";
+  let description = "";
+  let skillType = "markdown";
+  if (!raw.startsWith("---")) {
+    return {
+      content: raw,
+      name,
+      description,
+      config,
+      skillType: detectTypeFromContent(raw, filename)
+    };
+  }
+  const end = raw.indexOf("---", 3);
+  if (end === -1) {
+    return {
+      content: raw,
+      name,
+      description,
+      config,
+      skillType: detectTypeFromContent(raw, filename)
+    };
+  }
+  const frontmatter = raw.slice(3, end).trim();
+  const body = raw.slice(end + 3).trim();
+  for (const rawLine of frontmatter.split("\n")) {
+    const line = rawLine.trim();
+    if (!line || !line.includes(":")) continue;
+    const idx = line.indexOf(":");
+    const key = line.slice(0, idx).trim().toLowerCase();
+    const value = line.slice(idx + 1).trim();
+    if (key === "name" && value) {
+      name = value;
+    } else if (key === "description" && value) {
+      description = value;
+    } else if (key === "model" && value) {
+      config.model = value;
+    } else if (key === "temperature") {
+      const t = Number.parseFloat(value);
+      if (!Number.isNaN(t) && t >= 0 && t <= 2) config.temperature = t;
+    } else if (key === "agent") {
+      config.agent = ["true", "yes", "1"].includes(value.toLowerCase());
+    } else if (key === "tools" && value) {
+      config.tools = value.split(",").map((t) => t.trim()).filter(Boolean);
+    } else if (key === "type" && value) {
+      const v = value.toLowerCase();
+      if (v === "python" || v === "py") skillType = "python";
+      else if (v === "shell" || v === "sh" || v === "bash") skillType = "shell";
+      else if (v === "javascript" || v === "js" || v === "node") skillType = "javascript";
+      else if (v === "typescript" || v === "ts") skillType = "typescript";
+    }
+  }
+  if (skillType === "markdown") {
+    skillType = detectTypeFromContent(body, filename);
+  }
+  return { content: body, name, description, config, skillType };
+}
+function serializeSkill(input) {
+  const lines = ["---", `name: ${input.name}`, `description: ${input.description}`];
+  if (input.type && input.type !== "markdown") {
+    lines.push(`type: ${input.type}`);
+  }
+  lines.push("---", "", input.body.trim(), "");
+  return lines.join("\n");
+}
+var SKILL_FOLDER_PREFIX = "skills/";
+function stripExt(name) {
+  const i = name.lastIndexOf(".");
+  return i > 0 ? name.slice(0, i) : name;
+}
+function isJunkPath(path) {
+  if (path.endsWith("/")) return true;
+  const parts = path.split("/");
+  if (parts.some((p) => p === "__MACOSX")) return true;
+  return parts[parts.length - 1].startsWith(".");
+}
+function folderFor(slug, relDir) {
+  const root = `${SKILL_FOLDER_PREFIX}${slug}`;
+  return relDir ? `${root}/${relDir}` : root;
+}
+function importMarkdownSkill(fileName, text) {
+  const parsed = parseSkillFrontmatter(text, fileName);
+  const slug = skillSlug(parsed.name) || skillSlug(stripExt(fileName));
+  if (!slug) {
+    throw new Error(
+      "Could not derive a skill name. Add a `name:` to the frontmatter or rename the file."
+    );
+  }
+  return {
+    slug,
+    entries: [{ folder: folderFor(slug, ""), fileName: SKILL_MAIN_FILENAME, content: text }]
+  };
+}
+function commonTopDir(paths) {
+  const tops = /* @__PURE__ */ new Set();
+  for (const p of paths) {
+    const idx = p.indexOf("/");
+    if (idx === -1) return null;
+    tops.add(p.slice(0, idx));
+  }
+  return tops.size === 1 ? [...tops][0] : null;
+}
+function buildZipSkillImport(archiveName, rawEntries) {
+  const entries = rawEntries.filter((e) => e.path && !isJunkPath(e.path));
+  if (entries.length === 0) throw new Error("The archive contains no importable skill files.");
+  const top = commonTopDir(entries.map((e) => e.path));
+  const rel = (p) => top ? p.slice(top.length + 1) : p;
+  let slug = top ? skillSlug(top) : "";
+  if (!slug) {
+    const mainGuess = entries.find((e) => {
+      const r = rel(e.path);
+      return !r.includes("/") && isMainSkillFile(r, "__never__");
+    }) ?? entries.find((e) => !rel(e.path).includes("/"));
+    if (mainGuess) slug = skillSlug(parseSkillFrontmatter(mainGuess.text, rel(mainGuess.path)).name);
+  }
+  if (!slug) slug = skillSlug(stripExt(archiveName));
+  if (!slug) throw new Error("Could not derive a skill name from the archive.");
+  const rootFiles = entries.filter((e) => !rel(e.path).includes("/"));
+  const mainEntry = rootFiles.find((e) => isMainSkillFile(rel(e.path), slug)) ?? (rootFiles.length === 1 ? rootFiles[0] : void 0);
+  return {
+    slug,
+    entries: entries.map((e) => {
+      const r = rel(e.path);
+      const lastSlash = r.lastIndexOf("/");
+      return {
+        folder: folderFor(slug, lastSlash === -1 ? "" : r.slice(0, lastSlash)),
+        fileName: mainEntry && e.path === mainEntry.path ? SKILL_MAIN_FILENAME : lastSlash === -1 ? r : r.slice(lastSlash + 1),
+        content: e.text
+      };
+    })
+  };
+}
+async function readSkillArchive(file) {
+  const data = new Uint8Array(await file.arrayBuffer());
+  let files;
+  try {
+    files = await new Promise(
+      (resolve, reject) => unzip(
+        data,
+        { filter: (f) => !isJunkPath(f.name) },
+        (err, out) => err ? reject(err) : resolve(out)
+      )
+    );
+  } catch {
+    throw new Error("The archive is empty or could not be read.");
+  }
+  const entries = Object.entries(files).map(([path, bytes]) => ({ path, text: strFromU8(bytes) }));
+  if (entries.length === 0) throw new Error("The archive is empty or could not be read.");
+  return entries;
+}
+async function importSkillFile(file) {
+  const lower = file.name.toLowerCase();
+  if (lower.endsWith(".zip")) return buildZipSkillImport(file.name, await readSkillArchive(file));
+  if (lower.endsWith(".md") || lower.endsWith(".markdown")) {
+    return importMarkdownSkill(file.name, await file.text());
+  }
+  throw new Error("Unsupported file type. Choose a .md skill or a .zip archive.");
+}
+async function importSkillFromUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url.trim());
+  } catch {
+    throw new Error("That does not look like a link.");
+  }
+  const response = await fetch(parsed.toString());
+  if (!response.ok) throw new Error(`Could not open the link (${response.status}).`);
+  const text = await response.text();
+  const last = parsed.pathname.split("/").filter(Boolean).pop() ?? "skill";
+  return importMarkdownSkill(last.includes(".") ? last : `${last}.md`, text);
+}
+function PersonPill({ person, size = "sm", testId }) {
+  return /* @__PURE__ */ jsx("span", { "data-testid": testId, className: "inline-flex min-w-0", children: /* @__PURE__ */ jsx(
+    UserEntity,
+    {
+      variant: "pill",
+      size,
+      interactive: false,
+      showTooltip: false,
+      initials: initials(person.label),
+      displayName: person.label,
+      avatarStyle: person.id ? getEntityColorStyles(person.id) : void 0,
+      isAgent: person.isAgent,
+      isMe: person.isMe
+    }
+  ) });
+}
+var DEFAULT_TASK_TRIGGER_CHIP_LABELS = {
+  after: (name) => `After \u201C${name}\u201D is done`,
+  afterUnknown: "After another task is done",
+  onDemand: "Manual"
+};
+function TriggerIcon({ type, chained }) {
+  const cls = "size-3.5 shrink-0 text-muted-foreground";
+  if (chained) return /* @__PURE__ */ jsx(Link2, { className: cls, "aria-hidden": true });
+  switch (type) {
+    case "on_demand":
+      return /* @__PURE__ */ jsx(MousePointerClick, { className: cls, "aria-hidden": true });
+    case "recurring":
+      return /* @__PURE__ */ jsx(Clock, { className: cls, "aria-hidden": true });
+    case "event":
+      return /* @__PURE__ */ jsx(Bell, { className: cls, "aria-hidden": true });
+    default:
+      return /* @__PURE__ */ jsx(Clock, { className: cls, "aria-hidden": true });
+  }
+}
+function TaskTriggerChip({
+  id,
+  triggerType,
+  summary,
+  afterTaskId,
+  afterTaskName,
+  testId,
+  labels
+}) {
+  const l = { ...DEFAULT_TASK_TRIGGER_CHIP_LABELS, ...labels };
+  const chained = Boolean(afterTaskId);
+  const text = chained ? afterTaskName ? l.after(afterTaskName) : l.afterUnknown : triggerType === "on_demand" ? l.onDemand : summary;
+  return /* @__PURE__ */ jsxs(
+    "span",
+    {
+      className: "inline-flex min-w-0 max-w-full items-center gap-1.5 text-sm font-normal text-foreground",
+      "data-testid": testIdOr(testId, { testId: `task-trigger-${id}` }),
+      "data-trigger": chained ? "task" : triggerType,
+      children: [
+        /* @__PURE__ */ jsx(TriggerIcon, { type: triggerType, chained }),
+        /* @__PURE__ */ jsx("span", { className: "truncate", children: text })
+      ]
+    }
+  );
+}
+
+// src/agents/tasks/workflowRows.ts
+var isSkillRow = (row) => row.kind === "skill";
+var hasTrigger = (row) => !row.on_demand && Boolean(row.rrule || row.run_at || row.event_kind || row.after_conversation_ext_id);
+function workflowStatus(row) {
+  if (isSkillRow(row) || !hasTrigger(row)) return "on_demand";
+  return row.active ? "active" : "paused";
+}
+function workflowTriggerType(workflow) {
+  if (workflow.on_demand) return "on_demand";
+  if (workflow.after_conversation_ext_id) return "after";
+  if (workflow.event_kind) return "event";
+  if (workflow.rrule) return "recurring";
+  if (workflow.run_at) return "one_time";
+  return "on_demand";
+}
+function workflowRunStatusLabel(status) {
+  if (!status) return "None";
+  const labels = {
+    completed: "Success",
+    success: "Success",
+    failed: "Failed",
+    running: "In progress",
+    awaiting_authorization: "Awaiting access"
+  };
+  return labels[status] ?? status.replaceAll("_", " ");
+}
+function listedRunStatus(status, threadStatus) {
+  if (threadStatus === "done" && status === "running") return "completed";
+  return status;
+}
+
+// src/agents/tasks/workflowColumns.tsx
+var WORKFLOW_COLUMN_ORDER = [
+  "name",
+  "trigger",
+  "last_run",
+  "result",
+  "status",
+  "shared",
+  "actions"
+];
+function cell(render) {
+  return (params) => params.data ? render(params.data) : null;
+}
+var time = (iso) => iso ? Date.parse(iso) : Number.POSITIVE_INFINITY;
+function createWorkflowColumns(o) {
+  const l = o.labels;
+  const base = {
+    sortable: false,
+    cellStyle: { display: "flex", alignItems: "center" }
+  };
+  return [
+    {
+      ...base,
+      colId: "name",
+      sortable: true,
+      headerName: l.colName,
+      flex: 3,
+      minWidth: 210,
+      valueGetter: (p) => p.data?.name.toLowerCase() ?? "",
+      cellRenderer: cell(o.renderName)
+    },
+    {
+      ...base,
+      colId: "trigger",
+      headerName: l.colTrigger,
+      flex: 2.4,
+      minWidth: 185,
+      valueGetter: (p) => p.data ? o.getTriggerText(p.data) : "",
+      cellRenderer: cell(o.renderTrigger)
+    },
+    {
+      ...base,
+      colId: "last_run",
+      sortable: true,
+      headerName: l.colLastRun,
+      flex: 1.4,
+      minWidth: 140,
+      cellStyle: { display: "flex", alignItems: "center", padding: 0 },
+      valueGetter: (p) => time(p.data?.last_fired_at),
+      cellRenderer: cell(o.renderLastRun)
+    },
+    {
+      ...base,
+      colId: "result",
+      headerName: "Result",
+      width: 130,
+      valueGetter: (p) => p.data?.last_run_status ?? "",
+      cellStyle: { display: "flex", alignItems: "center", padding: 0 },
+      cellRenderer: cell(o.renderResult)
+    },
+    {
+      ...base,
+      colId: "status",
+      sortable: true,
+      headerName: l.colStatus,
+      width: 120,
+      valueGetter: (p) => p.data ? workflowStatus(p.data) : "",
+      cellRenderer: cell(o.renderStatus)
+    },
+    {
+      ...base,
+      colId: "shared",
+      headerName: l.colShared,
+      headerTooltip: l.shared,
+      width: 96,
+      cellStyle: { display: "flex", alignItems: "center", justifyContent: "center" },
+      valueGetter: (p) => p.data?.shared ?? false,
+      cellRenderer: cell(o.renderShared)
+    },
+    {
+      ...base,
+      colId: "actions",
+      headerName: "",
+      width: 180,
+      minWidth: 180,
+      cellStyle: { display: "flex", alignItems: "center", justifyContent: "flex-end" },
+      cellRenderer: cell(o.renderActions)
+    }
+  ];
+}
+
+// src/agents/tasks/workflowTableLabels.ts
+var DEFAULT_WORKFLOW_LIST_LABELS = {
+  colName: "Name",
+  colType: "Type",
+  colTrigger: "When",
+  colAction: "What it does",
+  colAgent: "Agent",
+  colStatus: "Active",
+  colShared: "Shared",
+  colLastRun: "Last run",
+  colNextRun: "Next run",
+  shared: "Shared with the workspace",
+  sharedOwnerOnly: "Only the creator can change who can see this",
+  deleteOwnerOnly: "Only the creator or workspace owner can delete this",
+  typeSkill: "Skill",
+  typeWorkflow: "Workflow",
+  statusActive: "Active",
+  statusPaused: "Inactive",
+  statusOnDemand: "On demand",
+  activeSwitch: (name) => `Active: \u201C${name}\u201D`,
+  agent: "Agent",
+  myAssistant: "My assistant",
+  me: "Me",
+  someone: "Someone",
+  never: "Never",
+  none: "\u2014",
+  reminder: "Reminder",
+  failed: "Failed",
+  lastRunFailed: "Last run failed",
+  openLastRun: "Open the task this run created",
+  editWorkflow: "Edit",
+  run: "Run",
+  runLater: "Run later",
+  runNow: "Run now",
+  runs: "Runs",
+  delete: "Delete",
+  moreActions: "More actions",
+  searchLabel: "Search workflows",
+  searchPlaceholder: "Search workflows and skills\u2026",
+  emptyTitle: "Nothing to run yet",
+  emptyMessage: "Skills and workflows you can run will appear here.",
+  firstRun: "Run a skill now, or choose Run later to save it as a workflow that runs on its own.",
+  noMatches: "Nothing in this view.",
+  filterAll: "All",
+  filterSkills: "Skills",
+  filterWorkflows: "Workflows",
+  filterActive: "Active",
+  filterPaused: "Inactive",
+  makeActive: "Make active",
+  makePaused: "Deactivate",
+  selectAll: "Select all",
+  selectWorkflow: (name) => `Select ${name}`
+};
+var ROW_HEIGHT = 40;
+function WorkflowsTable(props) {
+  const { workflows, isLoading, busyId, header, testId } = props;
+  const l = { ...DEFAULT_WORKFLOW_LIST_LABELS, ...props.labels };
+  const [filterStates, setFilterStates] = useState(/* @__PURE__ */ new Map());
+  const [filterOpen, setFilterOpen] = useState(false);
+  const [query, setQuery] = useState("");
+  const [selected, setSelected] = useState([]);
+  const apiRef = useRef(null);
+  const q = query.trim().toLowerCase();
+  const matches = (w) => !q || `${w.name} ${w.description ?? ""} ${w.prompt ?? ""} ${w.skill_ref ?? ""}`.toLowerCase().includes(q);
+  const inFilter = (w, f) => f === "all" || f === "skills" && isSkillRow(w) || f === "workflows" && !isSkillRow(w) || f === "active" && workflowStatus(w) === "active" || f === "paused" && workflowStatus(w) === "paused";
+  const counts = useMemo(() => {
+    const out = { all: 0, skills: 0, workflows: 0, active: 0, paused: 0 };
+    for (const w of workflows) {
+      if (!matches(w)) continue;
+      for (const f of Object.keys(out)) if (inFilter(w, f)) out[f] += 1;
+    }
+    return out;
+  }, [workflows, q]);
+  const shown = useMemo(
+    () => workflows.filter((w) => {
+      if (!matches(w)) return false;
+      for (const group of [
+        ["skills", "workflows"],
+        ["active", "paused"]
+      ]) {
+        const included = group.filter((f) => filterStates.get(f) === "include");
+        if (included.length && !included.some((f) => inFilter(w, f))) return false;
+        if (group.some((f) => filterStates.get(f) === "exclude" && inFilter(w, f))) return false;
+      }
+      return true;
+    }),
+    [workflows, filterStates, q]
+  );
+  const renderPerson = props.renderPerson ?? ((p) => /* @__PURE__ */ jsx(PersonPill, { person: p }));
+  const actionText = (w) => {
+    if (w.action)
+      return w.action.type === "email_documents" ? "Email latest documents" : "AI Review";
+    if (isSkillRow(w))
+      return w.description || w.skill_ref && props.skillNames?.[w.skill_ref] || w.name;
+    return w.skill_ref ? props.skillNames?.[w.skill_ref] ?? w.skill_ref : w.prompt?.trim() || l.reminder;
+  };
+  const latest = useRef({ props, l, renderPerson, actionText });
+  latest.current = { props, l, renderPerson, actionText };
+  const columnDefs = useMemo(
+    () => createWorkflowColumns({
+      labels: l,
+      getTriggerText: (w) => isSkillRow(w) ? l.statusOnDemand : latest.current.props.describeTrigger(w),
+      renderName: (w) => {
+        const { l: lb } = latest.current;
+        const skill = isSkillRow(w);
+        const text = skill ? latest.current.actionText(w) : w.description || latest.current.actionText(w);
+        const stem = w.name.replace(/…$/, "").trim();
+        const about = text && text.trim() !== w.name.trim() && text.trim() !== stem ? text : "";
+        return /* @__PURE__ */ jsxs("div", { className: "min-w-0 leading-tight", children: [
+          /* @__PURE__ */ jsxs("span", { className: "flex min-w-0 items-center gap-1.5", children: [
+            /* @__PURE__ */ jsx(
+              "span",
+              {
+                className: cn(
+                  "truncate text-sm font-normal",
+                  workflowStatus(w) === "paused" && "text-muted-foreground"
+                ),
+                "data-testid": `workflow-name-${w.external_id}`,
+                children: w.name
+              }
+            ),
+            skill && /* @__PURE__ */ jsx(
+              "span",
+              {
+                className: "shrink-0 rounded-full border border-border px-1.5 text-[11px] text-muted-foreground",
+                "data-testid": `workflow-type-${w.external_id}`,
+                children: lb.typeSkill
+              }
+            )
+          ] }),
+          about && !latest.current.props.automationsOnly && /* @__PURE__ */ jsx(
+            "p",
+            {
+              className: "truncate text-xs text-muted-foreground",
+              "data-testid": `workflow-action-${w.external_id}`,
+              children: about
+            }
+          )
+        ] });
+      },
+      renderTrigger: (w) => {
+        const { props: p } = latest.current;
+        const after = w.after_conversation_ext_id;
+        const skill = isSkillRow(w);
+        return /* @__PURE__ */ jsx("div", { className: "min-w-0 leading-tight", children: /* @__PURE__ */ jsx(
+          TaskTriggerChip,
+          {
+            id: w.external_id,
+            testId: `workflow-trigger-${w.external_id}`,
+            triggerType: workflowTriggerType(w),
+            summary: skill ? "" : p.describeTrigger(w),
+            afterTaskId: after,
+            afterTaskName: after ? p.taskNames?.[after] : void 0,
+            labels: p.triggerChipLabels
+          }
+        ) });
+      },
+      renderStatus: (w) => {
+        const { props: p, l: lb } = latest.current;
+        const canEdit = w.is_owner !== false || Boolean(p.canEditShared);
+        return /* @__PURE__ */ jsx(
+          Switch,
+          {
+            checked: hasTrigger(w) && !isSkillRow(w) && Boolean(w.active),
+            disabled: !hasTrigger(w) || isSkillRow(w) || !canEdit || p.busyId === w.external_id,
+            onCheckedChange: (next) => p.onToggleActive(w, next),
+            className: "disabled:data-[state=unchecked]:bg-muted dark:disabled:data-[state=unchecked]:bg-muted",
+            "aria-label": lb.activeSwitch(w.name),
+            "data-testid": `workflow-active-${w.external_id}`
+          }
+        );
+      },
+      renderShared: (w) => {
+        const { props: p, l: lb } = latest.current;
+        if (!p.onToggleShared || isSkillRow(w)) return null;
+        const isCreator = w.is_owner !== false;
+        return /* @__PURE__ */ jsx(
+          VisibilityToggle,
+          {
+            items: { shared: w.shared ?? false },
+            onToggle: (share) => latest.current.props.onToggleShared?.(w, share),
+            disabled: !isCreator || p.busyId === w.external_id,
+            disabledTooltip: lb.sharedOwnerOnly,
+            showLabel: false,
+            "data-testid": `workflow-shared-${w.external_id}`
+          }
+        );
+      },
+      renderLastRun: (w) => {
+        const { props: p, l: lb } = latest.current;
+        const at = w.last_fired_at ?? p.lastRuns?.[w.external_id]?.at;
+        return /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            className: "h-full w-full truncate px-4 text-left text-sm hover:text-primary",
+            onClick: () => p.onViewRuns?.(w),
+            title: "View run history",
+            "data-testid": `workflow-last-run-${w.external_id}`,
+            children: at ? p.formatDate(at) : lb.never
+          }
+        );
+      },
+      renderResult: (w) => {
+        const status = listedRunStatus(
+          w.last_run_status,
+          latest.current.props.lastRuns?.[w.external_id]?.threadStatus
+        );
+        const label = workflowRunStatusLabel(status);
+        return /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            onClick: () => latest.current.props.onViewRuns?.(w),
+            title: "View run history",
+            className: cn(
+              badgeVariants({ variant: "outline" }),
+              "mx-4 cursor-pointer text-xs font-medium",
+              status === "failed" ? "border-red-border bg-red-bg text-red-text hover:bg-red-bg/80" : status === "completed" || status === "success" ? "border-green-border bg-green-bg text-green-text hover:bg-green-bg/80" : status ? "border-primary/20 bg-primary/10 text-primary hover:bg-primary/15" : "border-border bg-muted text-muted-foreground hover:bg-muted/80"
+            ),
+            "data-testid": `workflow-result-${w.external_id}`,
+            children: label
+          }
+        );
+      },
+      renderActions: (w) => {
+        const { props: p, l: lb } = latest.current;
+        const id = w.external_id;
+        const skill = isSkillRow(w);
+        const busy = p.busyId === id;
+        const isOwner = w.is_owner !== false;
+        const canEdit = isOwner || Boolean(p.canEditShared);
+        const canAdmin = isOwner || Boolean(p.isWorkspaceOwner);
+        return /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-end gap-1", children: [
+          (skill || canEdit) && /* @__PURE__ */ jsxs(
+            Button,
+            {
+              size: "sm",
+              variant: "outline",
+              className: "h-8 gap-1.5 pointer-coarse:h-11",
+              disabled: busy,
+              onClick: () => p.onRun(w),
+              "data-testid": `workflow-run-btn-${id}`,
+              children: [
+                /* @__PURE__ */ jsx(Play, { className: "size-3.5", "aria-hidden": true }),
+                lb.run
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsxs(DropdownMenu, { children: [
+            /* @__PURE__ */ jsx(DropdownMenuTrigger, { asChild: true, children: /* @__PURE__ */ jsx(
+              Button,
+              {
+                variant: "ghost",
+                size: "icon",
+                className: "size-8 pointer-coarse:size-11",
+                "aria-label": lb.moreActions,
+                "data-testid": `workflow-menu-${id}`,
+                children: /* @__PURE__ */ jsx(MoreHorizontal, { className: "size-4", "aria-hidden": true })
+              }
+            ) }),
+            /* @__PURE__ */ jsxs(DropdownMenuContent, { align: "end", children: [
+              skill && p.onRunLater && /* @__PURE__ */ jsxs(
+                DropdownMenuItem,
+                {
+                  onSelect: () => p.onRunLater?.(w),
+                  "data-testid": `workflow-run-later-${id}`,
+                  children: [
+                    /* @__PURE__ */ jsx(History, { className: "mr-2 size-4", "aria-hidden": true }),
+                    lb.runLater
+                  ]
+                }
+              ),
+              !skill && canEdit && /* @__PURE__ */ jsxs(
+                DropdownMenuItem,
+                {
+                  onSelect: () => p.onEdit(w),
+                  "data-testid": `workflow-edit-${id}`,
+                  children: [
+                    /* @__PURE__ */ jsx(Pencil, { className: "mr-2 size-4", "aria-hidden": true }),
+                    lb.editWorkflow
+                  ]
+                }
+              ),
+              !skill && p.onViewRuns && /* @__PURE__ */ jsxs(
+                DropdownMenuItem,
+                {
+                  onSelect: () => p.onViewRuns?.(w),
+                  "data-testid": `workflow-runs-${id}`,
+                  children: [
+                    /* @__PURE__ */ jsx(History, { className: "mr-2 size-4", "aria-hidden": true }),
+                    lb.runs
+                  ]
+                }
+              ),
+              !skill && canEdit && /* @__PURE__ */ jsxs(Fragment, { children: [
+                /* @__PURE__ */ jsx(DropdownMenuSeparator, {}),
+                /* @__PURE__ */ jsxs(
+                  DropdownMenuItem,
+                  {
+                    disabled: busy || !canAdmin,
+                    onSelect: () => p.onDelete(w),
+                    title: canAdmin ? void 0 : lb.deleteOwnerOnly,
+                    className: "text-destructive focus:text-destructive",
+                    "data-testid": `workflow-delete-${id}`,
+                    children: [
+                      /* @__PURE__ */ jsx(Trash2, { className: "mr-2 size-4", "aria-hidden": true }),
+                      lb.delete
+                    ]
+                  }
+                )
+              ] })
+            ] })
+          ] })
+        ] });
+      }
+    }),
+    // Stable on purpose: only the header texts rebuild the columns (see `latest`).
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+      l.colName,
+      l.colType,
+      l.colTrigger,
+      l.colAction,
+      l.colAgent,
+      l.colStatus,
+      l.colShared,
+      l.shared,
+      l.colLastRun,
+      l.colNextRun
+    ]
+  );
+  useEffect(() => {
+    apiRef.current?.refreshCells({ force: true });
+  }, [
+    busyId,
+    props.agentNames,
+    props.skillNames,
+    props.taskNames,
+    props.lastRuns,
+    props.renderPerson,
+    props.labels,
+    props.canEditShared,
+    props.isWorkspaceOwner
+  ]);
+  const mine = selected.filter((w) => !isSkillRow(w));
+  const adminSelected = mine.filter((w) => w.is_owner !== false || props.isWorkspaceOwner);
+  const editableSelected = mine.filter(
+    (w) => hasTrigger(w) && (w.is_owner !== false || props.canEditShared)
+  );
+  const clearSelection = () => setSelected([]);
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: "flex min-h-0 flex-1 flex-col",
+      "data-testid": testIdOr(testId, { testId: "workflow-list" }),
+      children: [
+        /* @__PURE__ */ jsx(
+          TabHeader,
+          {
+            testId: "automations-tab-header",
+            tabs: [
+              {
+                id: "automations",
+                label: "",
+                count: shown.length,
+                countIcon: /* @__PURE__ */ jsx(Workflow, { className: "size-3.5" }),
+                countPlacement: "leading",
+                presentation: "count",
+                hasActiveFilters: !!q || [...filterStates.values()].some(Boolean)
+              },
+              ...props.tabs ?? []
+            ],
+            activeTabId: props.activeTabId ?? "automations",
+            onTabChange: props.onTabChange ?? (() => {
+            }),
+            firstTabContent: /* @__PURE__ */ jsx(
+              FilterInput,
+              {
+                value: query,
+                onChange: setQuery,
+                fields: ["text"],
+                onFieldsChange: () => {
+                },
+                hideFieldPicker: true,
+                ariaLabel: l.searchLabel,
+                testIds: { input: "workflow-search" },
+                filter: /* @__PURE__ */ jsx(
+                  TriStateFilterMenu,
+                  {
+                    testId: "automations-filter-button",
+                    open: filterOpen,
+                    onOpenChange: setFilterOpen,
+                    filterStates,
+                    onFiltersChange: setFilterStates,
+                    triggerClassName: "flex h-5 items-center gap-0.5 rounded px-1 text-muted-foreground hover:text-foreground pointer-coarse:h-11! pointer-coarse:min-w-11 pointer-coarse:justify-center",
+                    renderChevron: true,
+                    disableHoverOpen: true,
+                    options: [
+                      ...!props.automationsOnly ? [
+                        { id: "skills", label: l.filterSkills, count: counts.skills },
+                        {
+                          id: "workflows",
+                          label: l.filterWorkflows,
+                          count: counts.workflows
+                        }
+                      ] : [],
+                      { id: "active", label: l.filterActive, count: counts.active },
+                      { id: "paused", label: l.filterPaused, count: counts.paused }
+                    ]
+                  }
+                )
+              }
+            ),
+            rightContent: header
+          }
+        ),
+        props.content ? props.content : workflows.length === 0 && !isLoading ? /* @__PURE__ */ jsx(
+          EmptyState,
+          {
+            icon: Workflow,
+            title: l.emptyTitle,
+            description: l.emptyMessage,
+            testId: "workflow-list-empty"
+          }
+        ) : /* @__PURE__ */ jsx("div", { className: "min-h-0 flex-1", children: /* @__PURE__ */ jsx(
+          GridView,
+          {
+            testId: "workflow-grid",
+            gridId: props.gridId ?? "workflows-grid-v2",
+            items: shown,
+            columnDefs,
+            getItemId: (w) => w.external_id,
+            getRowTestId: (w) => `workflow-row-${w.external_id}`,
+            isLoading,
+            showEmpty: shown.length === 0,
+            emptyState: { title: l.noMatches },
+            rowHeight: ROW_HEIGHT,
+            height: "100%",
+            onGridReady: ({ api }) => {
+              apiRef.current = api;
+            },
+            onRowClick: (row) => props.onOpenRow?.(row),
+            selection: { mode: "multiple", selected, onSelectionChange: setSelected },
+            gridOptions: GRID_OPTIONS
+          }
+        ) }),
+        !props.content && /* @__PURE__ */ jsx(SelectionBar, { count: selected.length, onClear: clearSelection, children: (isCompact) => /* @__PURE__ */ jsxs(Fragment, { children: [
+          props.onToggleActiveMany && /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsx(
+              SelectionBarAction,
+              {
+                icon: Play,
+                label: l.makeActive,
+                onClick: () => {
+                  props.onToggleActiveMany?.(editableSelected, true);
+                  clearSelection();
+                },
+                disabled: editableSelected.length === 0,
+                isCompact,
+                testId: "workflow-bulk-activate"
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              SelectionBarAction,
+              {
+                icon: Workflow,
+                label: l.makePaused,
+                onClick: () => {
+                  props.onToggleActiveMany?.(editableSelected, false);
+                  clearSelection();
+                },
+                disabled: editableSelected.length === 0,
+                isCompact,
+                testId: "workflow-bulk-pause"
+              }
+            )
+          ] }),
+          props.onDeleteMany && /* @__PURE__ */ jsx(
+            SelectionBarAction,
+            {
+              icon: Trash2,
+              label: l.delete,
+              onClick: () => {
+                props.onDeleteMany?.(adminSelected);
+                clearSelection();
+              },
+              disabled: adminSelected.length === 0,
+              isCompact,
+              className: "border-red-border text-red-text hover:bg-red-bg hover:text-red-text",
+              testId: "workflow-bulk-delete"
+            }
+          )
+        ] }) })
+      ]
+    }
+  );
+}
+var GRID_OPTIONS = { suppressClickEdit: true };
 var DEFAULT_TASK_ACTIVITY_LABELS = {
   title: "Activity",
   empty: "Nothing has happened yet.",
@@ -2511,6 +4048,6 @@ function TaskActivityTimeline({
   }) });
 }
 
-export { ActionStepBody, ApprovalEvidence, AssigneeLine, DEFAULT_SCHEMA_FORM_LABELS, DEFAULT_STEP_BAR_LABELS, DEFAULT_TASK_ACTIVITY_LABELS, DEFAULT_WORKFLOW_RUNNER_LABELS, DEFAULT_WORKFLOW_STEP_PARTS_LABELS, STEP_LABEL, STEP_LABEL_CURRENT, STEP_LABEL_MAX, SchemaForm, SendBackControl, StepBarFrame, TaskActivityTimeline, WorkflowRunner, WorkflowStepBar, activeStepId, fromPlanAssignee, fromPlanDocumentRef, fromPlanSteps, isIncompleteSignal, layoutFromPlanSteps, stepWindow, taskActivityHeadline, toPlanAssignee, toPlanDocumentRef, toPlanSteps, useWorkflowView };
-//# sourceMappingURL=chunk-2PNNCEPH.js.map
-//# sourceMappingURL=chunk-2PNNCEPH.js.map
+export { ActionStepBody, AgentSelect, ApprovalEvidence, AssigneeLine, DEFAULT_AGENT_SELECT_LABELS, DEFAULT_SCHEMA_FORM_LABELS, DEFAULT_STEP_BAR_LABELS, DEFAULT_TASK_ACTIVITY_LABELS, DEFAULT_TASK_TRIGGER_CHIP_LABELS, DEFAULT_WORKFLOW_CONFIG_DIALOG_LABELS, DEFAULT_WORKFLOW_DOCUMENTS_FIELD_LABELS, DEFAULT_WORKFLOW_LIST_LABELS, DEFAULT_WORKFLOW_RUNNER_LABELS, DEFAULT_WORKFLOW_STEP_PARTS_LABELS, PersonPill, SKILL_MAIN_FILENAME, SKILL_TYPES, STEP_LABEL, STEP_LABEL_CURRENT, STEP_LABEL_MAX, SchemaForm, SendBackControl, StepBarFrame, TaskActivityTimeline, TaskTriggerChip, WORKFLOW_COLUMN_ORDER, WorkflowConfigDialog, WorkflowDocumentsField, WorkflowLauncher, WorkflowRunner, WorkflowStepBar, WorkflowsTable, activeStepId, buildWorkflowScopeSource, buildZipSkillImport, createWorkflowColumns, documentScopeLabels, fromPlanAssignee, fromPlanDocumentRef, fromPlanSteps, hasTrigger, importMarkdownSkill, importSkillFile, importSkillFromUrl, isIncompleteSignal, isMainSkillFile, isSkillRow, layoutFromPlanSteps, matchWorkflowScope, parseSkillFrontmatter, readSkillArchive, serializeSkill, skillSlug, stepWindow, taskActivityHeadline, toPlanAssignee, toPlanDocumentRef, toPlanSteps, useControllableState, useWorkflowView, workflowFromSkillMarkdown, workflowRunStatusLabel, workflowStatus, workflowToSkillMarkdown, workflowTriggerType };
+//# sourceMappingURL=chunk-ATJUVHVB.js.map
+//# sourceMappingURL=chunk-ATJUVHVB.js.map