@arbidocs/blocks 0.4.72 → 0.4.74

package/dist/chunk-YWYVIQ7T.js

@@ -0,0 +1,1402 @@
+"use client";
+import { UploadDropzone } from './chunk-EVUEIBNU.js';
+import { FoldSection } from './chunk-XD2M6LIG.js';
+import { useElementSize } from './chunk-HOXKR26S.js';
+import { testIdOr, prefixedTestId } from './chunk-7F6CBP3Z.js';
+import { useState, useRef, useEffect, useCallback, useMemo, useLayoutEffect } from 'react';
+import { cn, Card, Button, Label, Select, SelectTrigger, SelectValue, SelectContent, SelectItem, Switch, Input, Textarea } from '@arbidocs/react/ui';
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+import { CheckCircle2, ArrowLeft, Loader2, ArrowRight, RotateCw, GitBranch, FileText, Check, AlertTriangle, MinusCircle } from 'lucide-react';
+
+// src/agents/workflows/types.ts
+var EMPTY_WORKFLOW_SCOPE = { folders: [], labels: [] };
+
+// src/agents/workflows/workflow.ts
+var isWorkflowScope = (value) => typeof value === "object" && value !== null && Array.isArray(value.folders) && Array.isArray(value.labels);
+var isEmptyWorkflowScope = (scope) => scope.folders.length === 0 && scope.labels.length === 0 && !scope.documents?.length;
+var isFileField = (field) => field.type === "scope" || field.type === "documents";
+function emptyValue(field) {
+  switch (field.type) {
+    case "boolean":
+      return false;
+    case "scope":
+      return { folders: [], labels: [] };
+    case "documents":
+      return { folders: [], labels: [], documents: [] };
+    default:
+      return "";
+  }
+}
+function defaultInputs(workflow) {
+  const inputs = {};
+  for (const field of workflow.inputs) {
+    const d = field.default;
+    inputs[field.name] = d === void 0 ? emptyValue(field) : isWorkflowScope(d) ? { ...d } : d;
+  }
+  return inputs;
+}
+function validateInputs(workflow, inputs) {
+  const errors = {};
+  for (const field of workflow.inputs) {
+    const value = inputs[field.name];
+    if (field.type === "number") {
+      const blank = value === "" || value === void 0;
+      if (blank) {
+        if (field.required) errors[field.name] = "required";
+        continue;
+      }
+      const n = Number(value);
+      if (Number.isNaN(n)) errors[field.name] = "number";
+      else if (field.min !== void 0 && n < field.min) errors[field.name] = "min";
+      else if (field.max !== void 0 && n > field.max) errors[field.name] = "max";
+      continue;
+    }
+    if (!field.required) continue;
+    if (field.type === "documents") {
+      if (!isWorkflowScope(value) || !value.documents?.length) errors[field.name] = "required";
+      continue;
+    }
+    if (field.type === "boolean" || field.type === "scope") continue;
+    if (typeof value !== "string" || value.trim() === "") errors[field.name] = "required";
+  }
+  return errors;
+}
+function promptFieldName(workflow) {
+  return workflow.inputs.find((f) => !f.advanced && (f.type === "text" || f.type === "longtext"))?.name;
+}
+var quoteList = (names) => {
+  const quoted = names.map((n) => `"${n}"`);
+  return quoted.length <= 1 ? quoted[0] ?? "" : `${quoted.slice(0, -1).join(", ")} and ${quoted[quoted.length - 1]}`;
+};
+function fragment(field, value, ctx) {
+  switch (field.type) {
+    case "documents": {
+      const ids = isWorkflowScope(value) ? value.documents ?? [] : [];
+      const names = ids.flatMap((id) => {
+        const title = ctx?.documentTitles?.[id];
+        return title ? [title] : [];
+      });
+      return quoteList(names);
+    }
+    case "boolean":
+      return value ? field.trueText ?? "yes" : field.falseText ?? "no";
+    case "select": {
+      const option = field.options?.find((o) => o.value === value);
+      return option ? option.text ?? option.label : String(value ?? "");
+    }
+    case "scope":
+      return "";
+    default:
+      return typeof value === "string" ? value.trim() : String(value ?? "");
+  }
+}
+function composeWorkflowPrompt(workflow, inputs, ctx) {
+  if (workflow.run.kind !== "prompt") return "";
+  const byName = new Map(workflow.inputs.map((f) => [f.name, f]));
+  const template = workflow.run.promptTemplate;
+  let out = "";
+  let last = 0;
+  const append = (text, isValue) => {
+    let t = text;
+    if (!isValue) {
+      t = t.replace(/[ \t]{2,}/g, " ");
+      if (/[ \t]$/.test(out)) t = t.replace(/^[ \t]+/, "");
+    }
+    out += t;
+  };
+  for (const m of template.matchAll(/\{\{\s*([a-z][a-z0-9_]*)\s*\}\}/gi)) {
+    append(template.slice(last, m.index), false);
+    const field = byName.get(m[1]);
+    append(field ? fragment(field, inputs[m[1]], ctx) : "", true);
+    last = m.index + m[0].length;
+  }
+  append(template.slice(last), false);
+  return out.trim();
+}
+function buildLaunch(workflow, inputs, agentId) {
+  const scopeField = workflow.inputs.find(isFileField);
+  const raw = scopeField ? inputs[scopeField.name] : void 0;
+  const scope = isWorkflowScope(raw) ? raw : { ...EMPTY_WORKFLOW_SCOPE };
+  return { workflow, inputs, scope, agentId: agentId || workflow.defaultAgentId || void 0 };
+}
+function workflowAccepts(workflow) {
+  const kinds = /* @__PURE__ */ new Set();
+  for (const field of workflow.inputs) if (field.context) kinds.add(field.context);
+  return [...kinds];
+}
+function workflowsAccepting(workflows, supplied) {
+  return workflows.filter((w) => workflowAccepts(w).some((k) => supplied.includes(k)));
+}
+function workflowsForHost(workflows, host) {
+  return workflows.filter((w) => !w.host || w.host === host);
+}
+function inputsFromContext(workflow, context) {
+  const inputs = {};
+  for (const field of workflow.inputs) {
+    if (!field.context) continue;
+    if (field.context === "selection") {
+      if (context.selection) inputs[field.name] = context.selection;
+      continue;
+    }
+    const ids = field.context === "image" ? context.image ? [context.image] : [] : context.documents;
+    if (ids?.length && isFileField(field)) {
+      inputs[field.name] = { folders: [], labels: [], documents: ids.slice(0, field.max ?? 1) };
+    }
+  }
+  return inputs;
+}
+var SKILL_PROMPT_LABEL = "What should it work on?";
+var SKILL_PROMPT_FALLBACK_PLACEHOLDER = "Describe what you want";
+var plainHint = (hint) => hint.replace(/^[<[]\s*|\s*[>\]]$/g, "").trim();
+function skillToWorkflow(skill) {
+  const hint = plainHint((skill.arg_hint ?? "").trim());
+  const inputs = [
+    {
+      name: "args",
+      type: "longtext",
+      label: SKILL_PROMPT_LABEL,
+      placeholder: hint || SKILL_PROMPT_FALLBACK_PLACEHOLDER,
+      required: true
+    }
+  ];
+  return {
+    id: skill.slug,
+    skill: skill.slug,
+    title: skill.name || skill.slug,
+    description: skill.description ?? "",
+    inputs,
+    run: { kind: "prompt", promptTemplate: `/${skill.slug} {{args}}` },
+    landing: "chat",
+    schedulable: true
+  };
+}
+var FIELD_TYPES = [
+  "text",
+  "longtext",
+  "boolean",
+  "select",
+  "number",
+  "date",
+  "scope",
+  "documents"
+];
+var str = (v) => typeof v === "string" ? v : void 0;
+var num = (v) => typeof v === "number" ? v : void 0;
+var bool = (v) => typeof v === "boolean" ? v : void 0;
+function fieldFromFrontmatter(raw) {
+  if (typeof raw !== "object" || raw === null) return null;
+  const r = raw;
+  const name = str(r.name);
+  const type = FIELD_TYPES.find((t) => t === r.type);
+  if (!name || !/^[a-z][a-z0-9_]*$/.test(name) || !type) return null;
+  const options = Array.isArray(r.options) ? r.options.flatMap((o) => {
+    const ro = o;
+    const value = str(ro?.value);
+    const label = str(ro?.label);
+    return value && label ? [
+      {
+        value,
+        label,
+        description: str(ro.description),
+        text: str(ro.text),
+        icon: str(ro.icon)
+      }
+    ] : [];
+  }) : void 0;
+  return {
+    name,
+    type,
+    label: str(r.label) ?? name,
+    description: str(r.description),
+    placeholder: str(r.placeholder),
+    required: bool(r.required),
+    default: r.default,
+    options,
+    min: num(r.min),
+    max: num(r.max),
+    trueText: str(r.true_text),
+    falseText: str(r.false_text),
+    advanced: bool(r.advanced),
+    accept: r.accept === "image" ? "image" : void 0,
+    context: r.context === "documents" || r.context === "selection" || r.context === "image" ? r.context : void 0,
+    by: Array.isArray(r.by) ? r.by.filter((b) => b === "folders" || b === "labels") : void 0
+  };
+}
+function workflowFromFrontmatter(id, frontmatter, body) {
+  const inputs = Array.isArray(frontmatter.inputs) ? frontmatter.inputs.flatMap((f) => {
+    const field = fieldFromFrontmatter(f);
+    return field ? [field] : [];
+  }) : [];
+  return {
+    id,
+    title: str(frontmatter.name) ?? id,
+    description: str(frontmatter.description) ?? "",
+    icon: str(frontmatter.icon),
+    inputs,
+    run: { kind: "prompt", promptTemplate: body.trim() },
+    landing: frontmatter.landing === "files" ? "files" : "chat",
+    requiresFiles: bool(frontmatter.requires_files),
+    schedulable: bool(frontmatter.schedulable) ?? true
+  };
+}
+function fieldToFrontmatter(field) {
+  return compact({
+    name: field.name,
+    type: field.type,
+    label: field.label,
+    description: field.description,
+    placeholder: field.placeholder,
+    required: field.required,
+    default: field.default,
+    options: field.options?.map(
+      (o) => compact({
+        value: o.value,
+        label: o.label,
+        description: o.description,
+        text: o.text,
+        icon: o.icon
+      })
+    ),
+    min: field.min,
+    max: field.max,
+    true_text: field.trueText,
+    false_text: field.falseText,
+    advanced: field.advanced,
+    by: field.by,
+    accept: field.accept,
+    context: field.context
+  });
+}
+var compact = (o) => Object.fromEntries(Object.entries(o).filter(([, v]) => v !== void 0));
+var DEFAULT_SCHEMA_FORM_LABELS = {
+  optional: "(optional)",
+  advanced: "More options",
+  errors: {
+    required: "This is needed to continue",
+    min: "Too small",
+    max: "Too large",
+    number: "Enter a number"
+  }
+};
+var TILE_MAX = 4;
+function FieldControl({
+  field,
+  value,
+  error,
+  onChange,
+  l,
+  idFor,
+  renderScope,
+  renderDocuments,
+  renderIcon,
+  onEnterSubmit
+}) {
+  const id = `${idFor()}-control`;
+  const testId = idFor();
+  switch (field.type) {
+    case "text":
+      return /* @__PURE__ */ jsx(
+        Input,
+        {
+          id,
+          "data-testid": testId,
+          value: String(value ?? ""),
+          placeholder: field.placeholder,
+          "aria-required": field.required || void 0,
+          "aria-invalid": error ? true : void 0,
+          "aria-describedby": error ? idFor("error") : void 0,
+          onChange: (e) => onChange(e.target.value)
+        }
+      );
+    case "longtext":
+      return /* @__PURE__ */ jsx(
+        Textarea,
+        {
+          id,
+          "data-testid": testId,
+          value: String(value ?? ""),
+          placeholder: field.placeholder,
+          "aria-required": field.required || void 0,
+          "aria-invalid": error ? true : void 0,
+          "aria-describedby": error ? idFor("error") : void 0,
+          className: "min-h-[96px]",
+          onChange: (e) => onChange(e.target.value),
+          onKeyDown: (e) => {
+            if (onEnterSubmit && e.key === "Enter" && !e.shiftKey && !e.nativeEvent.isComposing) {
+              e.preventDefault();
+              onEnterSubmit();
+            }
+          }
+        }
+      );
+    case "number":
+      return /* @__PURE__ */ jsx(
+        Input,
+        {
+          id,
+          "data-testid": testId,
+          type: "number",
+          inputMode: "decimal",
+          min: field.min,
+          max: field.max,
+          value: value === void 0 ? "" : String(value),
+          placeholder: field.placeholder,
+          "aria-invalid": error ? true : void 0,
+          "aria-describedby": error ? idFor("error") : void 0,
+          onChange: (e) => onChange(e.target.value === "" ? "" : Number(e.target.value))
+        }
+      );
+    case "date":
+      return /* @__PURE__ */ jsx(
+        Input,
+        {
+          id,
+          "data-testid": testId,
+          type: "date",
+          value: String(value ?? ""),
+          "aria-invalid": error ? true : void 0,
+          "aria-describedby": error ? idFor("error") : void 0,
+          onChange: (e) => onChange(e.target.value)
+        }
+      );
+    case "boolean":
+      return /* @__PURE__ */ jsx(
+        Switch,
+        {
+          id,
+          "data-testid": testId,
+          checked: Boolean(value),
+          onCheckedChange: (checked) => onChange(checked)
+        }
+      );
+    case "select": {
+      const options = field.options ?? [];
+      if (options.length > 0 && options.length <= TILE_MAX) {
+        return /* @__PURE__ */ jsx(
+          "div",
+          {
+            role: "radiogroup",
+            "aria-label": field.label,
+            className: "grid grid-cols-2 gap-2 sm:grid-cols-4",
+            "data-testid": testId,
+            children: options.map((option) => {
+              const selected = value === option.value;
+              return /* @__PURE__ */ jsxs(
+                "button",
+                {
+                  type: "button",
+                  role: "radio",
+                  "aria-checked": selected,
+                  "data-testid": prefixedTestId(testId, option.value, {
+                    testId: `workflow-field-${field.name}-${option.value}`
+                  }),
+                  onClick: () => {
+                    onChange(option.value);
+                  },
+                  className: cn(
+                    "flex min-h-24 flex-col items-center justify-center gap-1.5 rounded-lg border p-3 text-center transition-colors pointer-coarse:min-h-28 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring",
+                    selected ? "border-primary bg-primary/10" : "border-border bg-card [&:hover]:border-primary [&:hover]:bg-muted"
+                  ),
+                  children: [
+                    option.icon && renderIcon && /* @__PURE__ */ jsx("span", { className: "text-muted-foreground", children: renderIcon(option.icon) }),
+                    /* @__PURE__ */ jsx("span", { className: "text-sm font-medium text-foreground", children: option.label }),
+                    option.description && /* @__PURE__ */ jsx("span", { className: "text-xs text-muted-foreground", children: option.description })
+                  ]
+                },
+                option.value
+              );
+            })
+          }
+        );
+      }
+      return /* @__PURE__ */ jsxs(Select, { value: String(value ?? ""), onValueChange: (v) => onChange(v), children: [
+        /* @__PURE__ */ jsx(SelectTrigger, { id, "data-testid": testId, className: "pointer-coarse:min-h-11", children: /* @__PURE__ */ jsx(SelectValue, { placeholder: field.placeholder }) }),
+        /* @__PURE__ */ jsx(SelectContent, { children: options.map((o) => /* @__PURE__ */ jsx(SelectItem, { value: o.value, children: o.label }, o.value)) })
+      ] });
+    }
+    case "scope": {
+      const scope = isWorkflowScope(value) ? value : { folders: [], labels: [] };
+      return /* @__PURE__ */ jsx("div", { "data-testid": testId, children: renderScope?.(field, scope, onChange) });
+    }
+    case "documents": {
+      const picked = isWorkflowScope(value) ? value : { folders: [], labels: [], documents: [] };
+      return /* @__PURE__ */ jsx("div", { "data-testid": testId, children: renderDocuments?.(field, picked, onChange) });
+    }
+  }
+}
+function FormField(props) {
+  const { field, error, l, idFor } = props;
+  const isBoolean = field.type === "boolean";
+  const showOptional = !field.required && field.type !== "boolean" && field.type !== "scope";
+  const label = /* @__PURE__ */ jsxs(
+    Label,
+    {
+      htmlFor: `${idFor()}-control`,
+      className: isBoolean ? "cursor-pointer font-normal" : void 0,
+      children: [
+        field.label,
+        showOptional && /* @__PURE__ */ jsxs(Fragment, { children: [
+          " ",
+          /* @__PURE__ */ jsx("span", { className: "font-normal text-muted-foreground", children: l.optional })
+        ] })
+      ]
+    }
+  );
+  return /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-1.5", "data-slot": "schema-field", "data-field": field.name, children: [
+    isBoolean ? /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2.5 pointer-coarse:min-h-11", children: [
+      /* @__PURE__ */ jsx(FieldControl, { ...props }),
+      label
+    ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+      field.type !== "scope" && label,
+      /* @__PURE__ */ jsx(FieldControl, { ...props })
+    ] }),
+    field.description && /* @__PURE__ */ jsx("p", { className: "text-xs text-muted-foreground", children: field.description }),
+    error && /* @__PURE__ */ jsx(
+      "p",
+      {
+        id: idFor("error"),
+        role: "alert",
+        className: "text-xs text-destructive",
+        "data-testid": idFor("error"),
+        children: l.errors[error]
+      }
+    )
+  ] });
+}
+function SchemaForm({
+  fields,
+  values,
+  onChange,
+  errors,
+  renderScope,
+  renderDocuments,
+  renderIcon,
+  onEnterSubmit,
+  testIdPrefix,
+  labels,
+  className
+}) {
+  const l = {
+    ...DEFAULT_SCHEMA_FORM_LABELS,
+    ...labels,
+    errors: { ...DEFAULT_SCHEMA_FORM_LABELS.errors, ...labels?.errors }
+  };
+  const [advancedOpen, setAdvancedOpen] = useState(false);
+  const common = fields.filter((f) => !f.advanced);
+  const advanced = fields.filter((f) => f.advanced);
+  const render = (field) => /* @__PURE__ */ jsx(
+    FormField,
+    {
+      field,
+      value: values[field.name],
+      error: errors?.[field.name],
+      onChange: (v) => onChange(field.name, v),
+      l,
+      idFor: (suffix) => suffix ? `${testIdOr(testIdPrefix, { testId: "workflow-field" })}-${field.name}-${suffix}` : `${testIdOr(testIdPrefix, { testId: "workflow-field" })}-${field.name}`,
+      renderScope,
+      renderDocuments,
+      renderIcon,
+      onEnterSubmit
+    },
+    field.name
+  );
+  return /* @__PURE__ */ jsxs("div", { className: cn("flex flex-col gap-4", className), "data-slot": "schema-form", children: [
+    common.map(render),
+    advanced.length > 0 && /* @__PURE__ */ jsx(
+      FoldSection,
+      {
+        label: l.advanced,
+        open: advancedOpen,
+        onOpenChange: setAdvancedOpen,
+        testId: `${testIdOr(testIdPrefix, { testId: "workflow-field" })}-advanced-toggle`,
+        children: /* @__PURE__ */ jsx("div", { className: "flex flex-col gap-4", children: advanced.map(render) })
+      }
+    )
+  ] });
+}
+
+// src/agents/workflows/run.ts
+function workflowSteps(workflow) {
+  return workflow.run.kind === "steps" ? workflow.run.steps : [];
+}
+var isSteppedWorkflow = (workflow) => workflow.run.kind === "steps";
+function stepDependencies(steps, id) {
+  const i = steps.findIndex((s) => s.id === id);
+  if (i < 0) return [];
+  return steps[i].after ?? (i > 0 ? [steps[i - 1].id] : []);
+}
+function dependsOn(steps, a, b) {
+  const seen = /* @__PURE__ */ new Set();
+  const stack = [...stepDependencies(steps, a)];
+  while (stack.length) {
+    const id = stack.pop();
+    if (id === b) return true;
+    if (seen.has(id)) continue;
+    seen.add(id);
+    stack.push(...stepDependencies(steps, id));
+  }
+  return false;
+}
+function orderSteps(steps) {
+  const explicit = steps.map((s) => ({ ...s, after: stepDependencies(steps, s.id) }));
+  const known = new Set(explicit.map((s) => s.id));
+  const placed = /* @__PURE__ */ new Set();
+  const out = [];
+  let progress = true;
+  while (out.length < explicit.length && progress) {
+    progress = false;
+    for (const s of explicit) {
+      if (placed.has(s.id)) continue;
+      if (s.after.every((d) => placed.has(d) || !known.has(d))) {
+        out.push(s);
+        placed.add(s.id);
+        progress = true;
+        break;
+      }
+    }
+  }
+  return [...out, ...explicit.filter((s) => !placed.has(s.id))];
+}
+function validateWorkflowGraph(steps) {
+  const problems = [];
+  const ids = /* @__PURE__ */ new Set();
+  for (const s of steps) {
+    if (ids.has(s.id)) problems.push({ code: "duplicate", step: s.id });
+    ids.add(s.id);
+  }
+  steps.forEach((s, i) => {
+    for (const d of stepDependencies(steps, s.id)) {
+      if (!ids.has(d)) problems.push({ code: "unknown", step: s.id, dependency: d });
+      else if (d === s.id || dependsOn(steps, d, s.id)) problems.push({ code: "cycle", step: s.id });
+      else if (steps.findIndex((x) => x.id === d) > i)
+        problems.push({ code: "order", step: s.id, dependency: d });
+    }
+  });
+  return problems;
+}
+function stepLevels(steps) {
+  const depth = /* @__PURE__ */ new Map();
+  for (const s of steps) {
+    const deps = stepDependencies(steps, s.id).filter((d) => depth.has(d));
+    depth.set(s.id, deps.length ? Math.max(...deps.map((d) => depth.get(d))) + 1 : 0);
+  }
+  const levels = [];
+  for (const s of steps) (levels[depth.get(s.id)] ??= []).push(s);
+  return levels.filter(Boolean);
+}
+var STEP_EVENTS = {
+  step_started: "running",
+  step_done: "done",
+  step_skipped: "skipped",
+  step_failed: "failed"
+};
+function stepStatesFromActivity(events) {
+  const states = {};
+  for (const e of events) {
+    const status = STEP_EVENTS[e.kind];
+    const step = e.detail?.step;
+    if (!status || typeof step !== "string") continue;
+    const responseId = typeof e.detail?.response_id === "string" ? e.detail.response_id : void 0;
+    const error = typeof e.detail?.error === "string" ? e.detail.error : null;
+    const startedAt = status === "running" ? e.created_at : states[step]?.startedAt;
+    states[step] = {
+      status,
+      responseId: responseId ?? states[step]?.responseId ?? null,
+      error,
+      ...startedAt ? { startedAt } : {}
+    };
+  }
+  return states;
+}
+function runFields(workflow) {
+  return [
+    ...workflow.inputs,
+    ...workflowSteps(workflow).flatMap((s) => s.kind === "form" ? s.inputs : [])
+  ];
+}
+function initialRunInputs(workflow, inputs = {}) {
+  return { ...defaultInputs({ ...workflow, inputs: runFields(workflow) }), ...inputs };
+}
+var finished = (s) => s?.status === "done" || s?.status === "skipped";
+function stepPhase(steps, states, id) {
+  const s = states[id];
+  if (s && s.status !== "pending") return s.status;
+  return stepDependencies(steps, id).every((d) => finished(states[d])) ? "ready" : "blocked";
+}
+var isRunFinished = (steps, states) => steps.length > 0 && steps.every((s) => finished(states[s.id]));
+var isPersonStep = (step) => step.kind !== "agent";
+function nextAction(steps, states, current) {
+  const i = steps.findIndex((s) => s.id === current);
+  const step = steps[i];
+  if (!step) return "wait";
+  const phase = stepPhase(steps, states, step.id);
+  if (phase === "blocked") return "wait";
+  const following = steps[i + 1];
+  const independentNext = !!following && !dependsOn(steps, following.id, step.id);
+  if (phase === "done" || phase === "skipped") {
+    if (following) return "move";
+    return isRunFinished(steps, states) ? "finish" : "wait";
+  }
+  if (isPersonStep(step)) return "complete";
+  if (phase !== "failed") return independentNext ? "move" : "wait";
+  const waitedFor = steps.slice(i + 1).some((s) => dependsOn(steps, s.id, step.id));
+  return waitedFor || !following ? "skip" : "move";
+}
+function validateStep(step, inputs) {
+  if (step.kind !== "form") return {};
+  return validateInputs(
+    {
+      id: step.id,
+      title: step.title,
+      inputs: step.inputs},
+    inputs
+  );
+}
+var asText = (value) => typeof value === "string" ? value.trim() : typeof value === "number" ? String(value) : "";
+function fillStepInputs(templates, inputs) {
+  const out = {};
+  for (const [name, template] of Object.entries(templates ?? {})) {
+    const bare = /^\{\{\s*([a-z][a-z0-9_]*)\s*\}\}$/i.exec(template);
+    if (bare) {
+      out[name] = inputs[bare[1]] ?? "";
+      continue;
+    }
+    out[name] = fillRunText(template, inputs);
+  }
+  return out;
+}
+function fillRunText(template, inputs) {
+  return template.replace(/\{\{([^}]*)\}\}/g, (_, expr) => {
+    for (const ref of expr.split("||")) {
+      const text = asText(inputs[ref.trim()]);
+      if (text) return text;
+    }
+    return "";
+  }).trim();
+}
+function runThreadTitle(workflow, inputs) {
+  const template = workflow.run.kind === "steps" ? workflow.run.threadTitle : void 0;
+  return template && fillRunText(template, inputs) || workflow.title;
+}
+function reviewInstructions(step, inputs) {
+  return step.instructions && fillRunText(step.instructions, inputs) || step.title;
+}
+function composeStepPrompt(workflow, step, runInputs, { resolveWorkflow, compose } = {}) {
+  if (step.workflow) {
+    const target = resolveWorkflow?.(step.workflow);
+    if (!target) return "";
+    const inputs = { ...defaultInputs(target), ...fillStepInputs(step.with, runInputs) };
+    return target.run.kind === "prompt" ? composeWorkflowPrompt(target, inputs) : compose?.(target.id, inputs, runInputs) ?? "";
+  }
+  if (step.run?.kind === "prompt") {
+    return composeWorkflowPrompt(
+      { ...workflow, inputs: runFields(workflow), run: step.run },
+      runInputs
+    );
+  }
+  return compose?.(step.id, runInputs, runInputs) ?? "";
+}
+
+// src/agents/workflows/planSteps.ts
+var compact2 = (o) => Object.fromEntries(Object.entries(o).filter(([, v]) => v !== void 0 && v !== ""));
+function placeholders(workflow) {
+  return Object.fromEntries(runFields(workflow).map((f) => [f.name, `{{${f.name}}}`]));
+}
+function agentStep(workflow, step, options) {
+  const target = step.workflow ? options.resolveWorkflow?.(step.workflow) : void 0;
+  if (target?.skill) return { skill: target.skill, inputs: step.with ?? {}, prompt: null };
+  const given = Object.entries(options.inputs ?? {}).filter(
+    ([, v]) => v !== void 0 && v !== null && v !== ""
+  );
+  const inputs = { ...placeholders(workflow), ...Object.fromEntries(given) };
+  return { skill: null, inputs: null, prompt: composeStepPrompt(workflow, step, inputs, options) };
+}
+function toPlanSteps(workflow, options = {}) {
+  const layout = workflow.run.kind === "steps" ? workflow.run.layout : void 0;
+  return workflowSteps(workflow).map((step) => {
+    const ui = compact2({
+      description: step.description,
+      icon: step.icon,
+      commit: step.commit,
+      next_label: step.nextLabel,
+      position: layout?.[step.id],
+      ...step.kind === "form" ? { fields: step.inputs } : {},
+      ...step.kind === "upload" ? { required: step.required, accept: step.accept, hint: step.hint } : {},
+      ...step.kind === "review" ? { instructions: step.instructions } : {},
+      ...step.kind === "agent" ? {
+        output: step.output,
+        workflow: step.workflow,
+        with: step.with,
+        prompt_template: step.run?.kind === "prompt" ? step.run.promptTemplate : void 0
+      } : {}
+    });
+    return {
+      id: step.id,
+      title: step.title,
+      kind: step.kind,
+      after: step.after ?? null,
+      branch: step.kind === "agent" && !!step.branch,
+      requires_files: false,
+      ui,
+      ...step.kind === "agent" ? agentStep(workflow, step, options) : { skill: null, inputs: null, prompt: null }
+    };
+  });
+}
+function fromPlanSteps(steps) {
+  return (steps ?? []).map((p) => {
+    const ui = p.ui ?? {};
+    const base = {
+      id: p.id,
+      title: p.title,
+      description: ui.description,
+      icon: ui.icon,
+      commit: ui.commit,
+      nextLabel: ui.next_label,
+      ...p.after != null ? { after: p.after } : {}
+    };
+    switch (p.kind) {
+      case "form":
+        return { ...base, kind: "form", inputs: ui.fields ?? [] };
+      case "upload":
+        return { ...base, kind: "upload", required: ui.required, accept: ui.accept, hint: ui.hint };
+      case "review":
+        return { ...base, kind: "review", instructions: ui.instructions };
+      default: {
+        const promptTemplate = ui.prompt_template ?? p.prompt ?? void 0;
+        return {
+          ...base,
+          kind: "agent",
+          workflow: ui.workflow ?? p.skill ?? void 0,
+          with: ui.with ?? p.inputs ?? void 0,
+          run: !ui.workflow && !p.skill && promptTemplate ? { kind: "prompt", promptTemplate } : void 0,
+          output: ui.output,
+          branch: p.branch || void 0
+        };
+      }
+    }
+  });
+}
+function layoutFromPlanSteps(steps) {
+  const entries = (steps ?? []).flatMap((p) => {
+    const position = p.ui?.position;
+    return position ? [[p.id, position]] : [];
+  });
+  return entries.length ? Object.fromEntries(entries) : void 0;
+}
+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"));
+  return open?.id ?? (steps.length && isRunFinished(steps, states) ? null : steps[0]?.id ?? null);
+}
+function useWorkflowView(options) {
+  const { steps, states, inputs, setInput } = options;
+  const [current, setCurrent] = useState(() => firstOpen(steps, states));
+  const [showErrors, setShowErrors] = useState(false);
+  const [busy, setBusy] = useState(false);
+  const [actionError, setActionError] = useState(null);
+  const optionsRef = useRef(options);
+  optionsRef.current = options;
+  const placed = useRef(steps.length > 0);
+  useEffect(() => {
+    if (placed.current || steps.length === 0) return;
+    placed.current = true;
+    setCurrent(firstOpen(steps, states));
+  }, [steps, states]);
+  const step = steps.find((s) => s.id === current);
+  const following = useCallback(
+    (id) => {
+      const i = steps.findIndex((s) => s.id === id);
+      return steps[i + 1]?.id ?? null;
+    },
+    [steps]
+  );
+  const onward = useCallback(
+    (id) => {
+      const { steps: s, states: st } = optionsRef.current;
+      const i = s.findIndex((x) => x.id === id);
+      const open = s.slice(i + 1).find((x) => !["done", "skipped"].includes(st[x.id]?.status ?? "pending"));
+      return open?.id ?? following(id);
+    },
+    [following]
+  );
+  const action = busy ? "wait" : nextAction(steps, states, current);
+  const next = useCallback(async () => {
+    const { steps: s, states: st, inputs: values } = optionsRef.current;
+    const at = s.find((x) => x.id === current);
+    const act2 = nextAction(s, st, current);
+    if (!at || act2 === "wait" || busy) return;
+    setActionError(null);
+    if (act2 === "finish") return setCurrent(null);
+    if (act2 === "move") return setCurrent(following(current));
+    setBusy(true);
+    try {
+      if (act2 === "skip") {
+        await optionsRef.current.skip(at.id);
+      } else {
+        if (Object.keys(validateStep(at, values)).length > 0) {
+          setShowErrors(true);
+          return;
+        }
+        await optionsRef.current.complete(at);
+      }
+      setShowErrors(false);
+      setCurrent(onward(at.id) ?? current);
+    } catch (e) {
+      setActionError(errorMessage(e));
+    } finally {
+      setBusy(false);
+    }
+  }, [current, busy, following, onward]);
+  const goTo = useCallback((stepId) => {
+    setShowErrors(false);
+    setActionError(null);
+    setCurrent(stepId);
+  }, []);
+  const index = steps.findIndex((s) => s.id === current);
+  const back = useCallback(() => {
+    const i = steps.findIndex((s) => s.id === current);
+    const to = i < 0 ? steps[steps.length - 1] : steps[i - 1];
+    if (to) goTo(to.id);
+  }, [steps, current, goTo]);
+  const act = useCallback(
+    (fn) => fn && (async (stepId) => {
+      setBusy(true);
+      setActionError(null);
+      try {
+        await fn(stepId);
+      } catch (e) {
+        setActionError(errorMessage(e));
+      } finally {
+        setBusy(false);
+      }
+    }),
+    []
+  );
+  const currentRef = useRef(current);
+  currentRef.current = current;
+  const skip = useMemo(
+    () => act(async (id) => {
+      await optionsRef.current.skip(id);
+      if (currentRef.current !== id) return;
+      setShowErrors(false);
+      setCurrent(onward(id) ?? id);
+    }),
+    [act, onward]
+  );
+  const retry = useMemo(
+    () => options.retry ? act((id) => optionsRef.current.retry?.(id) ?? Promise.resolve()) : void 0,
+    // Only whether the host offers retry matters here.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [act, !!options.retry]
+  );
+  const isLocked = useCallback(
+    (stepId) => optionsRef.current.isLocked?.(stepId) ?? false,
+    []
+  );
+  return {
+    steps,
+    step,
+    current,
+    isComplete: current === null,
+    inputs,
+    setInput,
+    stateOf: (id) => states[id],
+    phaseOf: (id) => stepPhase(steps, states, id),
+    isLocked,
+    errors: showErrors && step && !isLocked(step.id) ? validateStep(step, inputs) : {},
+    busy,
+    actionError,
+    isRunning: Object.values(states).some((s) => s.status === "running"),
+    action,
+    canBack: (current === null || index > 0) && !busy,
+    next,
+    back,
+    goTo,
+    skip,
+    retry,
+    restart: () => {
+      setShowErrors(false);
+      setActionError(null);
+      setCurrent(steps[0]?.id ?? null);
+    }
+  };
+}
+function PhaseMark({ phase, icon }) {
+  if (phase === "done") return /* @__PURE__ */ jsx(Check, { className: "size-3.5 shrink-0" });
+  if (phase === "running") return /* @__PURE__ */ jsx(Loader2, { className: "size-3.5 shrink-0 animate-spin" });
+  if (phase === "failed") return /* @__PURE__ */ jsx(AlertTriangle, { className: "size-3.5 shrink-0" });
+  if (phase === "skipped") return /* @__PURE__ */ jsx(MinusCircle, { className: "size-3.5 shrink-0" });
+  return icon ? /* @__PURE__ */ jsx("span", { className: "flex size-3.5 shrink-0 items-center justify-center [&_svg]:size-3.5", children: icon }) : null;
+}
+var PILL = "flex min-w-0 max-w-full shrink-0 items-center gap-2 whitespace-nowrap rounded-full border px-2.5 py-1.5 text-xs font-medium";
+var LABEL = "min-w-0 max-w-[12rem] truncate";
+function WorkflowStepBar({
+  run,
+  levels,
+  doneTitle,
+  doneIcon,
+  icon,
+  tid
+}) {
+  const box = useRef(null);
+  const measure = useRef(null);
+  const row = useRef(null);
+  const { width } = useElementSize(box);
+  const [compact3, setCompact] = useState(false);
+  const titles = levels.map((l) => l.map((s) => s.title).join("\0")).join("
") + doneTitle;
+  useLayoutEffect(() => {
+    const needed = measure.current?.scrollWidth ?? 0;
+    setCompact(width > 0 && needed > width);
+  }, [width, titles]);
+  useLayoutEffect(() => {
+    if (!compact3) return;
+    const el = row.current?.querySelector('[aria-current="step"]');
+    el?.scrollIntoView?.({ block: "nearest", inline: "nearest" });
+  }, [compact3, run.current]);
+  const pill = (s) => {
+    const phase = run.phaseOf(s.id);
+    const current = s.id === run.current;
+    return /* @__PURE__ */ jsxs(
+      "button",
+      {
+        type: "button",
+        onClick: () => run.goTo(s.id),
+        disabled: run.busy,
+        className: cn(
+          PILL,
+          "transition-colors disabled:cursor-default",
+          current ? "border-primary bg-primary/10 text-primary" : phase === "failed" ? "border-destructive/40 text-destructive" : phase === "done" || phase === "skipped" || phase === "running" ? "border-primary/30 bg-primary/5 text-primary" : "border-border text-muted-foreground"
+        ),
+        "aria-current": current ? "step" : void 0,
+        "aria-label": s.title,
+        title: s.title,
+        "data-phase": phase,
+        "data-testid": tid(`step-${s.id}`),
+        children: [
+          /* @__PURE__ */ jsx(PhaseMark, { phase, icon: icon(s.icon) }),
+          (current || !compact3) && /* @__PURE__ */ jsx("span", { className: LABEL, "data-testid": tid(`step-${s.id}-label`), children: s.title })
+        ]
+      },
+      s.id
+    );
+  };
+  const done = run.isComplete;
+  return /* @__PURE__ */ jsxs("div", { ref: box, className: "relative min-w-0", children: [
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref: measure,
+        "aria-hidden": true,
+        className: "pointer-events-none invisible absolute left-0 top-0 flex w-max items-center gap-1.5",
+        children: [...levels, [{ id: "__done", title: doneTitle }]].map((level, i) => /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-1.5", children: [
+          /* @__PURE__ */ jsx("div", { className: "flex flex-col items-start gap-1", children: level.map((s) => /* @__PURE__ */ jsxs("div", { className: PILL, children: [
+            /* @__PURE__ */ jsx("span", { className: "size-3.5 shrink-0" }),
+            /* @__PURE__ */ jsx(
+              "span",
+              {
+                className: cn(LABEL, "before:content-[attr(data-label)]"),
+                "data-label": s.title
+              }
+            )
+          ] }, s.id)) }),
+          i < levels.length && /* @__PURE__ */ jsx("div", { className: "w-2" })
+        ] }, i))
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "ol",
+      {
+        ref: row,
+        className: cn("flex w-full items-center gap-1.5", compact3 && "overflow-x-auto pb-1"),
+        "data-compact": compact3 || void 0,
+        "data-testid": tid("steps"),
+        children: [...levels, null].map((level, i) => /* @__PURE__ */ jsxs(
+          "li",
+          {
+            className: cn(
+              "flex min-w-0 items-center gap-1.5",
+              i < levels.length && !compact3 && "flex-1",
+              compact3 && "flex-none"
+            ),
+            children: [
+              level ? /* @__PURE__ */ jsx("div", { className: "flex min-w-0 flex-col items-start gap-1", children: level.map(pill) }) : /* @__PURE__ */ jsxs(
+                "div",
+                {
+                  className: cn(
+                    PILL,
+                    done ? "border-primary bg-primary/10 text-primary" : "border-border text-muted-foreground"
+                  ),
+                  "aria-current": done ? "step" : void 0,
+                  "aria-label": doneTitle,
+                  title: doneTitle,
+                  "data-testid": tid("step-done"),
+                  children: [
+                    /* @__PURE__ */ jsx(PhaseMark, { phase: "ready", icon: doneIcon }),
+                    (done || !compact3) && /* @__PURE__ */ jsx("span", { className: LABEL, children: doneTitle })
+                  ]
+                }
+              ),
+              i < levels.length && /* @__PURE__ */ jsx(
+                "div",
+                {
+                  className: cn(
+                    "h-px",
+                    compact3 ? "w-3 flex-none" : "min-w-2 flex-1",
+                    level?.every((s) => ["done", "skipped"].includes(run.phaseOf(s.id))) ? "bg-primary/40" : "bg-border"
+                  )
+                }
+              )
+            ]
+          },
+          level ? level.map((s) => s.id).join("+") : "done"
+        ))
+      }
+    )
+  ] });
+}
+var DEFAULT_WORKFLOW_RUNNER_LABELS = {
+  back: "Back",
+  next: "Continue",
+  skip: "Skip",
+  skipStep: "Skip this step",
+  finish: "Finish",
+  approve: "Approve",
+  working: "Working\u2026",
+  stepWorking: "{step}\u2026 {elapsed}",
+  starting: "Starting\u2026",
+  retry: "Retry",
+  failed: "This step did not finish.",
+  blocked: "Starts after {steps}.",
+  awaitingReview: "Waiting for approval.",
+  approved: "Approved.",
+  skipped: "Skipped.",
+  branch: "Runs alongside; its result joins the thread",
+  complete: "Done",
+  restart: "Start again",
+  filesHeading: "Already in the workspace ({count})",
+  addedHeading: "Added for this step ({count})",
+  noFiles: "No files yet.",
+  fileReading: "Reading\u2026",
+  fileReady: "Ready",
+  fileFailed: "Could not be read",
+  readingFiles: "Reading {current} of {count} files\u2026"
+};
+function WorkflowRunner({
+  workflow,
+  run,
+  renderAgentOutput,
+  renderReview,
+  onUpload,
+  uploading = false,
+  files,
+  renderUpload,
+  renderStepNote,
+  renderComplete,
+  renderScope,
+  renderDocuments,
+  renderIcon,
+  labels,
+  testIdPrefix = "workflow-run",
+  className
+}) {
+  const l = { ...DEFAULT_WORKFLOW_RUNNER_LABELS, ...labels };
+  const { steps, step, isComplete, action } = run;
+  const completion = workflow.run.kind === "steps" ? workflow.run.completion : void 0;
+  const tid = (suffix) => `${testIdPrefix}-${suffix}`;
+  const levels = stepLevels(steps);
+  const icon = (key) => key && renderIcon ? renderIcon(key) : void 0;
+  const added = step?.kind === "upload" ? (files ?? []).filter((f) => f.addedFor === step.id) : [];
+  const unread = added.filter((f) => f.status === "processing").length;
+  const reading = action === "complete" && unread > 0;
+  const nextLabel = reading ? l.readingFiles.replace("{current}", String(Math.min(added.length - unread + 1, added.length))).replace("{count}", String(added.length)) : action === "skip" ? l.skip : action === "finish" ? l.finish : action === "complete" && step?.kind === "review" ? l.approve : action === "wait" && (run.isRunning || run.busy) ? l.working : (step && !run.isLocked(step.id) ? step.nextLabel : void 0) ?? l.next;
+  return /* @__PURE__ */ jsxs("div", { className: cn("space-y-6", className), "data-testid": testIdPrefix, children: [
+    /* @__PURE__ */ jsx(
+      WorkflowStepBar,
+      {
+        run,
+        levels,
+        doneTitle: completion?.title ?? l.complete,
+        doneIcon: icon(completion?.icon),
+        icon,
+        tid
+      }
+    ),
+    isComplete ? renderComplete?.(run) ?? /* @__PURE__ */ jsxs(Card, { className: "mx-auto max-w-lg p-8 text-center", "data-testid": tid("done"), children: [
+      /* @__PURE__ */ jsx(CheckCircle2, { className: "mx-auto size-12 text-primary" }),
+      /* @__PURE__ */ jsx("h2", { className: "mt-4 text-xl font-semibold", children: completion?.title ?? l.complete }),
+      completion?.description && /* @__PURE__ */ jsx("p", { className: "mt-1 text-sm text-muted-foreground", children: completion.description }),
+      /* @__PURE__ */ jsx(
+        Button,
+        {
+          variant: "outline",
+          className: "mt-6",
+          onClick: run.restart,
+          "data-testid": tid("restart"),
+          children: l.restart
+        }
+      )
+    ] }) : step ? /* @__PURE__ */ jsx("div", { className: "space-y-3", children: run.phaseOf(step.id) === "blocked" ? /* @__PURE__ */ jsx(Card, { className: "max-w-2xl p-6", "data-testid": tid(step.id), children: /* @__PURE__ */ jsx("p", { className: "text-sm text-muted-foreground", "data-testid": tid(`${step.id}-blocked`), children: l.blocked.replace(
+      "{steps}",
+      stepDependencies(steps, step.id).map((d) => steps.find((s) => s.id === d)?.title ?? d).join(", ")
+    ) }) }) : step.kind === "form" ? /* @__PURE__ */ jsxs(Card, { className: "max-w-2xl space-y-4 p-6", "data-testid": tid(step.id), children: [
+      /* @__PURE__ */ jsx(StepHeading, { step, icon: icon(step.icon), testId: tid(`${step.id}-title`) }),
+      /* @__PURE__ */ jsx("fieldset", { disabled: run.isLocked(step.id), className: "contents", children: /* @__PURE__ */ jsx(
+        SchemaForm,
+        {
+          fields: step.inputs,
+          values: run.inputs,
+          onChange: run.setInput,
+          errors: run.errors,
+          renderScope,
+          renderDocuments,
+          renderIcon,
+          onEnterSubmit: () => void run.next(),
+          testIdPrefix: tid("field")
+        }
+      ) }),
+      run.actionError && /* @__PURE__ */ jsx("p", { className: "text-sm text-destructive", "data-testid": tid("action-error"), children: run.actionError }),
+      renderStepNote?.(step, run)
+    ] }) : step.kind === "upload" ? /* @__PURE__ */ jsxs(Card, { className: "max-w-2xl space-y-4 p-6", "data-testid": tid(step.id), children: [
+      renderUpload?.(step) ?? /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx(
+          UploadDropzone,
+          {
+            onFiles: (picked) => void onUpload?.(picked, step),
+            uploading,
+            disabled: !onUpload,
+            accept: step.accept,
+            title: step.title,
+            description: step.description,
+            hint: step.hint,
+            testId: tid(`${step.id}-drop`)
+          }
+        ),
+        files && /* @__PURE__ */ jsx(
+          UploadFiles,
+          {
+            added,
+            others: files.filter((f) => f.addedFor !== step.id),
+            l,
+            testId: tid(`${step.id}-files`)
+          }
+        )
+      ] }),
+      run.actionError && /* @__PURE__ */ jsx("p", { className: "text-sm text-destructive", children: run.actionError }),
+      renderStepNote?.(step, run)
+    ] }) : step.kind === "review" ? /* @__PURE__ */ jsxs(Card, { className: "max-w-2xl space-y-4 p-6", "data-testid": tid(step.id), children: [
+      /* @__PURE__ */ jsx(StepHeading, { step, icon: icon(step.icon) }),
+      /* @__PURE__ */ jsx("p", { className: "whitespace-pre-line text-sm text-muted-foreground", children: reviewInstructions(step, run.inputs) }),
+      /* @__PURE__ */ jsx("p", { className: "text-sm", "data-testid": tid(`${step.id}-status`), children: run.phaseOf(step.id) === "done" ? l.approved : run.phaseOf(step.id) === "skipped" ? l.skipped : l.awaitingReview }),
+      run.phaseOf(step.id) === "ready" && renderReview?.(step),
+      run.actionError && /* @__PURE__ */ jsx("p", { className: "text-sm text-destructive", children: run.actionError }),
+      renderStepNote?.(step, run)
+    ] }) : /* @__PURE__ */ jsx(
+      AgentStepBody,
+      {
+        step,
+        run,
+        renderAgentOutput,
+        icon: icon(step.icon),
+        renderStepNote,
+        l,
+        tid
+      }
+    ) }, step.id) : null,
+    !isComplete && /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between border-t border-border pt-4", children: [
+      /* @__PURE__ */ jsxs(
+        Button,
+        {
+          variant: "ghost",
+          onClick: run.back,
+          disabled: !run.canBack,
+          "data-testid": tid("back"),
+          children: [
+            /* @__PURE__ */ jsx(ArrowLeft, { className: "size-4" }),
+            " ",
+            l.back
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+        step && action !== "skip" && // A step that commits (creates the matter, starts the thread) is what the run stands on.
+        !step.commit && ["ready", "blocked", "failed"].includes(run.phaseOf(step.id)) && /* @__PURE__ */ jsx(
+          Button,
+          {
+            variant: "ghost",
+            onClick: () => void run.skip(step.id),
+            disabled: run.busy,
+            "data-testid": tid("skip-step"),
+            children: l.skipStep
+          }
+        ),
+        /* @__PURE__ */ jsxs(
+          Button,
+          {
+            onClick: () => void run.next(),
+            disabled: action === "wait" || reading,
+            "data-testid": tid("next"),
+            children: [
+              nextLabel,
+              reading || action === "wait" && (run.isRunning || run.busy) ? /* @__PURE__ */ jsx(Loader2, { className: "size-4 animate-spin" }) : /* @__PURE__ */ jsx(ArrowRight, { className: "size-4" })
+            ]
+          }
+        )
+      ] })
+    ] })
+  ] });
+}
+function UploadFiles({
+  added,
+  others,
+  l,
+  testId
+}) {
+  const heading = "text-xs font-semibold uppercase tracking-wide text-muted-foreground";
+  const row = (f) => /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: "flex items-center gap-2 text-sm text-muted-foreground",
+      "data-status": f.status,
+      "data-testid": `${testId}-file-${f.id}`,
+      children: [
+        /* @__PURE__ */ jsx(FileText, { className: "size-3.5 shrink-0 text-primary" }),
+        /* @__PURE__ */ jsx("span", { className: "min-w-0 flex-1 truncate", title: f.name, children: f.name }),
+        f.status === "processing" && /* @__PURE__ */ jsxs("span", { className: "flex shrink-0 items-center gap-1 text-xs", children: [
+          /* @__PURE__ */ jsx(Loader2, { className: "size-3 animate-spin" }),
+          " ",
+          l.fileReading
+        ] }),
+        f.status === "ready" && /* @__PURE__ */ jsxs("span", { className: "flex shrink-0 items-center gap-1 text-xs text-primary", children: [
+          /* @__PURE__ */ jsx(Check, { className: "size-3" }),
+          " ",
+          l.fileReady
+        ] }),
+        f.status === "failed" && /* @__PURE__ */ jsxs("span", { className: "flex shrink-0 items-center gap-1 text-xs text-destructive", children: [
+          /* @__PURE__ */ jsx(AlertTriangle, { className: "size-3" }),
+          " ",
+          l.fileFailed
+        ] })
+      ]
+    },
+    f.id
+  );
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-3", "data-testid": testId, children: [
+    added.length > 0 && /* @__PURE__ */ jsxs("div", { className: "space-y-1", "data-testid": `${testId}-added`, children: [
+      /* @__PURE__ */ jsx("p", { className: heading, children: l.addedHeading.replace("{count}", String(added.length)) }),
+      added.map(row)
+    ] }),
+    added.length === 0 && others.length === 0 && /* @__PURE__ */ jsx("p", { className: "text-sm text-muted-foreground", children: l.noFiles }),
+    others.length > 0 && /* @__PURE__ */ jsxs("details", { className: "space-y-1", "data-testid": `${testId}-others`, children: [
+      /* @__PURE__ */ jsx("summary", { className: cn(heading, "cursor-pointer select-none"), children: l.filesHeading.replace("{count}", String(others.length)) }),
+      /* @__PURE__ */ jsx("div", { className: "mt-1 max-h-48 space-y-1 overflow-y-auto", children: others.map(row) })
+    ] })
+  ] });
+}
+function StepHeading({
+  step,
+  icon,
+  testId
+}) {
+  return /* @__PURE__ */ jsxs("div", { className: "min-w-0", children: [
+    /* @__PURE__ */ jsxs("p", { className: "flex items-center gap-2 text-sm font-medium", "data-testid": testId, children: [
+      icon && /* @__PURE__ */ jsx("span", { className: "flex size-4 items-center justify-center text-primary [&_svg]:size-4", children: icon }),
+      step.title
+    ] }),
+    step.description && /* @__PURE__ */ jsx("p", { className: "mt-1 text-xs text-muted-foreground", children: step.description })
+  ] });
+}
+function formatElapsed(ms) {
+  const total = Math.max(0, Math.floor(ms / 1e3));
+  const h = Math.floor(total / 3600);
+  const m = Math.floor(total % 3600 / 60);
+  const sec = String(total % 60).padStart(2, "0");
+  return h ? `${h}:${String(m).padStart(2, "0")}:${sec}` : `${m}:${sec}`;
+}
+function StepWorking({ title, since, label }) {
+  const seen = useRef(Date.now());
+  const start = since && Date.parse(since) || seen.current;
+  const [now, setNow] = useState(() => Date.now());
+  useEffect(() => {
+    const t = setInterval(() => setNow(Date.now()), 1e3);
+    return () => clearInterval(t);
+  }, []);
+  return /* @__PURE__ */ jsx("span", { children: label.replace("{step}", title).replace("{elapsed}", formatElapsed(now - start)) });
+}
+function AgentStepBody({
+  step,
+  run,
+  renderAgentOutput,
+  icon,
+  renderStepNote,
+  l,
+  tid
+}) {
+  const state = run.stateOf(step.id);
+  const phase = run.phaseOf(step.id);
+  const header = /* @__PURE__ */ jsxs("div", { className: "flex items-start justify-between gap-3", children: [
+    /* @__PURE__ */ jsx(StepHeading, { step, icon }),
+    phase === "failed" && /* @__PURE__ */ jsx("div", { className: "flex shrink-0 items-center gap-2", children: run.retry && /* @__PURE__ */ jsxs(
+      Button,
+      {
+        variant: "outline",
+        size: "sm",
+        onClick: () => void run.retry?.(step.id),
+        disabled: run.busy,
+        "data-testid": tid(`${step.id}-retry`),
+        children: [
+          /* @__PURE__ */ jsx(RotateCw, { className: "size-4" }),
+          " ",
+          l.retry
+        ]
+      }
+    ) })
+  ] });
+  const status = /* @__PURE__ */ jsxs("div", { className: "space-y-1", children: [
+    step.branch && /* @__PURE__ */ jsxs("p", { className: "flex items-center gap-1.5 text-xs text-muted-foreground", children: [
+      /* @__PURE__ */ jsx(GitBranch, { className: "size-3.5" }),
+      " ",
+      l.branch
+    ] }),
+    (phase === "ready" || phase === "running") && !state?.text && /* @__PURE__ */ jsxs(
+      "p",
+      {
+        className: "flex items-center gap-2 text-sm text-muted-foreground",
+        "data-testid": tid(`${step.id}-working`),
+        children: [
+          /* @__PURE__ */ jsx(Loader2, { className: "size-4 animate-spin" }),
+          " ",
+          phase === "ready" ? l.starting : /* @__PURE__ */ jsx(StepWorking, { title: step.title, since: state?.startedAt, label: l.stepWorking })
+        ]
+      }
+    ),
+    phase === "failed" && /* @__PURE__ */ jsx("p", { className: "text-sm text-destructive", "data-testid": tid(`${step.id}-failed`), children: state?.error || l.failed }),
+    phase === "skipped" && /* @__PURE__ */ jsx("p", { className: "text-sm text-muted-foreground", children: l.skipped })
+  ] });
+  if (step.output === "artifact") {
+    return /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: "grid gap-4 lg:grid-cols-[minmax(0,18rem)_minmax(0,1fr)]",
+        "data-testid": tid(step.id),
+        children: [
+          /* @__PURE__ */ jsxs(Card, { className: "h-fit space-y-3 p-5", children: [
+            header,
+            status,
+            renderStepNote?.(step, run)
+          ] }),
+          /* @__PURE__ */ jsx("div", { className: "min-w-0", children: renderAgentOutput(step, state) })
+        ]
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs(Card, { className: "space-y-3 p-6", "data-testid": tid(step.id), children: [
+    header,
+    status,
+    renderAgentOutput(step, state),
+    renderStepNote?.(step, run)
+  ] });
+}
+
+export { DEFAULT_SCHEMA_FORM_LABELS, DEFAULT_WORKFLOW_RUNNER_LABELS, EMPTY_WORKFLOW_SCOPE, SKILL_PROMPT_FALLBACK_PLACEHOLDER, SKILL_PROMPT_LABEL, SchemaForm, WorkflowRunner, buildLaunch, composeStepPrompt, composeWorkflowPrompt, defaultInputs, dependsOn, fieldToFrontmatter, fillRunText, fillStepInputs, fromPlanSteps, initialRunInputs, inputsFromContext, isEmptyWorkflowScope, isPersonStep, isRunFinished, isSteppedWorkflow, isWorkflowScope, layoutFromPlanSteps, nextAction, orderSteps, promptFieldName, reviewInstructions, runFields, runThreadTitle, skillToWorkflow, stepDependencies, stepLevels, stepPhase, stepStatesFromActivity, toPlanSteps, useWorkflowView, validateInputs, validateStep, validateWorkflowGraph, workflowAccepts, workflowFromFrontmatter, workflowSteps, workflowsAccepting, workflowsForHost };
+//# sourceMappingURL=chunk-YWYVIQ7T.js.map
+//# sourceMappingURL=chunk-YWYVIQ7T.js.map