@arbidocs/blocks 0.4.76 → 0.4.78

package/dist/chunk-VFIZYSZB.cjs

@@ -0,0 +1,2783 @@
+"use client";
+'use strict';
+
+var chunk7D737FLE_cjs = require('./chunk-7D737FLE.cjs');
+var chunkDETZZBG2_cjs = require('./chunk-DETZZBG2.cjs');
+var chunkB4SRYJLM_cjs = require('./chunk-B4SRYJLM.cjs');
+var chunkMHVNT4J3_cjs = require('./chunk-MHVNT4J3.cjs');
+var react = require('react');
+var ui = require('@arbidocs/react/ui');
+var jsxRuntime = require('react/jsx-runtime');
+var lucideReact = require('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,
+  people
+}) {
+  const id = `${idFor()}-control`;
+  const testId = idFor();
+  switch (field.type) {
+    case "text":
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        ui.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__ */ jsxRuntime.jsx(
+        ui.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__ */ jsxRuntime.jsx(
+        ui.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__ */ jsxRuntime.jsx(
+        ui.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__ */ jsxRuntime.jsx(
+        ui.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__ */ jsxRuntime.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__ */ jsxRuntime.jsxs(
+                "button",
+                {
+                  type: "button",
+                  role: "radio",
+                  "aria-checked": selected,
+                  "data-testid": chunkMHVNT4J3_cjs.prefixedTestId(testId, option.value, {
+                    testId: `workflow-field-${field.name}-${option.value}`
+                  }),
+                  onClick: () => {
+                    onChange(option.value);
+                  },
+                  className: ui.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__ */ jsxRuntime.jsx("span", { className: "text-muted-foreground", children: renderIcon(option.icon) }),
+                    /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-sm font-medium text-foreground", children: option.label }),
+                    option.description && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-xs text-muted-foreground", children: option.description })
+                  ]
+                },
+                option.value
+              );
+            })
+          }
+        );
+      }
+      return /* @__PURE__ */ jsxRuntime.jsxs(ui.Select, { value: String(value ?? ""), onValueChange: (v) => onChange(v), children: [
+        /* @__PURE__ */ jsxRuntime.jsx(ui.SelectTrigger, { id, "data-testid": testId, className: "pointer-coarse:min-h-11", children: /* @__PURE__ */ jsxRuntime.jsx(ui.SelectValue, { placeholder: field.placeholder }) }),
+        /* @__PURE__ */ jsxRuntime.jsx(ui.SelectContent, { children: options.map((o) => /* @__PURE__ */ jsxRuntime.jsx(ui.SelectItem, { value: o.value, children: o.label }, o.value)) })
+      ] });
+    }
+    case "scope": {
+      const scope = isWorkflowScope(value) ? value : { folders: [], labels: [] };
+      return /* @__PURE__ */ jsxRuntime.jsx("div", { "data-testid": testId, children: renderScope?.(field, scope, onChange) });
+    }
+    case "documents": {
+      const picked = isWorkflowScope(value) ? value : { folders: [], labels: [], documents: [] };
+      return /* @__PURE__ */ jsxRuntime.jsx("div", { "data-testid": testId, children: renderDocuments?.(field, picked, onChange) });
+    }
+    case "person":
+      return people?.length ? /* @__PURE__ */ jsxRuntime.jsxs(
+        "select",
+        {
+          id,
+          "data-testid": testId,
+          value: String(value ?? ""),
+          "aria-required": field.required || void 0,
+          "aria-invalid": error ? true : void 0,
+          onChange: (e) => onChange(e.target.value),
+          className: "flex h-9 w-full rounded-md border border-input bg-background px-2 text-sm shadow-sm",
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx("option", { value: "", children: field.placeholder ?? "" }),
+            people.map((p) => /* @__PURE__ */ jsxRuntime.jsx("option", { value: p.value, children: p.label }, p.value))
+          ]
+        }
+      ) : /* @__PURE__ */ jsxRuntime.jsx(
+        ui.Input,
+        {
+          id,
+          "data-testid": testId,
+          value: String(value ?? ""),
+          placeholder: field.placeholder ?? "usr-\u2026",
+          "aria-required": field.required || void 0,
+          "aria-invalid": error ? true : void 0,
+          onChange: (e) => onChange(e.target.value)
+        }
+      );
+  }
+}
+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__ */ jsxRuntime.jsxs(
+    ui.Label,
+    {
+      htmlFor: `${idFor()}-control`,
+      className: isBoolean ? "cursor-pointer font-normal" : void 0,
+      children: [
+        field.label,
+        showOptional && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+          " ",
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "font-normal text-muted-foreground", children: l.optional })
+        ] })
+      ]
+    }
+  );
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col gap-1.5", "data-slot": "schema-field", "data-field": field.name, children: [
+    isBoolean ? /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2.5 pointer-coarse:min-h-11", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(FieldControl, { ...props }),
+      label
+    ] }) : /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      field.type !== "scope" && label,
+      /* @__PURE__ */ jsxRuntime.jsx(FieldControl, { ...props })
+    ] }),
+    field.description && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-xs text-muted-foreground", children: field.description }),
+    error && /* @__PURE__ */ jsxRuntime.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,
+  people,
+  testIdPrefix,
+  labels,
+  className
+}) {
+  const l = {
+    ...DEFAULT_SCHEMA_FORM_LABELS,
+    ...labels,
+    errors: { ...DEFAULT_SCHEMA_FORM_LABELS.errors, ...labels?.errors }
+  };
+  const [advancedOpen, setAdvancedOpen] = react.useState(false);
+  const common = fields.filter((f) => !f.advanced);
+  const advanced = fields.filter((f) => f.advanced);
+  const render = (field) => /* @__PURE__ */ jsxRuntime.jsx(
+    FormField,
+    {
+      field,
+      value: values[field.name],
+      error: errors?.[field.name],
+      onChange: (v) => onChange(field.name, v),
+      l,
+      idFor: (suffix) => suffix ? `${chunkMHVNT4J3_cjs.testIdOr(testIdPrefix, { testId: "workflow-field" })}-${field.name}-${suffix}` : `${chunkMHVNT4J3_cjs.testIdOr(testIdPrefix, { testId: "workflow-field" })}-${field.name}`,
+      renderScope,
+      renderDocuments,
+      renderIcon,
+      onEnterSubmit,
+      people
+    },
+    field.name
+  );
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: ui.cn("flex flex-col gap-4", className), "data-slot": "schema-form", children: [
+    common.map(render),
+    advanced.length > 0 && /* @__PURE__ */ jsxRuntime.jsx(
+      chunk7D737FLE_cjs.FoldSection,
+      {
+        label: l.advanced,
+        open: advancedOpen,
+        onOpenChange: setAdvancedOpen,
+        testId: `${chunkMHVNT4J3_cjs.testIdOr(testIdPrefix, { testId: "workflow-field" })}-advanced-toggle`,
+        children: /* @__PURE__ */ jsxRuntime.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_waiting: "waiting",
+  step_done: "done",
+  step_skipped: "skipped",
+  step_failed: "failed"
+};
+var str2 = (v) => typeof v === "string" && v ? v : void 0;
+var ACTION_TYPES = ["sign", "email_draft", "tabular_review"];
+var asAction = (v) => ACTION_TYPES.includes(v) ? v : void 0;
+var asRecord = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : void 0;
+var asStrings = (v) => Array.isArray(v) ? v.filter((x) => typeof x === "string") : void 0;
+function reopenedBy(detail) {
+  const to = str2(detail.to);
+  return asStrings(detail.reopened) ?? (to ? [to] : []);
+}
+function stepStatesFromActivity(events) {
+  const states = {};
+  for (const e of events) {
+    const detail = e.detail ?? {};
+    const step = str2(detail.step);
+    if (!step) continue;
+    if (e.kind === "step_sent_back") {
+      const to = str2(detail.to);
+      for (const id of reopenedBy(detail))
+        states[id] = id === to ? {
+          status: "pending",
+          sentBack: true,
+          hasNote: typeof detail.note_encrypted === "string"
+        } : { status: "pending" };
+      continue;
+    }
+    if (e.kind === "step_ready") {
+      states[step] = { ...states[step] ?? { status: "pending" }, announcedTo: str2(detail.to) };
+      continue;
+    }
+    if (e.kind === "step_progress") {
+      const before2 = states[step];
+      const waiting2 = asRecord(detail.waiting);
+      if (before2?.status === "waiting" && waiting2) states[step] = { ...before2, waiting: waiting2 };
+      continue;
+    }
+    const status = STEP_EVENTS[e.kind];
+    if (!status) continue;
+    const before = states[step];
+    const responseId = str2(detail.response_id) ?? before?.responseId ?? null;
+    const startedAt = status === "running" ? e.created_at : before?.startedAt;
+    const action = asAction(detail.action) ?? before?.action;
+    const documents = asStrings(detail.documents) ?? before?.documents;
+    const waiting = status === "waiting" ? asRecord(detail.waiting) : void 0;
+    const output = status === "done" ? asRecord(detail.output) : void 0;
+    const approved = Array.isArray(detail.approved) ? detail.approved.filter(asRecord) : void 0;
+    const finished2 = status === "done" || status === "skipped" || status === "failed";
+    const declinedBy = str2(detail.declined_by);
+    states[step] = {
+      status,
+      responseId,
+      error: str2(detail.error) ?? null,
+      ...startedAt ? { startedAt } : {},
+      ...action ? { action } : {},
+      ...documents?.length ? { documents } : {},
+      ...waiting ? { waiting } : {},
+      ...output ? { output } : {},
+      ...approved ? { approved } : {},
+      ...finished2 ? { by: e.actor_ext_id ?? null } : {},
+      ...finished2 && e.created_at ? { at: e.created_at } : {},
+      ...declinedBy ? { declinedBy } : {}
+    };
+  }
+  return states;
+}
+function stepFields(step) {
+  return step.kind === "form" ? step.inputs : step.kind === "review" ? step.fields ?? [] : [];
+}
+var runFieldsOf = (steps) => steps.flatMap(stepFields);
+function runFields(workflow) {
+  return [...workflow.inputs, ...workflowSteps(workflow).flatMap(stepFields)];
+}
+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" && step.kind !== "action";
+var isPersonAction = (step) => step.kind === "action" && (step.action.type === "sign" || step.action.type === "email_draft");
+var canAssign = (step) => isPersonStep(step) || isPersonAction(step);
+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 === "waiting" && step.kind === "action" && step.action.type === "email_draft")
+    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) {
+  const fields = stepFields(step);
+  if (!fields.length) return {};
+  return validateInputs(
+    {
+      id: step.id,
+      title: step.title,
+      inputs: fields},
+    inputs
+  );
+}
+function upstreamSteps(steps, id) {
+  return steps.filter((s) => s.id !== id && dependsOn(steps, id, s.id));
+}
+function sendBackTargets(steps, states, id) {
+  return upstreamSteps(steps, id).filter((s) => ["done", "skipped", "failed"].includes(states[s.id]?.status ?? "pending")).reverse();
+}
+var isBlankRef = (ref) => "step" in ref ? !ref.step : "input" in ref ? !ref.input : !ref.id.trim();
+function stepConfigProblems(steps) {
+  const out = [];
+  for (const s of steps) {
+    if (s.kind === "action") {
+      const a = s.action;
+      if (a.type === "sign") {
+        if (!a.document || isBlankRef(a.document)) out.push({ step: s.id, missing: "document" });
+        if (!a.signers.length) out.push({ step: s.id, missing: "signers" });
+      } else if (a.type === "email_draft") {
+        if (!a.to.some((t) => t.trim())) out.push({ step: s.id, missing: "recipients" });
+      } else {
+        if (!a.tags.length) out.push({ step: s.id, missing: "tags" });
+        if (Array.isArray(a.documents) && !a.documents.length)
+          out.push({ step: s.id, missing: "documents" });
+      }
+    }
+    if (s.kind === "agent" && s.editDocument && isBlankRef(s.editDocument))
+      out.push({ step: s.id, missing: "document" });
+  }
+  return out;
+}
+function splitDocRef(ref) {
+  const m = /^(doc-[A-Za-z0-9]+)(?:@v(\d+))?$/.exec(ref);
+  return m ? { id: m[1], ...m[2] ? { version: Number(m[2]) } : {} } : { id: ref };
+}
+var DEFAULT_ASSIGNEE_WORDING = {
+  runOwner: "whoever started the run",
+  projectLead: "the project lead",
+  input: "the person in \u201C{field}\u201D"
+};
+function assigneeName(assignee, options = {}) {
+  const w = { ...DEFAULT_ASSIGNEE_WORDING, ...options.wording };
+  const name = (id) => options.nameOf?.(id) ?? id;
+  const told = options.announcedTo ? options.nameOf?.(options.announcedTo) : void 0;
+  if (told) return told;
+  if (!assignee) return void 0;
+  if ("user" in assignee) return name(assignee.user);
+  if ("input" in assignee) {
+    const value = options.inputs?.[assignee.input];
+    if (typeof value === "string" && value) return name(value);
+    const label = options.fields?.find((f) => f.name === assignee.input)?.label ?? assignee.input;
+    return w.input.replace("{field}", label);
+  }
+  if ("runOwner" in assignee) return w.runOwner;
+  return w.projectLead;
+}
+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
+function toPlanAssignee(a) {
+  if ("user" in a) return { user: a.user };
+  if ("input" in a) return { input: a.input };
+  if ("runOwner" in a) return { run_owner: true };
+  return { project_lead: true };
+}
+function fromPlanAssignee(a) {
+  if (!a) return void 0;
+  if (a.user) return { user: a.user };
+  if (a.input) return { input: a.input };
+  if (a.run_owner) return { runOwner: true };
+  if (a.project_lead) return { projectLead: true };
+  return void 0;
+}
+function toPlanDocumentRef(ref) {
+  if ("step" in ref) return { step: ref.step };
+  if ("input" in ref) return { input: ref.input };
+  return ref.id.trim();
+}
+function fromPlanDocumentRef(ref) {
+  if (!ref) return void 0;
+  if (typeof ref === "string") return { id: ref };
+  if (ref.step) return { step: ref.step };
+  if (ref.input) return { input: ref.input };
+  return void 0;
+}
+var docRefs = (refs) => (refs ?? []).map(toPlanDocumentRef);
+var fromDocRefs = (refs) => (refs ?? []).flatMap((r) => {
+  const ref = fromPlanDocumentRef(r);
+  return ref ? [ref] : [];
+});
+function toPlanAction(a) {
+  switch (a.type) {
+    case "sign":
+      return {
+        type: "sign",
+        // The builder may hold a signature step whose document is not chosen yet: the server
+        // refuses it, and the builder says so before saving (`stepConfigProblems`).
+        document: a.document ? toPlanDocumentRef(a.document) : "",
+        signers: a.signers.map(toPlanAssignee),
+        ...a.message?.trim() ? { message: a.message.trim() } : {},
+        ...a.expiresAfterHours ? { expires_after_hours: a.expiresAfterHours } : {}
+      };
+    case "email_draft":
+      return {
+        type: "email_draft",
+        to: a.to.map((t) => t.trim()).filter(Boolean),
+        cc: (a.cc ?? []).map((t) => t.trim()).filter(Boolean),
+        subject: a.subject,
+        body_template: a.body,
+        attachments: docRefs(a.attachments)
+      };
+    case "tabular_review":
+      return {
+        type: "tabular_review",
+        tags: a.tags,
+        documents: Array.isArray(a.documents) ? docRefs(a.documents) : a.documents,
+        overwrite: !!a.overwrite
+      };
+  }
+}
+function fromPlanAction(a) {
+  switch (a?.type) {
+    case "sign":
+      return {
+        type: "sign",
+        document: fromPlanDocumentRef(a.document),
+        signers: (a.signers ?? []).flatMap((s) => {
+          const one = fromPlanAssignee(s);
+          return one ? [one] : [];
+        }),
+        ...a.message ? { message: a.message } : {},
+        ...a.expires_after_hours ? { expiresAfterHours: a.expires_after_hours } : {}
+      };
+    case "email_draft":
+      return {
+        type: "email_draft",
+        to: a.to ?? [],
+        ...a.cc?.length ? { cc: a.cc } : {},
+        subject: a.subject ?? "",
+        body: a.body_template ?? "",
+        ...a.attachments?.length ? { attachments: fromDocRefs(a.attachments) } : {}
+      };
+    case "tabular_review":
+      return {
+        type: "tabular_review",
+        tags: a.tags ?? [],
+        documents: Array.isArray(a.documents) ? fromDocRefs(a.documents) : a.documents ?? "run_uploads",
+        ...a.overwrite ? { overwrite: true } : {}
+      };
+    default:
+      return { type: "tabular_review", tags: [], documents: "run_uploads" };
+  }
+}
+function toStepField(f) {
+  return {
+    name: f.name,
+    type: f.type,
+    label: f.label,
+    required: !!f.required,
+    ...f.options ? { options: f.options.map((o) => ({ value: o.value, label: o.label })) } : {},
+    ...f.min !== void 0 ? { min: f.min } : {},
+    ...f.max !== void 0 ? { max: f.max } : {}
+  };
+}
+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, fields: step.fields?.length ? step.fields : void 0 } : {},
+      ...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,
+      // An unfinished signal (still being typed) is not saved: the server would refuse it.
+      ...step.signals?.some((s) => !isIncompleteSignal(s)) ? { signals: step.signals.filter((s) => !isIncompleteSignal(s)).map(toPlanSignal) } : {},
+      ...step.assignee && canAssign(step) ? { assignee: toPlanAssignee(step.assignee) } : {},
+      ...step.remindAfterHours && canAssign(step) ? { remind_after_hours: step.remindAfterHours } : {},
+      // A review's fields are what approving it is checked against (the server's `fields`).
+      ...step.kind === "review" && step.fields?.length ? { fields: step.fields.map(toStepField) } : {},
+      ...step.kind === "action" ? { action: toPlanAction(step.action) } : {},
+      ...step.kind === "agent" && step.editDocument && !step.branch ? { edit_document: toPlanDocumentRef(step.editDocument) } : {},
+      ...step.kind === "agent" ? agentStep(workflow, step, options) : { skill: null, inputs: null, prompt: null }
+    };
+  });
+}
+function toPlanSignal(signal) {
+  return signal.when ? { name: signal.name, when: signal.when } : { name: signal.name };
+}
+function isIncompleteSignal(signal) {
+  const when = signal.when;
+  if (!signal.name.trim()) return true;
+  if (!when) return false;
+  if ("field" in when) return !when.field || String(when.equals).trim() === "";
+  if ("contains" in when) return !when.contains.trim();
+  if ("matches" in when) return !when.matches.trim();
+  return false;
+}
+function fromPlanSignal(signal) {
+  const w = signal.when;
+  const when = w?.field != null && w.equals != null ? { field: w.field, equals: w.equals } : w?.contains != null ? { contains: w.contains } : w?.matches != null ? { matches: w.matches } : w?.approved ? { approved: true } : void 0;
+  return when ? { name: signal.name, when } : { name: signal.name };
+}
+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 } : {},
+      ...p.signals?.length ? { signals: p.signals.map(fromPlanSignal) } : {},
+      ...fromPlanAssignee(p.assignee) ? { assignee: fromPlanAssignee(p.assignee) } : {},
+      ...p.remind_after_hours ? { remindAfterHours: p.remind_after_hours } : {}
+    };
+    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,
+          // The client's copy of the fields (labels, options) when it kept one, else the plan's.
+          ...ui.fields?.length ? { fields: ui.fields } : p.fields?.length ? { fields: p.fields.map(fromStepField) } : {}
+        };
+      case "action":
+        return { ...base, kind: "action", action: fromPlanAction(p.action) };
+      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,
+          ...fromPlanDocumentRef(p.edit_document) ? { editDocument: fromPlanDocumentRef(p.edit_document) } : {}
+        };
+      }
+    }
+  });
+}
+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 FIELD_TYPES2 = /* @__PURE__ */ new Set([
+  "text",
+  "longtext",
+  "boolean",
+  "select",
+  "number",
+  "date",
+  "scope",
+  "documents",
+  "person"
+]);
+function fromStepField(f) {
+  return {
+    name: f.name,
+    type: FIELD_TYPES2.has(f.type) ? f.type : "text",
+    label: f.label ?? f.name,
+    ...f.required ? { required: true } : {},
+    ...f.options?.length ? { options: f.options.map((o) => ({ value: o.value, label: o.label ?? o.value })) } : {},
+    ...f.min != null ? { min: f.min } : {},
+    ...f.max != null ? { max: f.max } : {}
+  };
+}
+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, loaded = true } = options;
+  const [current, setCurrent] = react.useState(() => firstOpen(steps, states));
+  const [showErrors, setShowErrors] = react.useState(false);
+  const [busy, setBusy] = react.useState(false);
+  const [actionError, setActionError] = react.useState(null);
+  const optionsRef = react.useRef(options);
+  optionsRef.current = options;
+  const placed = react.useRef(steps.length > 0 && loaded);
+  react.useEffect(() => {
+    if (placed.current || steps.length === 0 || !loaded) return;
+    placed.current = true;
+    setCurrent(firstOpen(steps, states));
+  }, [steps, states, loaded]);
+  const step = steps.find((s) => s.id === current);
+  const following = react.useCallback(
+    (id) => {
+      const i = steps.findIndex((s) => s.id === id);
+      return steps[i + 1]?.id ?? null;
+    },
+    [steps]
+  );
+  const onward = react.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 = react.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 = react.useCallback((stepId) => {
+    setShowErrors(false);
+    setActionError(null);
+    setCurrent(stepId);
+  }, []);
+  const index = steps.findIndex((s) => s.id === current);
+  const back = react.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 = react.useCallback(
+    (fn) => fn && (async (stepId) => {
+      setBusy(true);
+      setActionError(null);
+      try {
+        await fn(stepId);
+      } catch (e) {
+        setActionError(errorMessage(e));
+      } finally {
+        setBusy(false);
+      }
+    }),
+    []
+  );
+  const currentRef = react.useRef(current);
+  currentRef.current = current;
+  const skip = react.useMemo(
+    () => act(async (id) => {
+      await optionsRef.current.skip(id);
+      if (currentRef.current !== id) return;
+      setShowErrors(false);
+      setCurrent(onward(id) ?? id);
+    }),
+    [act, onward]
+  );
+  const retry = react.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 sendBack = react.useMemo(
+    () => options.sendBack ? async (stepId, to, note) => {
+      setBusy(true);
+      setActionError(null);
+      try {
+        await optionsRef.current.sendBack?.(stepId, to, note);
+        setShowErrors(false);
+        setCurrent(to);
+      } catch (e) {
+        setActionError(errorMessage(e));
+      } finally {
+        setBusy(false);
+      }
+    } : void 0,
+    // Only whether the host offers it matters here.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [!!options.sendBack]
+  );
+  const declineWithNote = react.useMemo(
+    () => options.decline ? async (stepId, note) => {
+      setBusy(true);
+      setActionError(null);
+      try {
+        await optionsRef.current.decline?.(stepId, note);
+      } catch (e) {
+        setActionError(errorMessage(e));
+      } finally {
+        setBusy(false);
+      }
+    } : void 0,
+    // Only whether the host offers it matters here.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [!!options.decline]
+  );
+  const isLocked = react.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,
+    sendBack,
+    decline: declineWithNote,
+    nameOf: options.nameOf,
+    assigneeOf: (id) => {
+      const s = steps.find((x) => x.id === id);
+      if (!s || !canAssign(s)) return void 0;
+      return assigneeName(s.assignee, {
+        nameOf: options.nameOf,
+        inputs,
+        fields: runFieldsOf(steps),
+        announcedTo: states[id]?.announcedTo
+      });
+    },
+    restart: () => {
+      setShowErrors(false);
+      setActionError(null);
+      setCurrent(steps[0]?.id ?? null);
+    }
+  };
+}
+
+// src/agents/workflows/stepWindow.ts
+var ATTENTION = ["waiting", "failed", "ready"];
+function activeStepId(levels, phaseOf) {
+  const all = levels.flat();
+  for (const phase of ["running", ...ATTENTION]) {
+    const hit = all.find((s) => phaseOf(s.id) === phase);
+    if (hit) return hit.id;
+  }
+  return all[all.length - 1]?.id;
+}
+function primaryOf(steps, phaseOf, current) {
+  return steps.find((s) => phaseOf(s.id) === "running") ?? steps.find((s) => s.id === current) ?? ATTENTION.map((p) => steps.find((s) => phaseOf(s.id) === p)).find(Boolean) ?? steps[0];
+}
+function stepWindow({
+  levels: raw,
+  phaseOf,
+  current,
+  start: requested,
+  span = 3
+}) {
+  const levelsIn = raw.filter((l) => l.length > 0);
+  const known = current && levelsIn.some((l) => l.some((s) => s.id === current));
+  const at = known ? current : activeStepId(levelsIn, phaseOf);
+  const currentLevel = Math.max(
+    0,
+    levelsIn.findIndex((l) => l.some((s) => s.id === at))
+  );
+  const n = levelsIn.length;
+  const size = Math.max(1, Math.min(span, n));
+  const maxStart = Math.max(0, n - size);
+  const auto = currentLevel - (size >= 3 ? 1 : 0);
+  const start = Math.min(maxStart, Math.max(0, requested ?? auto));
+  const end = start + size;
+  const levels = levelsIn.map((steps, index) => {
+    const primary = primaryOf(steps, phaseOf, at);
+    return {
+      index,
+      steps,
+      primary,
+      others: steps.filter((s) => s !== primary),
+      role: index === currentLevel ? "current" : index === currentLevel - 1 ? "previous" : index === currentLevel + 1 ? "next" : "other"
+    };
+  });
+  const visible = levels.slice(start, end);
+  const count = (ls) => ls.reduce((sum, l) => sum + l.steps.length, 0);
+  const shown = new Set(visible.map((l) => l.primary.id));
+  const all = levelsIn.flat();
+  return {
+    levels,
+    visible,
+    start,
+    end,
+    currentLevel,
+    hiddenBefore: count(levels.slice(0, start)),
+    hiddenAfter: count(levels.slice(end)),
+    canBack: start > 0,
+    canForward: end < n,
+    runningHidden: all.filter((s) => phaseOf(s.id) === "running" && !shown.has(s.id)),
+    position: Math.max(1, all.findIndex((s) => s.id === at) + 1),
+    total: all.length
+  };
+}
+function PhaseMark({ phase, icon }) {
+  if (phase === "done") return /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Check, { className: "size-3.5 shrink-0" });
+  if (phase === "running") return /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Loader2, { className: "size-3.5 shrink-0 animate-spin" });
+  if (phase === "waiting") return /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Hourglass, { className: "size-3.5 shrink-0" });
+  if (phase === "failed") return /* @__PURE__ */ jsxRuntime.jsx(lucideReact.AlertTriangle, { className: "size-3.5 shrink-0" });
+  if (phase === "skipped") return /* @__PURE__ */ jsxRuntime.jsx(lucideReact.MinusCircle, { className: "size-3.5 shrink-0" });
+  return icon ? /* @__PURE__ */ jsxRuntime.jsx("span", { className: "flex size-3.5 shrink-0 items-center justify-center [&_svg]:size-3.5", children: icon }) : /* @__PURE__ */ jsxRuntime.jsx("span", { className: "mx-1 size-1.5 shrink-0 rounded-full bg-current opacity-60" });
+}
+var DEFAULT_STEP_BAR_LABELS = {
+  nav: "Workflow steps",
+  back: "Earlier steps",
+  forward: "Later steps",
+  hiddenBefore: "{count} earlier steps: show all steps",
+  hiddenAfter: "{count} later steps: show all steps",
+  position: "Step {position} of {total}",
+  parallel: "{count} more in parallel",
+  inParallel: "In parallel",
+  working: "Working: {title}",
+  moreWorking: "+{count} working",
+  waitingFor: "Waiting for {name}",
+  phases: {
+    blocked: "Not started",
+    ready: "To do",
+    running: "Working",
+    waiting: "Waiting",
+    done: "Done",
+    skipped: "Skipped",
+    failed: "Failed"
+  }
+};
+function stepPillTone(phase, current) {
+  if (current) return "border-primary bg-primary/10 text-primary font-semibold shadow-sm";
+  switch (phase) {
+    case "done":
+      return "border-emerald-600/30 text-emerald-700 dark:border-emerald-400/30 dark:text-emerald-400";
+    case "running":
+      return "border-primary/40 bg-primary/5 text-primary";
+    case "waiting":
+      return "border-amber-500/40 text-amber-700 dark:text-amber-300";
+    case "failed":
+      return "border-destructive/40 text-destructive";
+    case "skipped":
+      return "border-border text-muted-foreground line-through decoration-1";
+    case "ready":
+      return "border-border text-foreground";
+    default:
+      return "border-dashed border-border text-muted-foreground";
+  }
+}
+var PHASE_TEXT = {
+  done: "text-emerald-700 dark:text-emerald-400",
+  running: "text-primary",
+  waiting: "text-amber-700 dark:text-amber-300",
+  failed: "text-destructive",
+  skipped: "text-muted-foreground",
+  ready: "text-foreground",
+  blocked: "text-muted-foreground"
+};
+var STEP_PILL = "flex min-w-0 items-center gap-1.5 whitespace-nowrap rounded-full border px-2.5 py-1 text-xs font-medium transition-colors";
+var STEP_LABEL = "min-w-[2.5rem] truncate";
+var STEP_EXTRA = "min-w-0 shrink-[6] truncate font-normal opacity-80";
+var fill = (template, values) => Object.entries(values).reduce((s, [k, v]) => s.replace(`{${k}}`, String(v)), template);
+var NARROW_PX = 560;
+var FULL_LEVEL_PX = 190;
+function StepBarFrame({
+  levels,
+  phaseOf,
+  current,
+  onSelect,
+  renderStep,
+  noteOf,
+  renderAfter,
+  leading,
+  trailing,
+  isSelectable = () => true,
+  icon,
+  disabled,
+  labels,
+  tid,
+  className
+}) {
+  const l = { ...DEFAULT_STEP_BAR_LABELS, ...labels };
+  const box = react.useRef(null);
+  const { width } = chunkB4SRYJLM_cjs.useElementSize(box);
+  const narrow = width > 0 && width < NARROW_PX;
+  const [start, setStart] = react.useState(null);
+  react.useEffect(() => setStart(null), [current]);
+  const span = narrow ? 2 : width >= levels.length * FULL_LEVEL_PX ? levels.length : 3;
+  const win = stepWindow({ levels, phaseOf, current, start, span });
+  const [listOpen, setListOpen] = react.useState(null);
+  const move = (to) => setStart(Math.max(0, Math.min(win.levels.length - 1, to)));
+  const select = (id) => {
+    setListOpen(null);
+    setStart(null);
+    onSelect(id);
+  };
+  const onKeyDown = (e) => {
+    if (!box.current?.contains(e.target)) return;
+    const to = e.key === "ArrowLeft" ? win.start - 1 : e.key === "ArrowRight" ? win.start + 1 : e.key === "Home" ? 0 : e.key === "End" ? win.levels.length : null;
+    if (to === null) return;
+    e.preventDefault();
+    move(to);
+  };
+  const row = (s, isCurrent) => {
+    const phase = phaseOf(s.id);
+    const selectable = isSelectable(s.id);
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      "button",
+      {
+        type: "button",
+        disabled: !selectable || disabled,
+        onClick: () => select(s.id),
+        "aria-current": isCurrent ? "step" : void 0,
+        className: ui.cn(
+          "flex w-full min-w-0 items-center gap-2 rounded-md px-2 py-1 text-left text-xs hover:bg-accent disabled:cursor-default disabled:hover:bg-transparent",
+          isCurrent && "bg-primary/10 font-semibold text-primary"
+        ),
+        "data-phase": phase,
+        "data-testid": tid(`list-step-${s.id}`),
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: ui.cn("flex shrink-0", !isCurrent && PHASE_TEXT[phase]), children: /* @__PURE__ */ jsxRuntime.jsx(PhaseMark, { phase, icon: icon?.(s) }) }),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "min-w-0 flex-1 truncate", title: s.title, children: s.title }),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "shrink-0 text-[10px] font-normal text-muted-foreground", children: l.phases[phase] })
+        ]
+      },
+      s.id
+    );
+  };
+  const at = win.levels[win.currentLevel];
+  const atId = at && (at.steps.find((s) => s.id === current) ?? at.primary).id;
+  const focusCurrent = (e) => {
+    const el = e.currentTarget?.querySelector(
+      '[aria-current="step"]'
+    );
+    if (!el) return;
+    e.preventDefault();
+    el.focus();
+    el.scrollIntoView?.({ block: "nearest" });
+  };
+  const allSteps = /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx("p", { className: "px-2 py-1 text-[11px] font-medium text-muted-foreground", children: fill(l.position, { position: win.position, total: win.total }) }),
+    /* @__PURE__ */ jsxRuntime.jsx("ol", { children: win.levels.map((level) => /* @__PURE__ */ jsxRuntime.jsxs(
+      "li",
+      {
+        className: ui.cn(level.steps.length > 1 && "my-0.5 border-l-2 border-primary/30 pl-1"),
+        children: [
+          level.steps.length > 1 && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "px-2 text-[10px] uppercase tracking-wide text-muted-foreground", children: l.inParallel }),
+          level.steps.map((s) => row(s, s.id === atId))
+        ]
+      },
+      level.index
+    )) })
+  ] });
+  const overflow = (side, count) => narrow && side === "before" ? null : narrow && side === "after" ? win.hiddenBefore + win.hiddenAfter > 0 ? /* @__PURE__ */ jsxRuntime.jsxs(ui.Popover, { open: listOpen === side, onOpenChange: (o) => setListOpen(o ? side : null), children: [
+    /* @__PURE__ */ jsxRuntime.jsx(ui.PopoverTrigger, { asChild: true, children: /* @__PURE__ */ jsxRuntime.jsxs(
+      "button",
+      {
+        type: "button",
+        className: "flex shrink-0 items-center rounded-full px-1.5 py-1 text-[11px] tabular-nums text-muted-foreground hover:bg-accent hover:text-foreground",
+        "aria-label": fill(l.position, { position: win.position, total: win.total }),
+        title: fill(l.position, { position: win.position, total: win.total }),
+        "data-testid": tid("steps-count"),
+        children: [
+          win.position,
+          "/",
+          win.total
+        ]
+      }
+    ) }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      ui.PopoverContent,
+      {
+        align: "end",
+        className: "max-h-[min(24rem,70vh)] w-72 overflow-y-auto p-1",
+        onOpenAutoFocus: focusCurrent,
+        "data-testid": tid("all-steps"),
+        children: allSteps
+      }
+    )
+  ] }) : null : count > 0 ? /* @__PURE__ */ jsxRuntime.jsxs(ui.Popover, { open: listOpen === side, onOpenChange: (o) => setListOpen(o ? side : null), children: [
+    /* @__PURE__ */ jsxRuntime.jsx(ui.PopoverTrigger, { asChild: true, children: /* @__PURE__ */ jsxRuntime.jsxs(
+      "button",
+      {
+        type: "button",
+        className: "flex shrink-0 items-center gap-0.5 rounded-full px-1.5 py-1 text-xs text-muted-foreground hover:bg-accent hover:text-foreground",
+        "aria-label": fill(side === "before" ? l.hiddenBefore : l.hiddenAfter, { count }),
+        title: fill(side === "before" ? l.hiddenBefore : l.hiddenAfter, { count }),
+        "data-testid": tid(`hidden-${side}`),
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", { "aria-hidden": true, children: "\u2026" }),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "tabular-nums", children: count })
+        ]
+      }
+    ) }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      ui.PopoverContent,
+      {
+        align: side === "before" ? "start" : "end",
+        className: "max-h-[min(24rem,70vh)] w-80 overflow-y-auto p-1",
+        onOpenAutoFocus: focusCurrent,
+        "data-testid": tid("all-steps"),
+        children: allSteps
+      }
+    )
+  ] }) : null;
+  const arrow = (dir) => {
+    const can = dir === "back" ? win.canBack : win.canForward;
+    const Icon = dir === "back" ? lucideReact.ChevronLeft : lucideReact.ChevronRight;
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "button",
+      {
+        type: "button",
+        onClick: () => move(win.start + (dir === "back" ? -1 : 1)),
+        disabled: !can,
+        "aria-label": dir === "back" ? l.back : l.forward,
+        title: dir === "back" ? l.back : l.forward,
+        className: "flex size-6 shrink-0 items-center justify-center rounded-full text-muted-foreground hover:bg-accent hover:text-foreground disabled:pointer-events-none disabled:opacity-30",
+        "data-testid": tid(`steps-${dir}`),
+        children: /* @__PURE__ */ jsxRuntime.jsx(Icon, { className: "size-4" })
+      }
+    );
+  };
+  const running = win.runningHidden;
+  const workingPill = (s) => /* @__PURE__ */ jsxRuntime.jsxs(
+    "button",
+    {
+      type: "button",
+      onClick: () => select(s.id),
+      className: "flex min-w-0 max-w-[14rem] shrink items-center gap-1.5 rounded-full border border-primary/40 bg-primary/5 px-2 py-1 text-xs text-primary hover:bg-primary/10",
+      title: fill(l.working, { title: s.title }),
+      "data-testid": tid(`working-${s.id}`),
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Loader2, { className: "size-3.5 shrink-0 animate-spin" }),
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "truncate", children: fill(l.working, { title: s.title }) })
+      ]
+    },
+    s.id
+  );
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "nav",
+    {
+      ref: box,
+      "aria-label": l.nav,
+      onKeyDown,
+      className: ui.cn("flex min-w-0 items-center gap-1", narrow && "flex-wrap", className),
+      "data-testid": tid("steps"),
+      "data-narrow": narrow || void 0,
+      children: [
+        arrow("back"),
+        win.start === 0 && leading,
+        overflow("before", win.hiddenBefore),
+        /* @__PURE__ */ jsxRuntime.jsx("ol", { className: "flex min-w-0 flex-1 items-center gap-1", children: win.visible.map((level, i) => /* @__PURE__ */ jsxRuntime.jsxs(
+          "li",
+          {
+            className: ui.cn(
+              "flex min-w-[5.5rem] items-center gap-1",
+              i === win.visible.length - 1 ? "flex-[0_1_auto]" : "flex-[1_1_auto]"
+            ),
+            "data-role": level.role,
+            children: [
+              renderStep(level.primary, level, win, narrow),
+              level.others.length > 0 && /* @__PURE__ */ jsxRuntime.jsx(
+                GroupChip,
+                {
+                  level,
+                  label: fill(l.parallel, { count: level.others.length }),
+                  heading: l.inParallel,
+                  row: (s) => row(s, s.id === atId),
+                  tid
+                }
+              ),
+              renderAfter?.(level),
+              i < win.visible.length - 1 && !narrow && /* @__PURE__ */ jsxRuntime.jsx(
+                "span",
+                {
+                  "aria-hidden": true,
+                  className: ui.cn(
+                    "h-px min-w-3 flex-1",
+                    level.steps.every((s) => ["done", "skipped"].includes(phaseOf(s.id))) ? "bg-emerald-600/40" : "bg-border"
+                  )
+                }
+              )
+            ]
+          },
+          level.steps.map((s) => s.id).join("+")
+        )) }),
+        overflow("after", win.hiddenAfter),
+        !win.canForward && trailing,
+        arrow("forward"),
+        narrow && atId && noteOf?.(atId) && /* @__PURE__ */ jsxRuntime.jsx(
+          "p",
+          {
+            className: "min-w-0 basis-full truncate px-1 text-[11px] text-muted-foreground",
+            "data-testid": tid("note"),
+            children: noteOf(atId)
+          }
+        ),
+        running.length > 0 && /* @__PURE__ */ jsxRuntime.jsxs(
+          "div",
+          {
+            className: ui.cn("flex min-w-0 shrink items-center gap-1", narrow && "basis-full"),
+            "data-testid": tid("working"),
+            children: [
+              (running.length > 2 ? running.slice(0, 1) : running).map(workingPill),
+              running.length > 2 && /* @__PURE__ */ jsxRuntime.jsxs(ui.Popover, { children: [
+                /* @__PURE__ */ jsxRuntime.jsx(ui.PopoverTrigger, { asChild: true, children: /* @__PURE__ */ jsxRuntime.jsxs(
+                  "button",
+                  {
+                    type: "button",
+                    className: "flex shrink-0 items-center gap-1 rounded-full border border-primary/40 bg-primary/5 px-2 py-1 text-xs text-primary hover:bg-primary/10",
+                    "data-testid": tid("working-more"),
+                    children: [
+                      /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Loader2, { className: "size-3.5 animate-spin" }),
+                      fill(l.moreWorking, { count: running.length - 1 })
+                    ]
+                  }
+                ) }),
+                /* @__PURE__ */ jsxRuntime.jsx(ui.PopoverContent, { align: "end", className: "w-72 p-1", children: running.slice(1).map((s) => row(s, false)) })
+              ] })
+            ]
+          }
+        )
+      ]
+    }
+  );
+}
+function GroupChip({
+  level,
+  label,
+  heading,
+  row,
+  tid
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsxs(ui.Popover, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(ui.PopoverTrigger, { asChild: true, children: /* @__PURE__ */ jsxRuntime.jsxs(
+      "button",
+      {
+        type: "button",
+        className: "shrink-0 rounded-full border border-border bg-muted px-1.5 py-0.5 text-[11px] font-medium tabular-nums text-muted-foreground hover:border-primary/40 hover:text-primary",
+        "aria-label": label,
+        title: label,
+        "data-testid": tid(`group-${level.steps[0].id}`),
+        children: [
+          "+",
+          level.others.length
+        ]
+      }
+    ) }),
+    /* @__PURE__ */ jsxRuntime.jsxs(
+      ui.PopoverContent,
+      {
+        align: "start",
+        className: "w-72 p-1",
+        "data-testid": tid(`group-${level.steps[0].id}-list`),
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx("p", { className: "px-2 py-1 text-[11px] font-medium text-muted-foreground", children: heading }),
+          level.steps.map(row)
+        ]
+      }
+    )
+  ] });
+}
+var DEFAULT_WORKFLOW_STEP_PARTS_LABELS = {
+  waitingFor: "Waiting for {name}",
+  sendBack: "Send back",
+  sendBackTo: "Send back to",
+  sendBackNote: "What needs to change? (optional)",
+  cancel: "Cancel",
+  sentBackHere: "This step was sent back to be done again.",
+  approvedBy: "Approved by {name}",
+  approvedAt: "{date}",
+  approvedWhat: "What was approved",
+  viewAnswer: "View the answer",
+  fieldsHeading: "Recorded with the approval",
+  signers: "Signers",
+  signed: "Signed",
+  notSigned: "Not signed yet",
+  openAndSign: "Open and sign",
+  decline: "Decline",
+  declineNote: "Why are you declining? (optional)",
+  declineConfirm: "Decline to sign",
+  declined: "Declined by {name}.",
+  signedVersion: "Open the signed version",
+  preparingSign: "Preparing the signature request\u2026",
+  expires: "Expires {date}",
+  preparingDraft: "Preparing the draft\u2026",
+  draftReady: "The draft is ready in native mail. Check it, send it, then mark it as sent.",
+  openDraft: "Open draft",
+  emailSent: "Sent.",
+  reviewRunning: "Reviewing the documents\u2026",
+  reviewDone: "Reviewed {docs} documents in {cols} columns.",
+  openReview: "Open the review",
+  openInWord: "Open in Word",
+  redlineHint: "The edits are tracked changes: accept or reject each one in Word.",
+  someone: "someone"
+};
+var formatDate = (iso) => {
+  const t = iso ? Date.parse(iso) : NaN;
+  return Number.isNaN(t) ? "" : new Date(t).toLocaleString(void 0, { dateStyle: "medium", timeStyle: "short" });
+};
+var docName = (ref, nameOfDoc) => {
+  const { id, version } = splitDocRef(ref);
+  const name = nameOfDoc?.(id) ?? id;
+  return version ? `${name} \xB7 v${version}` : name;
+};
+function DocChip({
+  docRef,
+  actions,
+  nameOfDoc,
+  testId
+}) {
+  const label = docName(docRef, nameOfDoc);
+  const cls = "inline-flex max-w-full items-center gap-1 rounded-md border border-border px-1.5 py-0.5 text-xs";
+  return actions?.openDocument ? /* @__PURE__ */ jsxRuntime.jsxs(
+    "button",
+    {
+      type: "button",
+      onClick: () => actions.openDocument?.(docRef),
+      className: ui.cn(cls, "hover:border-primary/40 hover:text-primary"),
+      title: docRef,
+      "data-testid": testId,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(lucideReact.FileText, { className: "size-3 shrink-0" }),
+        " ",
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "truncate", children: label })
+      ]
+    }
+  ) : /* @__PURE__ */ jsxRuntime.jsxs("span", { className: cls, title: docRef, "data-testid": testId, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(lucideReact.FileText, { className: "size-3 shrink-0" }),
+    " ",
+    /* @__PURE__ */ jsxRuntime.jsx("span", { className: "truncate", children: label })
+  ] });
+}
+function AssigneeLine({
+  run,
+  stepId,
+  l,
+  testId
+}) {
+  const name = run.assigneeOf(stepId);
+  const phase = run.phaseOf(stepId);
+  if (!name || !["ready", "waiting", "blocked"].includes(phase)) return null;
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "p",
+    {
+      className: "flex items-center gap-1.5 text-xs text-muted-foreground",
+      "data-testid": `${testId}-assignee`,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(lucideReact.UserRound, { className: "size-3.5" }),
+        " ",
+        l.waitingFor.replace("{name}", name)
+      ]
+    }
+  );
+}
+function SentBackNote({
+  state,
+  l,
+  testId
+}) {
+  if (!state?.sentBack) return null;
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "p",
+    {
+      className: "flex items-center gap-1.5 rounded-md bg-amber-500/10 px-2 py-1 text-xs text-amber-700 dark:text-amber-300",
+      "data-testid": `${testId}-sent-back`,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(lucideReact.CornerUpLeft, { className: "size-3.5" }),
+        " ",
+        l.sentBackHere
+      ]
+    }
+  );
+}
+function SendBackControl({
+  run,
+  step,
+  l,
+  testId
+}) {
+  const states = Object.fromEntries(
+    run.steps.map((s) => [s.id, run.stateOf(s.id) ?? { status: "pending" }])
+  );
+  const targets = sendBackTargets(run.steps, states, step.id);
+  const [open, setOpen] = react.useState(false);
+  const [to, setTo] = react.useState(targets[0]?.id ?? "");
+  const [note, setNote] = react.useState("");
+  if (!run.sendBack || run.phaseOf(step.id) !== "ready" || targets.length === 0) return null;
+  if (!open)
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      ui.Button,
+      {
+        variant: "outline",
+        size: "sm",
+        onClick: () => setOpen(true),
+        disabled: run.busy,
+        "data-testid": `${testId}-send-back`,
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx(lucideReact.CornerUpLeft, { className: "size-4" }),
+          " ",
+          l.sendBack
+        ]
+      }
+    );
+  const target = targets.some((t) => t.id === to) ? to : targets[0].id;
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      className: "space-y-2 rounded-md border border-border p-3",
+      "data-testid": `${testId}-send-back-form`,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("label", { className: "block space-y-1 text-xs font-medium", children: [
+          l.sendBackTo,
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "select",
+            {
+              className: "flex h-8 w-full rounded-md border border-input bg-background px-2 text-sm",
+              value: target,
+              onChange: (e) => setTo(e.target.value),
+              "data-testid": `${testId}-send-back-to`,
+              children: targets.map((t) => /* @__PURE__ */ jsxRuntime.jsx("option", { value: t.id, children: t.title }, t.id))
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          ui.Textarea,
+          {
+            rows: 3,
+            value: note,
+            placeholder: l.sendBackNote,
+            "aria-label": l.sendBackNote,
+            onChange: (e) => setNote(e.target.value),
+            "data-testid": `${testId}-send-back-note`
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex justify-end gap-2", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(ui.Button, { variant: "ghost", size: "sm", onClick: () => setOpen(false), children: l.cancel }),
+          /* @__PURE__ */ jsxRuntime.jsxs(
+            ui.Button,
+            {
+              size: "sm",
+              disabled: run.busy,
+              onClick: () => void run.sendBack?.(step.id, target, note.trim() || void 0),
+              "data-testid": `${testId}-send-back-confirm`,
+              children: [
+                /* @__PURE__ */ jsxRuntime.jsx(lucideReact.CornerUpLeft, { className: "size-4" }),
+                " ",
+                l.sendBack
+              ]
+            }
+          )
+        ] })
+      ]
+    }
+  );
+}
+var shownValue = (v, field, nameOf) => {
+  if (v === void 0 || v === null || v === "") return "\u2014";
+  if (typeof v === "boolean") return v ? "\u2713" : "\u2717";
+  if (field.type === "person" && typeof v === "string") return nameOf?.(v) ?? v;
+  if (field.type === "select") return field.options?.find((o) => o.value === v)?.label ?? String(v);
+  return typeof v === "object" ? JSON.stringify(v) : String(v);
+};
+function ApprovalEvidence({
+  run,
+  step,
+  actions,
+  nameOfDoc,
+  l,
+  testId
+}) {
+  const state = run.stateOf(step.id);
+  if (state?.status !== "done") return null;
+  const approver = state.by ? run.nameOf?.(state.by) ?? l.someone : void 0;
+  const evidence = state.approved ?? [];
+  const titleOf = (id) => run.steps.find((s) => s.id === id)?.title ?? id;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "space-y-2 rounded-md bg-muted/40 p-3", "data-testid": `${testId}-evidence`, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("p", { className: "flex flex-wrap items-center gap-1.5 text-sm font-medium", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(lucideReact.ShieldCheck, { className: "size-4 text-primary" }),
+      approver ? l.approvedBy.replace("{name}", approver) : null,
+      state.at && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-xs font-normal text-muted-foreground", children: l.approvedAt.replace("{date}", formatDate(state.at)) })
+    ] }),
+    evidence.length > 0 && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "space-y-1.5", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-xs font-semibold uppercase tracking-wide text-muted-foreground", children: l.approvedWhat }),
+      evidence.map((e) => /* @__PURE__ */ jsxRuntime.jsxs(
+        "div",
+        {
+          className: "flex flex-wrap items-center gap-1.5 text-xs",
+          "data-testid": `${testId}-evidence-${e.step}`,
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "font-medium", children: titleOf(e.step) }),
+            e.response_id && (actions?.openMessage ? /* @__PURE__ */ jsxRuntime.jsxs(
+              "button",
+              {
+                type: "button",
+                onClick: () => actions.openMessage?.(e.response_id),
+                className: "inline-flex items-center gap-1 text-primary hover:underline",
+                "data-testid": `${testId}-evidence-${e.step}-answer`,
+                children: [
+                  /* @__PURE__ */ jsxRuntime.jsx(lucideReact.MessageSquare, { className: "size-3" }),
+                  " ",
+                  l.viewAnswer
+                ]
+              }
+            ) : null),
+            (e.documents ?? []).map((d) => /* @__PURE__ */ jsxRuntime.jsx(DocChip, { docRef: d, actions, nameOfDoc }, d))
+          ]
+        },
+        e.step
+      ))
+    ] }),
+    (step.fields ?? []).length > 0 && /* @__PURE__ */ jsxRuntime.jsx("dl", { className: "grid grid-cols-[auto_1fr] gap-x-3 gap-y-0.5 text-xs", children: (step.fields ?? []).map((f) => /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "contents", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("dt", { className: "text-muted-foreground", children: f.label }),
+      /* @__PURE__ */ jsxRuntime.jsx("dd", { "data-testid": `${testId}-evidence-field-${f.name}`, children: shownValue(run.inputs[f.name], f, run.nameOf) })
+    ] }, f.name)) })
+  ] });
+}
+function RedlineOpen({
+  step,
+  state,
+  actions,
+  l,
+  testId
+}) {
+  const version = state?.status === "done" ? state.documents?.[0] : void 0;
+  if (!step.editDocument || !version || !actions?.openRedline) return null;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-wrap items-center gap-2", "data-testid": `${testId}-redline`, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(
+      ui.Button,
+      {
+        size: "sm",
+        onClick: () => actions.openRedline?.(version),
+        "data-testid": `${testId}-open-word`,
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx(lucideReact.FileText, { className: "size-4" }),
+          " ",
+          l.openInWord
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-xs text-muted-foreground", children: l.redlineHint })
+  ] });
+}
+function ActionStepBody({
+  step,
+  run,
+  actions,
+  nameOfDoc,
+  heading,
+  l,
+  testId
+}) {
+  const state = run.stateOf(step.id);
+  const phase = run.phaseOf(step.id);
+  const name = (id) => run.nameOf?.(id) ?? id;
+  const [declining, setDeclining] = react.useState(false);
+  const [note, setNote] = react.useState("");
+  const a = step.action;
+  const working = (text) => /* @__PURE__ */ jsxRuntime.jsxs(
+    "p",
+    {
+      className: "flex items-center gap-2 text-sm text-muted-foreground",
+      "data-testid": `${testId}-working`,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Loader2, { className: "size-4 animate-spin" }),
+        " ",
+        text
+      ]
+    }
+  );
+  let body = null;
+  if (a.type === "sign") {
+    const waiting = state?.waiting;
+    const signers = waiting?.signers ?? [];
+    const signed = new Set(waiting?.signed ?? []);
+    const mine = !actions?.me || signers.includes(actions.me) && !signed.has(actions.me);
+    const signedRef = state?.status === "done" ? state.documents?.[0] : void 0;
+    body = /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      (phase === "ready" || phase === "running") && working(l.preparingSign),
+      phase === "waiting" && waiting?.doc_ext_id && /* @__PURE__ */ jsxRuntime.jsx(
+        DocChip,
+        {
+          docRef: `${waiting.doc_ext_id}${waiting.version ? `@v${waiting.version}` : ""}`,
+          actions,
+          nameOfDoc,
+          testId: `${testId}-document`
+        }
+      ),
+      signers.length > 0 && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "space-y-1", "data-testid": `${testId}-signers`, children: [
+        /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-xs font-semibold uppercase tracking-wide text-muted-foreground", children: l.signers }),
+        signers.map((id) => /* @__PURE__ */ jsxRuntime.jsxs(
+          "p",
+          {
+            className: "flex items-center gap-2 text-sm",
+            "data-signed": signed.has(id) || void 0,
+            "data-testid": `${testId}-signer-${id}`,
+            children: [
+              signed.has(id) ? /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Check, { className: "size-3.5 text-primary" }) : /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Hourglass, { className: "size-3.5 text-muted-foreground" }),
+              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "font-medium", children: name(id) }),
+              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-xs text-muted-foreground", children: signed.has(id) ? l.signed : l.notSigned })
+            ]
+          },
+          id
+        ))
+      ] }),
+      waiting?.expires_at && phase === "waiting" && /* @__PURE__ */ jsxRuntime.jsxs("p", { className: "flex items-center gap-1.5 text-xs text-muted-foreground", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Clock, { className: "size-3.5" }),
+        " ",
+        l.expires.replace("{date}", formatDate(waiting.expires_at))
+      ] }),
+      phase === "waiting" && mine && !declining && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-wrap gap-2", children: [
+        actions?.sign && state && /* @__PURE__ */ jsxRuntime.jsxs(
+          ui.Button,
+          {
+            size: "sm",
+            onClick: () => actions.sign?.(step, state),
+            "data-testid": `${testId}-open-sign`,
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx(lucideReact.PenLine, { className: "size-4" }),
+              " ",
+              l.openAndSign
+            ]
+          }
+        ),
+        run.decline && /* @__PURE__ */ jsxRuntime.jsxs(
+          ui.Button,
+          {
+            size: "sm",
+            variant: "ghost",
+            onClick: () => setDeclining(true),
+            "data-testid": `${testId}-decline`,
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx(lucideReact.X, { className: "size-4" }),
+              " ",
+              l.decline
+            ]
+          }
+        )
+      ] }),
+      declining && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "space-y-2", "data-testid": `${testId}-decline-form`, children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          ui.Textarea,
+          {
+            rows: 2,
+            value: note,
+            placeholder: l.declineNote,
+            "aria-label": l.declineNote,
+            onChange: (e) => setNote(e.target.value),
+            "data-testid": `${testId}-decline-note`
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex justify-end gap-2", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(ui.Button, { variant: "ghost", size: "sm", onClick: () => setDeclining(false), children: l.cancel }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            ui.Button,
+            {
+              size: "sm",
+              variant: "destructive",
+              disabled: run.busy,
+              onClick: async () => {
+                await run.decline?.(step.id, note.trim() || void 0);
+                setDeclining(false);
+              },
+              "data-testid": `${testId}-decline-confirm`,
+              children: l.declineConfirm
+            }
+          )
+        ] })
+      ] }),
+      phase === "failed" && state?.declinedBy && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm text-destructive", "data-testid": `${testId}-declined`, children: l.declined.replace("{name}", name(state.declinedBy)) }),
+      signedRef && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex flex-wrap items-center gap-2", children: actions?.openDocument ? /* @__PURE__ */ jsxRuntime.jsxs(
+        ui.Button,
+        {
+          size: "sm",
+          variant: "outline",
+          onClick: () => actions.openDocument?.(signedRef),
+          "data-testid": `${testId}-signed-version`,
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx(lucideReact.ExternalLink, { className: "size-4" }),
+            " ",
+            l.signedVersion
+          ]
+        }
+      ) : /* @__PURE__ */ jsxRuntime.jsx(DocChip, { docRef: signedRef, nameOfDoc }) })
+    ] });
+  } else if (a.type === "email_draft") {
+    const draftId = state?.waiting?.draft_id ?? (typeof state?.output?.draft_id === "string" ? state.output.draft_id : void 0);
+    body = /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      (phase === "ready" || phase === "running") && working(l.preparingDraft),
+      phase === "waiting" && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm text-muted-foreground", children: l.draftReady }),
+      phase === "done" && /* @__PURE__ */ jsxRuntime.jsxs("p", { className: "flex items-center gap-1.5 text-sm", "data-testid": `${testId}-sent`, children: [
+        /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Check, { className: "size-4 text-primary" }),
+        " ",
+        l.emailSent
+      ] }),
+      draftId && actions?.openDraft && phase !== "done" && /* @__PURE__ */ jsxRuntime.jsxs(
+        ui.Button,
+        {
+          size: "sm",
+          variant: "outline",
+          onClick: () => actions.openDraft?.(draftId, state?.waiting?.mailbox),
+          "data-testid": `${testId}-open-draft`,
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Mail, { className: "size-4" }),
+            " ",
+            l.openDraft
+          ]
+        }
+      )
+    ] });
+  } else {
+    const tags = state?.output?.tag_ext_ids ?? a.tags;
+    const docs = state?.output?.doc_ext_ids ?? [];
+    body = /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      (phase === "ready" || phase === "running") && working(l.reviewRunning),
+      phase === "done" && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm text-muted-foreground", "data-testid": `${testId}-reviewed`, children: l.reviewDone.replace("{docs}", String(docs.length)).replace("{cols}", String(tags.length)) }),
+        actions?.openReview && /* @__PURE__ */ jsxRuntime.jsxs(
+          ui.Button,
+          {
+            size: "sm",
+            onClick: () => actions.openReview?.(tags, docs),
+            "data-testid": `${testId}-open-review`,
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Table2, { className: "size-4" }),
+              " ",
+              l.openReview
+            ]
+          }
+        )
+      ] })
+    ] });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "space-y-3", children: [
+    heading,
+    /* @__PURE__ */ jsxRuntime.jsx(SentBackNote, { state, l, testId }),
+    /* @__PURE__ */ jsxRuntime.jsx(AssigneeLine, { run, stepId: step.id, l, testId }),
+    body,
+    phase === "failed" && !state?.declinedBy && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm text-destructive", "data-testid": `${testId}-failed`, children: state?.error || "" })
+  ] });
+}
+var DONE = "__done";
+function WorkflowStepBar({
+  run,
+  levels,
+  doneTitle,
+  doneIcon,
+  icon,
+  tid,
+  labels
+}) {
+  const l = { ...DEFAULT_STEP_BAR_LABELS, ...labels };
+  const done = { id: DONE, title: doneTitle };
+  const phaseOf = (id) => id === DONE ? run.isComplete ? "done" : "blocked" : run.phaseOf(id);
+  const current = run.isComplete ? DONE : run.current;
+  const waitingOf = (id) => {
+    if (id === DONE || !["ready", "waiting"].includes(phaseOf(id))) return void 0;
+    const assignee = run.assigneeOf(id);
+    return assignee ? l.waitingFor.replace("{name}", assignee) : void 0;
+  };
+  const pill = (s, narrow = false) => {
+    const phase = phaseOf(s.id);
+    const isCurrent = s.id === current;
+    const assignee = ["ready", "waiting"].includes(phase) ? run.assigneeOf(s.id) : void 0;
+    const waiting = assignee ? l.waitingFor.replace("{name}", assignee) : void 0;
+    const title = waiting ? `${s.title} \xB7 ${waiting}` : s.title;
+    const name = `${title} (${l.phases[phase]})`;
+    if (s.id === DONE)
+      return /* @__PURE__ */ jsxRuntime.jsxs(
+        "span",
+        {
+          className: ui.cn(STEP_PILL, stepPillTone(phase, isCurrent)),
+          "aria-current": isCurrent ? "step" : void 0,
+          "aria-label": name,
+          title: doneTitle,
+          "data-phase": phase,
+          "data-testid": tid("step-done"),
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx(PhaseMark, { phase: run.isComplete ? "done" : "ready", icon: doneIcon }),
+            /* @__PURE__ */ jsxRuntime.jsx("span", { className: ui.cn(STEP_LABEL, "max-w-[12rem]"), children: doneTitle })
+          ]
+        }
+      );
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      "button",
+      {
+        type: "button",
+        onClick: () => run.goTo(s.id),
+        disabled: run.busy,
+        className: ui.cn(STEP_PILL, stepPillTone(phase, isCurrent), "disabled:cursor-default"),
+        "aria-current": isCurrent ? "step" : void 0,
+        "aria-label": name,
+        title,
+        "data-phase": phase,
+        "data-testid": tid(`step-${s.id}`),
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx(PhaseMark, { phase, icon: icon(s.icon) }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "span",
+            {
+              className: ui.cn(STEP_LABEL, isCurrent ? "max-w-[18rem]" : "max-w-[12rem]"),
+              "data-testid": tid(`step-${s.id}-label`),
+              children: s.title
+            }
+          ),
+          assignee && isCurrent && !narrow && /* @__PURE__ */ jsxRuntime.jsxs(
+            "span",
+            {
+              className: ui.cn(STEP_EXTRA, "max-w-[12rem]"),
+              "data-testid": tid(`step-${s.id}-assignee`),
+              children: [
+                "\xB7 ",
+                waiting
+              ]
+            }
+          )
+        ]
+      }
+    );
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    StepBarFrame,
+    {
+      levels: [...levels, [done]],
+      phaseOf,
+      current,
+      onSelect: (id) => id !== DONE && run.goTo(id),
+      isSelectable: (id) => id !== DONE,
+      renderStep: (s, _level, _win, narrow) => pill(s, narrow),
+      noteOf: waitingOf,
+      icon: (s) => s.id === DONE ? doneIcon : icon(s.icon),
+      disabled: run.busy,
+      labels,
+      tid,
+      className: "w-full"
+    }
+  );
+}
+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",
+  markSent: "Mark as sent"
+};
+function WorkflowRunner({
+  workflow,
+  run,
+  renderAgentOutput,
+  renderReview,
+  onUpload,
+  uploading = false,
+  files,
+  renderUpload,
+  renderStepNote,
+  renderComplete,
+  renderScope,
+  renderDocuments,
+  renderIcon,
+  people,
+  actions,
+  nameOfDoc,
+  hideStepBar,
+  compact: compact3,
+  labels,
+  partsLabels,
+  testIdPrefix = "workflow-run",
+  className
+}) {
+  const l = { ...DEFAULT_WORKFLOW_RUNNER_LABELS, ...labels };
+  const pl = { ...DEFAULT_WORKFLOW_STEP_PARTS_LABELS, ...partsLabels };
+  const box = compact3 ? "p-4" : "max-w-2xl p-6";
+  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 === "complete" && step?.kind === "action" ? l.markSent : action === "wait" && (run.isRunning || run.busy) ? l.working : (step && !run.isLocked(step.id) ? step.nextLabel : void 0) ?? l.next;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: ui.cn(compact3 ? "space-y-3" : "space-y-6", className), "data-testid": testIdPrefix, children: [
+    !hideStepBar && /* @__PURE__ */ jsxRuntime.jsx(
+      WorkflowStepBar,
+      {
+        run,
+        levels,
+        doneTitle: completion?.title ?? l.complete,
+        doneIcon: icon(completion?.icon),
+        icon,
+        tid
+      }
+    ),
+    isComplete ? renderComplete?.(run) ?? /* @__PURE__ */ jsxRuntime.jsxs(ui.Card, { className: "mx-auto max-w-lg p-8 text-center", "data-testid": tid("done"), children: [
+      /* @__PURE__ */ jsxRuntime.jsx(lucideReact.CheckCircle2, { className: "mx-auto size-12 text-primary" }),
+      /* @__PURE__ */ jsxRuntime.jsx("h2", { className: "mt-4 text-xl font-semibold", children: completion?.title ?? l.complete }),
+      completion?.description && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "mt-1 text-sm text-muted-foreground", children: completion.description }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        ui.Button,
+        {
+          variant: "outline",
+          className: "mt-6",
+          onClick: run.restart,
+          "data-testid": tid("restart"),
+          children: l.restart
+        }
+      )
+    ] }) : step ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: "space-y-3", children: run.phaseOf(step.id) === "blocked" ? /* @__PURE__ */ jsxRuntime.jsx(ui.Card, { className: ui.cn(box, "p-6"), "data-testid": tid(step.id), children: /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.jsxs(ui.Card, { className: ui.cn(box, "space-y-4"), "data-testid": tid(step.id), children: [
+      /* @__PURE__ */ jsxRuntime.jsx(StepHeading, { step, icon: icon(step.icon), testId: tid(`${step.id}-title`) }),
+      /* @__PURE__ */ jsxRuntime.jsx(SentBackNote, { state: run.stateOf(step.id), l: pl, testId: tid(step.id) }),
+      /* @__PURE__ */ jsxRuntime.jsx(AssigneeLine, { run, stepId: step.id, l: pl, testId: tid(step.id) }),
+      /* @__PURE__ */ jsxRuntime.jsx("fieldset", { disabled: run.isLocked(step.id), className: "contents", children: /* @__PURE__ */ jsxRuntime.jsx(
+        SchemaForm,
+        {
+          fields: step.inputs,
+          values: run.inputs,
+          onChange: run.setInput,
+          errors: run.errors,
+          renderScope,
+          renderDocuments,
+          renderIcon,
+          people,
+          onEnterSubmit: () => void run.next(),
+          testIdPrefix: tid("field")
+        }
+      ) }),
+      run.actionError && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm text-destructive", "data-testid": tid("action-error"), children: run.actionError }),
+      renderStepNote?.(step, run)
+    ] }) : step.kind === "upload" ? /* @__PURE__ */ jsxRuntime.jsxs(ui.Card, { className: ui.cn(box, "space-y-4"), "data-testid": tid(step.id), children: [
+      /* @__PURE__ */ jsxRuntime.jsx(SentBackNote, { state: run.stateOf(step.id), l: pl, testId: tid(step.id) }),
+      /* @__PURE__ */ jsxRuntime.jsx(AssigneeLine, { run, stepId: step.id, l: pl, testId: tid(step.id) }),
+      renderUpload?.(step) ?? /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          chunkDETZZBG2_cjs.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__ */ jsxRuntime.jsx(
+          UploadFiles,
+          {
+            added,
+            others: files.filter((f) => f.addedFor !== step.id),
+            l,
+            testId: tid(`${step.id}-files`)
+          }
+        )
+      ] }),
+      run.actionError && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm text-destructive", children: run.actionError }),
+      renderStepNote?.(step, run)
+    ] }) : step.kind === "review" ? /* @__PURE__ */ jsxRuntime.jsxs(ui.Card, { className: ui.cn(box, "space-y-4"), "data-testid": tid(step.id), children: [
+      /* @__PURE__ */ jsxRuntime.jsx(StepHeading, { step, icon: icon(step.icon) }),
+      /* @__PURE__ */ jsxRuntime.jsx(SentBackNote, { state: run.stateOf(step.id), l: pl, testId: tid(step.id) }),
+      /* @__PURE__ */ jsxRuntime.jsx("p", { className: "whitespace-pre-line text-sm text-muted-foreground", children: reviewInstructions(step, run.inputs) }),
+      /* @__PURE__ */ jsxRuntime.jsx(AssigneeLine, { run, stepId: step.id, l: pl, testId: tid(step.id) }),
+      !(run.phaseOf(step.id) === "done" && run.stateOf(step.id)?.by) && /* @__PURE__ */ jsxRuntime.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 }),
+      (step.fields ?? []).length > 0 && run.phaseOf(step.id) === "ready" && /* @__PURE__ */ jsxRuntime.jsx(
+        SchemaForm,
+        {
+          fields: step.fields ?? [],
+          values: run.inputs,
+          onChange: run.setInput,
+          errors: run.errors,
+          renderScope,
+          renderDocuments,
+          renderIcon,
+          people,
+          testIdPrefix: tid("field")
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        ApprovalEvidence,
+        {
+          run,
+          step,
+          actions,
+          nameOfDoc,
+          l: pl,
+          testId: tid(step.id)
+        }
+      ),
+      run.phaseOf(step.id) === "ready" && renderReview?.(step),
+      /* @__PURE__ */ jsxRuntime.jsx(SendBackControl, { run, step, l: pl, testId: tid(step.id) }),
+      run.actionError && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm text-destructive", children: run.actionError }),
+      renderStepNote?.(step, run)
+    ] }) : step.kind === "action" ? /* @__PURE__ */ jsxRuntime.jsxs(ui.Card, { className: ui.cn(box, "space-y-4"), "data-testid": tid(step.id), children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        ActionStepBody,
+        {
+          step,
+          run,
+          actions,
+          nameOfDoc,
+          heading: /* @__PURE__ */ jsxRuntime.jsx(StepHeading, { step, icon: icon(step.icon) }),
+          l: pl,
+          testId: tid(step.id)
+        }
+      ),
+      run.actionError && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm text-destructive", children: run.actionError }),
+      renderStepNote?.(step, run)
+    ] }) : /* @__PURE__ */ jsxRuntime.jsx(
+      AgentStepBody,
+      {
+        step,
+        run,
+        renderAgentOutput,
+        icon: icon(step.icon),
+        renderStepNote,
+        compact: compact3,
+        extra: /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(SentBackNote, { state: run.stateOf(step.id), l: pl, testId: tid(step.id) }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            RedlineOpen,
+            {
+              step,
+              state: run.stateOf(step.id),
+              actions,
+              l: pl,
+              testId: tid(step.id)
+            }
+          )
+        ] }),
+        l,
+        tid
+      }
+    ) }, step.id) : null,
+    !isComplete && /* @__PURE__ */ jsxRuntime.jsxs(
+      "div",
+      {
+        className: ui.cn(
+          "flex items-center justify-between border-t border-border pt-4",
+          compact3 && "flex-wrap gap-2 pt-3"
+        ),
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsxs(
+            ui.Button,
+            {
+              variant: "ghost",
+              onClick: run.back,
+              disabled: !run.canBack,
+              "data-testid": tid("back"),
+              children: [
+                /* @__PURE__ */ jsxRuntime.jsx(lucideReact.ArrowLeft, { className: "size-4" }),
+                " ",
+                l.back
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsxs(
+            "div",
+            {
+              className: ui.cn("flex items-center gap-2", compact3 && "ml-auto flex-wrap justify-end"),
+              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__ */ jsxRuntime.jsx(
+                  ui.Button,
+                  {
+                    variant: "ghost",
+                    onClick: () => void run.skip(step.id),
+                    disabled: run.busy,
+                    "data-testid": tid("skip-step"),
+                    children: l.skipStep
+                  }
+                ),
+                /* @__PURE__ */ jsxRuntime.jsxs(
+                  ui.Button,
+                  {
+                    onClick: () => void run.next(),
+                    disabled: action === "wait" || reading,
+                    "data-testid": tid("next"),
+                    children: [
+                      nextLabel,
+                      reading || action === "wait" && (run.isRunning || run.busy) ? /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Loader2, { className: "size-4 animate-spin" }) : /* @__PURE__ */ jsxRuntime.jsx(lucideReact.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__ */ jsxRuntime.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__ */ jsxRuntime.jsx(lucideReact.FileText, { className: "size-3.5 shrink-0 text-primary" }),
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "min-w-0 flex-1 truncate", title: f.name, children: f.name }),
+        f.status === "processing" && /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "flex shrink-0 items-center gap-1 text-xs", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Loader2, { className: "size-3 animate-spin" }),
+          " ",
+          l.fileReading
+        ] }),
+        f.status === "ready" && /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "flex shrink-0 items-center gap-1 text-xs text-primary", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Check, { className: "size-3" }),
+          " ",
+          l.fileReady
+        ] }),
+        f.status === "failed" && /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "flex shrink-0 items-center gap-1 text-xs text-destructive", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(lucideReact.AlertTriangle, { className: "size-3" }),
+          " ",
+          l.fileFailed
+        ] })
+      ]
+    },
+    f.id
+  );
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "space-y-3", "data-testid": testId, children: [
+    added.length > 0 && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "space-y-1", "data-testid": `${testId}-added`, children: [
+      /* @__PURE__ */ jsxRuntime.jsx("p", { className: heading, children: l.addedHeading.replace("{count}", String(added.length)) }),
+      added.map(row)
+    ] }),
+    added.length === 0 && others.length === 0 && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm text-muted-foreground", children: l.noFiles }),
+    others.length > 0 && /* @__PURE__ */ jsxRuntime.jsxs("details", { className: "space-y-1", "data-testid": `${testId}-others`, children: [
+      /* @__PURE__ */ jsxRuntime.jsx("summary", { className: ui.cn(heading, "cursor-pointer select-none"), children: l.filesHeading.replace("{count}", String(others.length)) }),
+      /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.jsxs("div", { className: "min-w-0", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("p", { className: "flex items-center gap-2 text-sm font-medium", "data-testid": testId, children: [
+      icon && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "flex size-4 items-center justify-center text-primary [&_svg]:size-4", children: icon }),
+      step.title
+    ] }),
+    step.description && /* @__PURE__ */ jsxRuntime.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 = react.useRef(Date.now());
+  const start = since && Date.parse(since) || seen.current;
+  const [now, setNow] = react.useState(() => Date.now());
+  react.useEffect(() => {
+    const t = setInterval(() => setNow(Date.now()), 1e3);
+    return () => clearInterval(t);
+  }, []);
+  return /* @__PURE__ */ jsxRuntime.jsx("span", { children: label.replace("{step}", title).replace("{elapsed}", formatElapsed(now - start)) });
+}
+function AgentStepBody({
+  step,
+  run,
+  renderAgentOutput,
+  icon,
+  renderStepNote,
+  extra,
+  compact: compact3,
+  l,
+  tid
+}) {
+  const state = run.stateOf(step.id);
+  const phase = run.phaseOf(step.id);
+  const header = /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-start justify-between gap-3", children: [
+    /* @__PURE__ */ jsxRuntime.jsx(StepHeading, { step, icon }),
+    phase === "failed" && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex shrink-0 items-center gap-2", children: run.retry && /* @__PURE__ */ jsxRuntime.jsxs(
+      ui.Button,
+      {
+        variant: "outline",
+        size: "sm",
+        onClick: () => void run.retry?.(step.id),
+        disabled: run.busy,
+        "data-testid": tid(`${step.id}-retry`),
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx(lucideReact.RotateCw, { className: "size-4" }),
+          " ",
+          l.retry
+        ]
+      }
+    ) })
+  ] });
+  const status = /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "space-y-1", children: [
+    step.branch && /* @__PURE__ */ jsxRuntime.jsxs("p", { className: "flex items-center gap-1.5 text-xs text-muted-foreground", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(lucideReact.GitBranch, { className: "size-3.5" }),
+      " ",
+      l.branch
+    ] }),
+    (phase === "ready" || phase === "running") && !state?.text && /* @__PURE__ */ jsxRuntime.jsxs(
+      "p",
+      {
+        className: "flex items-center gap-2 text-sm text-muted-foreground",
+        "data-testid": tid(`${step.id}-working`),
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Loader2, { className: "size-4 animate-spin" }),
+          " ",
+          phase === "ready" ? l.starting : /* @__PURE__ */ jsxRuntime.jsx(StepWorking, { title: step.title, since: state?.startedAt, label: l.stepWorking })
+        ]
+      }
+    ),
+    phase === "failed" && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm text-destructive", "data-testid": tid(`${step.id}-failed`), children: state?.error || l.failed }),
+    phase === "skipped" && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm text-muted-foreground", children: l.skipped }),
+    extra
+  ] });
+  if (step.output === "artifact" && !compact3) {
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      "div",
+      {
+        className: "grid gap-4 lg:grid-cols-[minmax(0,18rem)_minmax(0,1fr)]",
+        "data-testid": tid(step.id),
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsxs(ui.Card, { className: "h-fit space-y-3 p-5", children: [
+            header,
+            status,
+            renderStepNote?.(step, run)
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "min-w-0", children: renderAgentOutput(step, state) })
+        ]
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs(ui.Card, { className: ui.cn("space-y-3", compact3 ? "p-4" : "p-6"), "data-testid": tid(step.id), children: [
+    header,
+    status,
+    renderAgentOutput(step, state),
+    renderStepNote?.(step, run)
+  ] });
+}
+
+exports.ActionStepBody = ActionStepBody;
+exports.ApprovalEvidence = ApprovalEvidence;
+exports.AssigneeLine = AssigneeLine;
+exports.DEFAULT_ASSIGNEE_WORDING = DEFAULT_ASSIGNEE_WORDING;
+exports.DEFAULT_SCHEMA_FORM_LABELS = DEFAULT_SCHEMA_FORM_LABELS;
+exports.DEFAULT_STEP_BAR_LABELS = DEFAULT_STEP_BAR_LABELS;
+exports.DEFAULT_WORKFLOW_RUNNER_LABELS = DEFAULT_WORKFLOW_RUNNER_LABELS;
+exports.DEFAULT_WORKFLOW_STEP_PARTS_LABELS = DEFAULT_WORKFLOW_STEP_PARTS_LABELS;
+exports.EMPTY_WORKFLOW_SCOPE = EMPTY_WORKFLOW_SCOPE;
+exports.PhaseMark = PhaseMark;
+exports.SKILL_PROMPT_FALLBACK_PLACEHOLDER = SKILL_PROMPT_FALLBACK_PLACEHOLDER;
+exports.SKILL_PROMPT_LABEL = SKILL_PROMPT_LABEL;
+exports.STEP_EXTRA = STEP_EXTRA;
+exports.STEP_LABEL = STEP_LABEL;
+exports.STEP_PILL = STEP_PILL;
+exports.SchemaForm = SchemaForm;
+exports.SendBackControl = SendBackControl;
+exports.StepBarFrame = StepBarFrame;
+exports.WorkflowRunner = WorkflowRunner;
+exports.WorkflowStepBar = WorkflowStepBar;
+exports.activeStepId = activeStepId;
+exports.assigneeName = assigneeName;
+exports.buildLaunch = buildLaunch;
+exports.canAssign = canAssign;
+exports.composeStepPrompt = composeStepPrompt;
+exports.composeWorkflowPrompt = composeWorkflowPrompt;
+exports.defaultInputs = defaultInputs;
+exports.dependsOn = dependsOn;
+exports.fieldToFrontmatter = fieldToFrontmatter;
+exports.fillRunText = fillRunText;
+exports.fillStepInputs = fillStepInputs;
+exports.fromPlanAssignee = fromPlanAssignee;
+exports.fromPlanDocumentRef = fromPlanDocumentRef;
+exports.fromPlanSteps = fromPlanSteps;
+exports.initialRunInputs = initialRunInputs;
+exports.inputsFromContext = inputsFromContext;
+exports.isEmptyWorkflowScope = isEmptyWorkflowScope;
+exports.isIncompleteSignal = isIncompleteSignal;
+exports.isPersonAction = isPersonAction;
+exports.isPersonStep = isPersonStep;
+exports.isRunFinished = isRunFinished;
+exports.isSteppedWorkflow = isSteppedWorkflow;
+exports.isWorkflowScope = isWorkflowScope;
+exports.layoutFromPlanSteps = layoutFromPlanSteps;
+exports.nextAction = nextAction;
+exports.orderSteps = orderSteps;
+exports.promptFieldName = promptFieldName;
+exports.reviewInstructions = reviewInstructions;
+exports.runFields = runFields;
+exports.runFieldsOf = runFieldsOf;
+exports.runThreadTitle = runThreadTitle;
+exports.sendBackTargets = sendBackTargets;
+exports.skillToWorkflow = skillToWorkflow;
+exports.splitDocRef = splitDocRef;
+exports.stepConfigProblems = stepConfigProblems;
+exports.stepDependencies = stepDependencies;
+exports.stepFields = stepFields;
+exports.stepLevels = stepLevels;
+exports.stepPhase = stepPhase;
+exports.stepPillTone = stepPillTone;
+exports.stepStatesFromActivity = stepStatesFromActivity;
+exports.stepWindow = stepWindow;
+exports.toPlanAssignee = toPlanAssignee;
+exports.toPlanDocumentRef = toPlanDocumentRef;
+exports.toPlanSteps = toPlanSteps;
+exports.upstreamSteps = upstreamSteps;
+exports.useWorkflowView = useWorkflowView;
+exports.validateInputs = validateInputs;
+exports.validateStep = validateStep;
+exports.validateWorkflowGraph = validateWorkflowGraph;
+exports.workflowAccepts = workflowAccepts;
+exports.workflowFromFrontmatter = workflowFromFrontmatter;
+exports.workflowSteps = workflowSteps;
+exports.workflowsAccepting = workflowsAccepting;
+exports.workflowsForHost = workflowsForHost;
+//# sourceMappingURL=chunk-VFIZYSZB.cjs.map
+//# sourceMappingURL=chunk-VFIZYSZB.cjs.map