@arbidocs/blocks 0.4.122 → 0.4.123

package/dist/agents/index.js

@@ -1,27 +1,27 @@
 "use client";
-export { AgentAvatarField, AgentBar, AgentBarIconButton, AgentBarMenu, AgentBarNotes, AgentBarProbeAnswer, AgentBarQueuedNote, AgentBarStatus, AgentCard, AgentCreateView, AgentCreatedView, AgentCreator, AgentEditView, AgentGallery, AgentMainView, AgentSelect, AgentTypeSelector, CapabilityGrid, CapabilityTile, ConfigField, ConfigForm, ConsentActions, ConsentBulletList, ConsentCard, ConsentFootnote, ConsentHeader, ConsentMessage, ConsentNotice, ConsentPage, ConsentPermissionList, ConsentSection, ConsentStrong, ConsentText, ConversationListView, ConversationTurnSpeaker, CopyableUrl, DEFAULT_AGENT_AVATAR_FIELD_LABELS, DEFAULT_AGENT_BAR_LABELS, DEFAULT_AGENT_CARD_LABELS, DEFAULT_AGENT_CREATOR_LABELS, DEFAULT_AGENT_GALLERY_LABELS, DEFAULT_AGENT_SELECT_LABELS, DEFAULT_AGENT_STEPS_LABELS, DEFAULT_AGENT_TYPE_SELECTOR_LABELS, DEFAULT_AUTHORIZE_AGENT_LABELS, DEFAULT_CONFIG_FIELD_LABELS, DEFAULT_CONFIG_FORM_LABELS, DEFAULT_CONSENT_ACTIONS_LABELS, DEFAULT_COPYABLE_URL_LABELS, DEFAULT_NEW_THREAD_DIALOG_LABELS, DEFAULT_PILL_SELECT_LABELS, DEFAULT_RECURRENCE, DEFAULT_RECURRENCE_BUILDER_LABELS, DEFAULT_SKILL_CARD_LABELS, DEFAULT_SKILL_EDIT_FORM_LABELS, DEFAULT_SKILL_GENERATE_FORM_LABELS, DEFAULT_SKILL_GLOBAL_BADGE_LABELS, DEFAULT_SKILL_ROW_LABELS, DEFAULT_SKILL_VIEW_TOGGLE_LABELS, DEFAULT_SUBAGENT_ROSTER_LABELS, DEFAULT_TASKS_CHROME_LABELS, DEFAULT_TASK_COMPOSER_LABELS, DEFAULT_TASK_LIST_LABELS, DEFAULT_TASK_OUTPUTS_CELL_LABELS, DEFAULT_TASK_PLAN_LABELS, DEFAULT_TASK_RUNS_DIALOG_LABELS, DEFAULT_TASK_STATUS_PILL_LABELS, DEFAULT_TASK_THREAD_CHIP_LABELS, DEFAULT_TASK_TRIGGER_CHIP_LABELS, DEFAULT_TUPLE_ARRAY_FIELD_LABELS, DEFAULT_UPLOAD_TASK_ITEM_LABELS, DEFAULT_UPLOAD_TASK_LIST_LABELS, DEFAULT_WORKFLOWS_CHROME_LABELS, DEFAULT_WORKFLOW_CONFIG_DIALOG_LABELS, DEFAULT_WORKFLOW_LIST_LABELS, DEFAULT_WORKFLOW_THREAD_STRIP_LABELS, DERIVED_NAME_WORDS, EMPTY_NEW_THREAD, GoalCriteria, MAX_TASK_DEPTH, NewThreadDialog, PersonPill, PillSelect, RecurrenceBuilder, STATUS_LABELS, STATUS_ORDER, STATUS_TONE, SkillActionButton, SkillCard, SkillDetail, SkillDetailSection, SkillEditForm, SkillFilterChips, SkillGenerateForm, SkillGlobalBadge, SkillRow, SkillTile, SkillTypeBadge, SkillViewToggle, StepDetail, StepNarration, StepOutcome, StepParams, StepRow, StepSummary, StepTrace, StepTraceSummary, SubAgentLane, SubStepGroup, SubagentRoster, TASK_COLUMN_ORDER, TRIGGER_LABELS, TaskActivityDialog, TaskComposer, TaskFlow, TaskInbox, TaskMoveDialog, TaskOutputsCell, TaskPlan, TaskRunsDialog, TaskStartDialog, TaskStatusPill, TaskTable, TaskThreadChip, TaskTriggerChip, TasksToolbar, ThreadActivity, ThreadNotifyDialog, TupleArrayField, UploadTaskItem, UploadTaskList, WEEKDAYS, WORKFLOW_COLUMN_ORDER, WorkflowConfigDialog, WorkflowDocumentsField, WorkflowLauncher, WorkflowThreadStartedBy, WorkflowThreadStrip, WorkflowsTable, WorkflowsToolbar, agentConfigSectionToValues, agentCreatorToConfigSection, asTaskStatus, authModeFor, buildRRule, buildTaskRows, buildWorkflowScopeSource, compactThreadActivity, composePersona, composerToTaskQuery, composerToWorkRequest, composerToWorkflowRequest, composerToWorkflowUpdate, createTaskColumns, createWorkflowColumns, createsWork, defaultScopeRenderer, defaultTaskComposerValues, deriveAgentName, deriveWorkflowName, descendantIds, describeRRule, filterConversationRows, firstWords, formatElapsed, goalProgress, groupThreadActivity, hasTaskFields, hasTrigger, humanizeSection, indexTasks, inferType, inputDocumentIds, isAgenticWorkflow, isOutOfBounds, isPlainTodo, isSkillRow, isValidAgentName, isoToLocalInput, linkedRunsFromActivity, localInputToIso, matchWorkflowScope, moveTargets, newThreadToRequest, nextCriterionId, ownerExtId, parseRRule, prettifyKey, resolveScopeInputs, skillSlug, stripPersonaPreamble, summarizeAgent, summarizeCapabilities, taskComposerToCreateRequest, taskComposerToUpdateRequest, taskNeedsAccess, taskToComposerValues, useWorkflowPreview, workflowFromSkillMarkdown, workflowStatus, workflowTaskFields, workflowToComposerValues, workflowToSkillMarkdown, workflowTriggerType, workflowWhen } from '../chunk-ZP4IFW2E.js';
+export { AgentAvatarField, AgentBar, AgentBarIconButton, AgentBarMenu, AgentBarNotes, AgentBarProbeAnswer, AgentBarQueuedNote, AgentBarStatus, AgentCard, AgentCreateView, AgentCreatedView, AgentCreator, AgentEditView, AgentGallery, AgentMainView, AgentSelect, AgentTypeSelector, CapabilityGrid, CapabilityTile, ConfigField, ConfigForm, ConsentActions, ConsentBulletList, ConsentCard, ConsentFootnote, ConsentHeader, ConsentMessage, ConsentNotice, ConsentPage, ConsentPermissionList, ConsentSection, ConsentStrong, ConsentText, ConversationListView, ConversationTurnSpeaker, CopyableUrl, DEFAULT_AGENT_AVATAR_FIELD_LABELS, DEFAULT_AGENT_BAR_LABELS, DEFAULT_AGENT_CARD_LABELS, DEFAULT_AGENT_CREATOR_LABELS, DEFAULT_AGENT_GALLERY_LABELS, DEFAULT_AGENT_SELECT_LABELS, DEFAULT_AGENT_STEPS_LABELS, DEFAULT_AGENT_TYPE_SELECTOR_LABELS, DEFAULT_AUTHORIZE_AGENT_LABELS, DEFAULT_CONFIG_FIELD_LABELS, DEFAULT_CONFIG_FORM_LABELS, DEFAULT_CONSENT_ACTIONS_LABELS, DEFAULT_COPYABLE_URL_LABELS, DEFAULT_NEW_THREAD_DIALOG_LABELS, DEFAULT_PILL_SELECT_LABELS, DEFAULT_RECURRENCE, DEFAULT_RECURRENCE_BUILDER_LABELS, DEFAULT_SKILL_CARD_LABELS, DEFAULT_SKILL_EDIT_FORM_LABELS, DEFAULT_SKILL_GENERATE_FORM_LABELS, DEFAULT_SKILL_GLOBAL_BADGE_LABELS, DEFAULT_SKILL_ROW_LABELS, DEFAULT_SKILL_VIEW_TOGGLE_LABELS, DEFAULT_SUBAGENT_ROSTER_LABELS, DEFAULT_TASKS_CHROME_LABELS, DEFAULT_TASK_COMPOSER_LABELS, DEFAULT_TASK_LIST_LABELS, DEFAULT_TASK_OUTPUTS_CELL_LABELS, DEFAULT_TASK_PLAN_LABELS, DEFAULT_TASK_RUNS_DIALOG_LABELS, DEFAULT_TASK_STATUS_PILL_LABELS, DEFAULT_TASK_THREAD_CHIP_LABELS, DEFAULT_TASK_TRIGGER_CHIP_LABELS, DEFAULT_THREAD_LAUNCHER_LABELS, DEFAULT_THREAD_STATE_LABELS, DEFAULT_TUPLE_ARRAY_FIELD_LABELS, DEFAULT_UPLOAD_TASK_ITEM_LABELS, DEFAULT_UPLOAD_TASK_LIST_LABELS, DEFAULT_WORKFLOWS_CHROME_LABELS, DEFAULT_WORKFLOW_CONFIG_DIALOG_LABELS, DEFAULT_WORKFLOW_LIST_LABELS, DEFAULT_WORKFLOW_RUN_STATUS_LABELS, DEFAULT_WORKFLOW_THREAD_STRIP_LABELS, DERIVED_NAME_WORDS, EMPTY_NEW_THREAD, GoalCriteria, MAX_TASK_DEPTH, NewThreadDialog, PersonPill, PillSelect, RecurrenceBuilder, STATUS_LABELS, STATUS_ORDER, STATUS_TONE, SkillActionButton, SkillCard, SkillDetail, SkillDetailSection, SkillEditForm, SkillFilterChips, SkillGenerateForm, SkillGlobalBadge, SkillRow, SkillTile, SkillTypeBadge, SkillViewToggle, StepDetail, StepNarration, StepOutcome, StepParams, StepRow, StepSummary, StepTrace, StepTraceSummary, SubAgentLane, SubStepGroup, SubagentRoster, TASK_COLUMN_ORDER, TRIGGER_LABELS, TaskActivityDialog, TaskComposer, TaskFlow, TaskInbox, TaskMoveDialog, TaskOutputsCell, TaskPlan, TaskRunsDialog, TaskStartDialog, TaskStatusPill, TaskTable, TaskThreadChip, TaskTriggerChip, TasksToolbar, ThreadActivity, ThreadLauncher, ThreadNotifyDialog, ThreadStatusLine, TupleArrayField, UploadTaskItem, UploadTaskList, WEEKDAYS, WORKFLOW_COLUMN_ORDER, WorkflowConfigDialog, WorkflowDocumentsField, WorkflowLauncher, WorkflowRunStatus, WorkflowThreadStartedBy, WorkflowThreadStrip, WorkflowsTable, WorkflowsToolbar, agentConfigSectionToValues, agentCreatorToConfigSection, asTaskStatus, authModeFor, buildRRule, buildTaskRows, buildWorkflowScopeSource, compactThreadActivity, composePersona, composerToTaskQuery, composerToWorkRequest, composerToWorkflowRequest, composerToWorkflowUpdate, createTaskColumns, createWorkflowColumns, createsWork, defaultScopeRenderer, defaultTaskComposerValues, deriveAgentName, deriveWorkflowName, descendantIds, describeRRule, filterConversationRows, firstWords, formatElapsed, goalProgress, groupThreadActivity, hasTaskFields, hasTrigger, humanizeSection, indexTasks, inferType, inputDocumentIds, isAgenticWorkflow, isOutOfBounds, isPlainTodo, isSkillRow, isValidAgentName, isoToLocalInput, linkedRunsFromActivity, localInputToIso, matchWorkflowScope, moveTargets, newThreadToRequest, nextCriterionId, ownerExtId, parseRRule, prettifyKey, resolveScopeInputs, skillSlug, stripPersonaPreamble, summarizeAgent, summarizeCapabilities, taskComposerToCreateRequest, taskComposerToUpdateRequest, taskNeedsAccess, taskToComposerValues, useWorkflowPreview, workflowFromSkillMarkdown, workflowStatus, workflowTaskFields, workflowToComposerValues, workflowToSkillMarkdown, workflowTriggerType, workflowWhen } from '../chunk-RARHNGKM.js';
 import '../chunk-P5ST47VY.js';
 import '../chunk-4XJZ6AAY.js';
 import '../chunk-P6GHJSLR.js';
-export { ActionStepBody, ApprovalEvidence, AssigneeLine, DEFAULT_ASSIGNEE_WORDING, DEFAULT_SCHEMA_FORM_LABELS, DEFAULT_STEP_BAR_LABELS, DEFAULT_TASK_ACTIVITY_LABELS, DEFAULT_WORKFLOW_RUNNER_LABELS, DEFAULT_WORKFLOW_STEP_PARTS_LABELS, EMPTY_WORKFLOW_SCOPE, SKILL_PROMPT_FALLBACK_PLACEHOLDER, SKILL_PROMPT_LABEL, SchemaForm, SendBackControl, TaskActivityTimeline, WorkflowRunner, activeStepId, assigneeName, buildLaunch, canAssign, composeStepPrompt, composeWorkflowPrompt, defaultInputs, dependsOn, fieldToFrontmatter, fillRunText, fillStepInputs, fromPlanAssignee, fromPlanDocumentRef, fromPlanSteps, initialRunInputs, inputsFromContext, isEmptyWorkflowScope, isIncompleteSignal, isPersonAction, isPersonStep, isRunFinished, isSteppedWorkflow, isWorkflowScope, layoutFromPlanSteps, nextAction, orderSteps, promptFieldName, reviewInstructions, runFields, runFieldsOf, runThreadTitle, sendBackTargets, skillToWorkflow, splitDocRef, stepConfigProblems, stepDependencies, stepFields, stepLevels, stepPhase, stepStatesFromActivity, stepWindow, taskActivityHeadline, toPlanAssignee, toPlanDocumentRef, toPlanSteps, upstreamSteps, useWorkflowView, validateInputs, validateStep, validateWorkflowGraph, workflowAccepts, workflowFromFrontmatter, workflowSteps, workflowsAccepting, workflowsForHost } from '../chunk-AY32GGKU.js';
+export { ActionStepBody, ApprovalEvidence, AssigneeLine, DEFAULT_SCHEMA_FORM_LABELS, DEFAULT_STEP_BAR_LABELS, DEFAULT_TASK_ACTIVITY_LABELS, DEFAULT_WORKFLOW_RUNNER_LABELS, DEFAULT_WORKFLOW_STEP_PARTS_LABELS, SchemaForm, SendBackControl, TaskActivityTimeline, WorkflowRunner, activeStepId, fromPlanAssignee, fromPlanDocumentRef, fromPlanSteps, isIncompleteSignal, layoutFromPlanSteps, stepWindow, taskActivityHeadline, toPlanAssignee, toPlanDocumentRef, toPlanSteps, useWorkflowView } from '../chunk-MD7RVFKA.js';
 import '../chunk-XD2M6LIG.js';
 import '../chunk-6S5FLMWG.js';
 import '../chunk-RFXJYIDV.js';
 import '../chunk-5LXQPP2K.js';
 import '../chunk-S7PSMMRG.js';
 import '../chunk-EVUEIBNU.js';
-import '../chunk-AUS3KBHJ.js';
 import '../chunk-NUNKSZKU.js';
 import '../chunk-YU2KUMGE.js';
 import '../chunk-N5YEF3LC.js';
-import '../chunk-HOXKR26S.js';
-import '../chunk-AA3PT6KR.js';
-import '../chunk-SLSBJRWW.js';
 import '../chunk-4WWM3GQ5.js';
 import '../chunk-TX2ZICS7.js';
+import '../chunk-76JDDMSP.js';
+export { DEFAULT_ASSIGNEE_WORDING, DEFAULT_STEP_DOCUMENT_LABELS, DEFAULT_STEP_KIND_LABELS, DEFAULT_STEP_RECORD_LABELS, EMPTY_WORKFLOW_SCOPE, SKILL_PROMPT_FALLBACK_PLACEHOLDER, SKILL_PROMPT_LABEL, STEP_KIND_ICONS, StepDocumentButton, StepDocumentCards, StepRecord, WORKFLOW_STEP_KINDS, assigneeName, buildLaunch, canAssign, composeStepPrompt, composeWorkflowPrompt, defaultInputs, dependsOn, fieldToFrontmatter, fillRunText, fillStepInputs, initialRunInputs, inputsFromContext, isEmptyWorkflowScope, isPersonAction, isPersonStep, isRunFinished, isSteppedWorkflow, isWorkflowScope, nextAction, orderSteps, promptFieldName, reviewInstructions, runFields, runFieldsOf, runThreadTitle, sendBackTargets, skillToWorkflow, splitDocRef, stepConfigProblems, stepDependencies, stepDocuments, stepFields, stepKindOf, stepLevels, stepPhase, stepStatesFromActivity, upstreamSteps, validateInputs, validateStep, validateWorkflowGraph, workflowAccepts, workflowFromFrontmatter, workflowSteps, workflowsAccepting, workflowsForHost } from '../chunk-7HAM7Y5U.js';
+import '../chunk-AA3PT6KR.js';
+import '../chunk-AUS3KBHJ.js';
+import '../chunk-SLSBJRWW.js';
 import '../chunk-NPLYHR2E.js';
 import '../chunk-7F6CBP3Z.js';
-import '../chunk-76JDDMSP.js';
 import '../chunk-OXF2IFXG.js';
 import '../chunk-VUNV25KB.js';
 //# sourceMappingURL=index.js.map

package/dist/agents/tasks/ConversationListView.d.ts

@@ -37,6 +37,8 @@ export interface ConversationListViewProps<T extends ConversationListRow> {
     meetingFilter?: 'include' | 'exclude' | null;
     filterText?: string;
     header?: ReactNode;
+    /** Below the list: the launcher that starts a new thread from here. */
+    footer?: ReactNode;
     showHeader?: boolean;
     formatDate: (iso: string) => string;
     renderThread?: (conversation: T) => ReactNode;
@@ -48,7 +50,6 @@ export interface ConversationListViewProps<T extends ConversationListRow> {
     onOpen: (conversation: T) => void;
     onRename: (conversation: T) => void;
     onDelete: (conversation: T) => void;
-    onToggleShared?: (conversation: T, shared: boolean) => void;
     canEditShared?: boolean;
     isWorkspaceOwner?: boolean;
     selectionActions?: (selected: T[], compact: boolean, clear: () => void) => ReactNode;

package/dist/agents/tasks/ConversationTurnSpeaker.d.ts

@@ -6,11 +6,13 @@ export interface TurnSpeakerProfile {
     parent_ext_id?: string | null;
 }
 /** A last-turn speaker, using only metadata returned with the conversation list. */
-export declare function ConversationTurnSpeaker({ role, actor, currentUserId, colorClass, platformName, platformLogoSrc, }: {
+export declare function ConversationTurnSpeaker({ role, actor, currentUserId, colorClass, platformName, platformLogoSrc, variant, }: {
     role?: string | null;
     actor?: TurnSpeakerProfile | null;
     currentUserId?: string;
     colorClass?: string;
     platformName?: string;
     platformLogoSrc?: string;
+    /** `icon`: the face alone (its name on hover), for a narrow column. */
+    variant?: 'icon' | 'pill';
 }): import("react").JSX.Element;

package/dist/agents/tasks/TaskFlow.d.ts

@@ -1,7 +1,24 @@
 import { type ReactNode } from 'react';
+import type { WorkflowStepPhase } from '../workflows/run';
 export interface TaskFlowItem {
     id: string;
     avatar: ReactNode;
+    /** Who acted (a person's id, `assistant`…): their face shows once however often they acted. */
+    actor?: string;
+    /**
+     * A workflow step's event: drawn in the transcript as that step's chip (its kind's colour and
+     * icon, the phase the event put it in), as the thread's bar draws the step.
+     */
+    stepChip?: {
+        kind: string;
+        phase: WorkflowStepPhase;
+        icon?: ReactNode;
+        /** The document the event produced: opened from beside the chip. */
+        document?: {
+            name: string;
+            onOpen: () => void;
+        };
+    };
     label: string;
     description?: string;
     time: string;

package/dist/agents/tasks/ThreadLauncher.d.ts

@@ -0,0 +1,51 @@
+/**
+ * The threads list's launcher: a composer at the bottom of the list that starts a thread where you
+ * are. Type what you need (@mention people), or pick a saved workflow or a to-do, and press Enter:
+ * the thread starts and joins the list, and the launcher offers to open it — it never takes you
+ * there by itself, so several can be started one after another, as agents are dispatched.
+ */
+import { type MentionCandidate } from '../../chat/mentions';
+import type { TaskStartValues } from './TaskStartDialog';
+export interface ThreadLauncherLabels {
+    placeholder: string;
+    todoPlaceholder: string;
+    withArbi: string;
+    todo: string;
+    source: string;
+    start: string;
+    schedule: string;
+    /** A started thread; `{title}` is replaced. */
+    started: string;
+    open: string;
+    dismiss: string;
+    shared: string;
+    private: string;
+}
+export declare const DEFAULT_THREAD_LAUNCHER_LABELS: ThreadLauncherLabels;
+/** What a start made, as the launcher offers it. */
+export interface ThreadLauncherStarted {
+    id: string;
+    title: string;
+}
+export interface ThreadLauncherProps {
+    workflows: readonly {
+        external_id: string;
+        name: string;
+    }[];
+    /** Who can be @mentioned: the workspace's people. */
+    people?: ReadonlyArray<MentionCandidate>;
+    isPending?: boolean;
+    error?: string | null;
+    /** Replaces the start button's label (e.g. "Look again" while a thread is late). */
+    startLabel?: string;
+    /** Start it; resolves to the thread it made (offered with Open), or nothing. Throws to keep the draft. */
+    onStart: (values: TaskStartValues) => Promise<ThreadLauncherStarted | null | undefined>;
+    /** Start it later: the host's scheduler. */
+    onLater?: (values: TaskStartValues) => void;
+    onOpen: (id: string) => void;
+    /** Focus the field when the launcher appears (the header's New Task brought you here). */
+    autoFocus?: boolean;
+    labels?: Partial<ThreadLauncherLabels>;
+    className?: string;
+}
+export declare function ThreadLauncher({ workflows, people, isPending, error, startLabel, onStart, onLater, onOpen, autoFocus, labels, className, }: ThreadLauncherProps): import("react").JSX.Element;

package/dist/agents/tasks/ThreadStatusLine.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Where a thread stands, in one word and one look for every row of a list — a plain chat, a to-do,
+ * a workflow run — as a list of agents says it: Generating, Needs you, Up next, Ready, To do,
+ * Done, Failed. An icon and the word in the state's colour, then what it is about (the next step).
+ */
+import type { ReactNode } from 'react';
+export type ThreadState = 'generating' | 'needs' | 'next' | 'ready' | 'todo' | 'done' | 'failed' | 'queued' | 'access';
+export interface ThreadStateLabels {
+    generating: string;
+    /** `{name}` is replaced ("you", a person). */
+    needs: string;
+    next: string;
+    ready: string;
+    todo: string;
+    done: string;
+    failed: string;
+    queued: string;
+    access: string;
+}
+export declare const DEFAULT_THREAD_STATE_LABELS: ThreadStateLabels;
+export interface ThreadStatusLineProps {
+    state: ThreadState;
+    /** Who a `needs` state waits for ("you", a name). */
+    name?: string;
+    /** What it is about, after the word (the next step's title). */
+    detail?: string;
+    /** After the word, e.g. a live elapsed time. */
+    extra?: ReactNode;
+    labels?: Partial<ThreadStateLabels>;
+    className?: string;
+    testId?: string;
+}
+export declare function ThreadStatusLine({ state, name, detail, extra, labels, className, testId, }: ThreadStatusLineProps): import("react").JSX.Element;

package/dist/agents/tasks/WorkflowRunStatus.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Where a workflow run is, in a line of a list (the threads list's status), on two lines. First a
+ * track with one segment per step in its kind's colour — filled once done, pulsing while it runs,
+ * outlined while still to come — centred on the step the run is at, with "…" where a long run has
+ * more before or after. Then where it stands, in words, about the NEXT step (what happens now):
+ * Generating, Needs you, Up next, Failed — or Ready once every step is done (Done once a person
+ * marked it so). The thread bar's chips in miniature, so a list of runs reads like a list of agents.
+ */
+import type { WorkflowStep, WorkflowStepState } from '../workflows/types';
+import { type ThreadStateLabels } from './ThreadStatusLine';
+export interface WorkflowRunStatusLabels extends ThreadStateLabels {
+    /** A finished run's detail; `{count}` is replaced. */
+    allDone: string;
+}
+export declare const DEFAULT_WORKFLOW_RUN_STATUS_LABELS: Partial<WorkflowRunStatusLabels>;
+export interface WorkflowRunStatusProps {
+    steps: WorkflowStep[];
+    /** Each step's state (from `stepStatesFromActivity`). */
+    states: Record<string, WorkflowStepState>;
+    /** Who a step is for, in words (`assigneeName`): a person's step "needs" them. */
+    assigneeOf?: (step: WorkflowStep) => string | undefined;
+    labels?: Partial<WorkflowRunStatusLabels>;
+    /** The states are still loading: the track shows the steps only, with no position yet. */
+    isLoading?: boolean;
+    /** The thread's own status (To do / Done), which a person sets: a finished run marked done is Done. */
+    workStatus?: string | null;
+    /** The most steps the track shows; a longer run is trimmed around the step it is at. */
+    maxSegments?: number;
+    className?: string;
+    testId?: string;
+}
+export declare function WorkflowRunStatus({ steps, states, assigneeOf, labels, isLoading, workStatus, maxSegments, className, testId, }: WorkflowRunStatusProps): import("react").JSX.Element;

package/dist/agents/tasks/WorkflowThreadStrip.d.ts

@@ -1,10 +1,12 @@
 /**
- * The top bar of a thread that runs a workflow: where the run is — the previous, current and next
+ * The top bar of a thread that runs a workflow, in the builder canvas's own look (`StepChip`: each
+ * kind of step in its colour, the start as the canvas's start pill): where the run is — the previous, current and next
  * steps by name, the rest behind ‹ › and "…", parallel steps as a "+N" chip, and every running step
  * out of view as "Working: <title>" (`StepBarFrame`, the same model as the runner's stepper) — with
  * everything that actually happened in the thread attached to the step it happened
  * during — the assistant's turns, a draft sent back, people's messages and edits, notifications.
- * What happened before the first step or after the last stays as ordinary entries at either end.
+ * Each step shows who acted during it (their faces, and how many entries); what happened before the
+ * first step sits on the start pill, and what happened after the last on an "After" chip.
  * Linked runs show too: a signal a step raised and the linked thread it started (after the step),
  * and, for a thread a signal started, "Started by <step> in <thread>" (before the steps).
  * A thread without a workflow shows `TaskFlow` instead.
@@ -12,6 +14,8 @@
 import { type ReactNode } from 'react';
 import { type WorkflowStepPhase } from '../workflows/run';
 import { type StepBarLabels } from '../workflows/StepBarFrame';
+import { type WorkflowStepKind } from '../workflows/stepKinds';
+import { type StepDocumentLabels, type StepRecordLabels } from '../workflows/StepDocuments';
 import type { WorkflowStep, WorkflowStepState } from '../workflows/types';
 import type { TaskFlowItem } from './TaskFlow';
 /** An activity entry, with what the strip needs to place it. */
@@ -39,6 +43,8 @@ export declare function groupThreadActivity<T extends {
 export interface WorkflowThreadStripLabels {
     /** The popover heading of a step's entries; `{count}` is replaced. */
     happened: string;
+    /** What the count on a step is; `{count}` is replaced. */
+    updates: string;
     nothingYet: string;
     skip: string;
     /** A linked run's origin; `{step}` and `{thread}` are replaced. */
@@ -51,6 +57,17 @@ export interface WorkflowThreadStripLabels {
     waitingFor: string;
     /** A step the work was sent back to. */
     sentBack: string;
+    /** The start pill: the run began. */
+    started: string;
+    /** The chip of what happened once every step had finished. */
+    after: string;
+    /** The start pill's list, and the "After" chip's. */
+    beforeSteps: string;
+    afterSteps: string;
+    /** Each kind's name, on the step in view. */
+    kinds: Record<WorkflowStepKind, string>;
+    documents: StepDocumentLabels;
+    record: StepRecordLabels;
 }
 export declare const DEFAULT_WORKFLOW_THREAD_STRIP_LABELS: WorkflowThreadStripLabels;
 /** A linked thread a signal started, as the host names it. */
@@ -93,6 +110,15 @@ export interface WorkflowThreadStripProps {
     startedBy?: WorkflowThreadOrigin;
     /** Who a step is for, in words (`assigneeName`): shown on the step while it waits for them. */
     assigneeOf?: (step: WorkflowStep) => string | undefined;
+    /**
+     * The documents: a step's popover leads with the versions it drafted, or for an approval the
+     * versions it approves (`stepDocuments`), named by `nameOfDoc` and opened by `onOpenDocument`.
+     */
+    nameOfDoc?: (id: string) => string | undefined;
+    onOpenDocument?: (ref: string) => void;
+    /** The run's answers (`skill_inputs`) and people's names: a finished step shows what it recorded. */
+    inputs?: Record<string, unknown>;
+    nameOf?: (id: string) => string | undefined;
     labels?: Partial<WorkflowThreadStripLabels>;
     /** The bar's own wording (arrows, "…", "Working: <title>", status words). */
     barLabels?: Partial<StepBarLabels>;
@@ -103,4 +129,4 @@ export declare function WorkflowThreadStartedBy({ origin, labels, }: {
     origin: WorkflowThreadOrigin;
     labels?: Partial<WorkflowThreadStripLabels>;
 }): import("react").JSX.Element;
-export declare function WorkflowThreadStrip({ steps, states, items, renderIcon, onSkip, renderStepAction, signals, startedBy, assigneeOf, labels, barLabels, className, }: WorkflowThreadStripProps): import("react").JSX.Element;
+export declare function WorkflowThreadStrip({ steps, states, items, renderIcon, onSkip, renderStepAction, signals, startedBy, assigneeOf, nameOfDoc, onOpenDocument, inputs, nameOf, labels, barLabels, className, }: WorkflowThreadStripProps): import("react").JSX.Element;

package/dist/agents/tasks/compact-thread-activity.d.ts

@@ -4,5 +4,8 @@ export interface CompactThreadActivity {
     label: string;
     recipients: string[];
 }
-/** Only user-facing actions. Notification batches group by their persisted source message. */
-export declare function compactThreadActivity(events: readonly TaskActivityEvent[]): CompactThreadActivity[];
+/**
+ * Only user-facing actions. Notification batches group by their persisted source message. A step's
+ * events are named after the step (`stepTitleOf`, from the run's plan) when it is known.
+ */
+export declare function compactThreadActivity(events: readonly TaskActivityEvent[], stepTitleOf?: (stepId: string) => string | undefined): CompactThreadActivity[];

package/dist/agents/tasks/index.d.ts

@@ -23,6 +23,9 @@ export { TaskStatusPill, DEFAULT_TASK_STATUS_PILL_LABELS, type TaskStatusPillPro
 export { TaskActivityTimeline, taskActivityHeadline, DEFAULT_TASK_ACTIVITY_LABELS, type TaskActivityEvent, type TaskActivityKind, type TaskActivityLabels, type TaskActivityTimelineProps, } from './TaskActivityTimeline';
 export { TaskActivityDialog, type TaskActivityDialogProps } from './TaskActivityDialog';
 export { TaskFlow, ThreadActivity, type TaskFlowItem } from './TaskFlow';
+export { ThreadLauncher, DEFAULT_THREAD_LAUNCHER_LABELS, type ThreadLauncherProps, type ThreadLauncherLabels, type ThreadLauncherStarted, } from './ThreadLauncher';
+export { ThreadStatusLine, DEFAULT_THREAD_STATE_LABELS, type ThreadState, type ThreadStateLabels, type ThreadStatusLineProps, } from './ThreadStatusLine';
+export { WorkflowRunStatus, DEFAULT_WORKFLOW_RUN_STATUS_LABELS, type WorkflowRunStatusProps, type WorkflowRunStatusLabels, } from './WorkflowRunStatus';
 export { WorkflowThreadStrip, groupThreadActivity, DEFAULT_WORKFLOW_THREAD_STRIP_LABELS, type WorkflowThreadItem, type WorkflowThreadStripProps, type WorkflowThreadStripLabels, type GroupedThreadActivity, WorkflowThreadStartedBy, type WorkflowThreadSignal, type WorkflowThreadOrigin, type WorkflowThreadLinkedRun, } from './WorkflowThreadStrip';
 export { linkedRunsFromActivity, type WorkflowRunLinks, type WorkflowRaisedSignal, type WorkflowRunOrigin, type WorkflowLinkedRunRef, } from './linkedRuns';
 export { compactThreadActivity, type CompactThreadActivity } from './compact-thread-activity';

package/dist/agents/workflows/StepBarFrame.d.ts

@@ -4,14 +4,12 @@
  * step by name (its pill is the host's), a parallel level adds a "+N" chip that lists the group,
  * "…" on either side lists every step, and every running step the window does not show gets a
  * "Working: <title>" pill at the end, every failed one a "Failed: <title>" pill. The bar is a nav landmark; ←/→ (Home/End) move the window.
+ * Steps look as they do on the builder's canvas (`StepChip`): each kind in its own colour, and the
+ * line out of a finished step in that step's colour.
  */
 import { type ReactNode } from 'react';
 import type { WorkflowStepPhase } from './run';
 import { type StepWindow, type StepWindowLevel, type StepWindowStep } from './stepWindow';
-export declare function PhaseMark({ phase, icon }: {
-    phase: WorkflowStepPhase;
-    icon?: ReactNode;
-}): import("react").JSX.Element;
 export interface StepBarLabels {
     nav: string;
     back: string;
@@ -36,9 +34,6 @@ export interface StepBarLabels {
     phases: Record<WorkflowStepPhase, string>;
 }
 export declare const DEFAULT_STEP_BAR_LABELS: StepBarLabels;
-/** A pill's colours: the status shows in the text colour as well as the icon. */
-export declare function stepPillTone(phase: WorkflowStepPhase, current: boolean): string;
-export declare const 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";
 /**
  * A label is the full title, cut with an ellipsis only when very long (in full in `title`) or when
  * the bar is out of room — connectors give up their room first. Its widest is `LABEL_MAX_PX`
@@ -47,11 +42,11 @@ export declare const STEP_PILL = "flex min-w-0 items-center gap-1.5 whitespace-n
 export declare const STEP_LABEL = "min-w-[2.5rem] truncate";
 export declare const STEP_LABEL_MAX = "max-w-[20rem]";
 /**
- * The step in view's label: wider (26rem), the last to give up room (what is around it shrinks a
- * million times harder, so it is not cut while anything else on its pill or the bar can still
- * give), and when it must, it wraps to a second line before it is cut.
+ * The step in view's label: wider (26rem), and the last to give up room (what is around it shrinks
+ * a million times harder, so it is not cut while anything else on its chip or the bar can still
+ * give). Its chip already has two lines (the kind above the name), so it is cut, not wrapped.
  */
-export declare const STEP_LABEL_CURRENT = "min-w-[2.5rem] max-w-[26rem] whitespace-normal text-left text-balance line-clamp-2";
+export declare const STEP_LABEL_CURRENT = "block min-w-[2.5rem] max-w-[26rem] truncate";
 /**
  * What follows a name on its pill ("Waiting for …"): cut before the name is. Flex shares a shortage
  * in proportion, so the factor is huge: even a sliver taken from the name would show an ellipsis.
@@ -70,22 +65,28 @@ export interface StepBarFrameProps<T extends StepBarStep> {
     onSelect: (id: string) => void;
     /** The pill of a level's primary step (a button or a popover trigger). */
     renderStep: (step: T, level: StepWindowLevel<T>, win: StepWindow<T>, narrow: boolean) => ReactNode;
-    /**
-     * What the step in view waits on ("Waiting for …"): on its pill when wide, on a line of its own
-     * when narrow (where the pill has room for its name only).
-     */
-    noteOf?: (id: string) => string | undefined;
     /** What follows a level's pill (signals it raised…). */
     renderAfter?: (level: StepWindowLevel<T>) => ReactNode;
     /** Before the steps / after them: shown while the window is at that end. */
     leading?: ReactNode;
     trailing?: ReactNode;
+    /**
+     * Room the bar needs beyond the levels' names: always (a wider step in view), and for `leading`
+     * and `trailing` while the window reaches that end. A window is only as wide as fits with it.
+     */
+    reservePx?: {
+        always?: number;
+        leading?: number;
+        trailing?: number;
+    };
     /** Steps that cannot be gone to (the completion marker). */
     isSelectable?: (id: string) => boolean;
     icon?: (step: T) => ReactNode;
+    /** A step's kind (`agent`, `review`…), for its colour; none = neutral. */
+    kindOf?: (step: T) => string;
     disabled?: boolean;
     labels?: Partial<StepBarLabels>;
     tid: (suffix: string) => string;
     className?: string;
 }
-export declare function StepBarFrame<T extends StepBarStep>({ levels, phaseOf, current, onSelect, renderStep, noteOf, renderAfter, leading, trailing, isSelectable, icon, disabled, labels, tid, className, }: StepBarFrameProps<T>): import("react").JSX.Element;
+export declare function StepBarFrame<T extends StepBarStep>({ levels, phaseOf, current, onSelect, renderStep, renderAfter, leading, trailing, reservePx, isSelectable, icon, kindOf, disabled, labels, tid, className, }: StepBarFrameProps<T>): import("react").JSX.Element;

package/dist/agents/workflows/StepChip.d.ts

@@ -0,0 +1,37 @@
+/**
+ * A step on a bar — the runner's stepper, a thread's top bar, the threads list — drawn as the
+ * builder's canvas card in miniature (`.wf-chip` in `blocks.css`): its kind's accent and icon, its
+ * phase in the badge (a filled check once done, a spinner while running, an hourglass while it
+ * waits), and, for the step in view, the kind's name and what it waits on above its title, as a
+ * canvas card heads itself. A button, so it can open a popover (`PopoverTrigger asChild`).
+ */
+import { type ButtonHTMLAttributes, type ReactNode } from 'react';
+import type { WorkflowStepPhase } from './run';
+/**
+ * What the badge shows: the kind's icon (filled in once done, as the canvas marks a done card), or
+ * the phase while the step moves or when it went wrong.
+ */
+export declare function StepBadgeMark({ phase, icon }: {
+    phase: WorkflowStepPhase;
+    icon?: ReactNode;
+}): import("react").JSX.Element;
+export interface StepChipProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    /** The kind (`form`, `agent`…, `start`, `adhoc`): its accent. */
+    kind: string;
+    phase: WorkflowStepPhase;
+    /** The kind's icon (or the host's icon for the step). */
+    icon?: ReactNode;
+    label: string;
+    /** The step in view: ringed, and headed with `heading` above its label. */
+    current?: boolean;
+    /** The current chip's top line: the kind's name, and what the step waits on. */
+    heading?: ReactNode;
+    /** The label's classes (how it gives up room on a crowded bar). */
+    labelClassName?: string;
+    labelTestId?: string;
+    /** After the label: who acted in the step, a sent-back mark… */
+    children?: ReactNode;
+    /** A static chip (the completion marker): not a button. */
+    inert?: boolean;
+}
+export declare const StepChip: import("react").ForwardRefExoticComponent<StepChipProps & import("react").RefAttributes<HTMLButtonElement>>;

package/dist/agents/workflows/StepDocuments.d.ts

@@ -0,0 +1,64 @@
+/**
+ * The documents a step is about — what most steps of real work hand on, review and approve is a
+ * document, not a message in the chat. A drafting step's are the versions it produced; an approval's
+ * are the drafts it approves (the versions of the steps it waits for while it is open, exactly the
+ * versions it recorded once approved). `StepDocumentCards` shows them as cards to open, and
+ * `StepRecord` what a finished step recorded: who did it, when, and its answers.
+ */
+import type { WorkflowField, WorkflowStep, WorkflowStepState } from './types';
+/** The document versions (`doc-…@v<n>`) a step is about, newest last, each once. */
+export declare function stepDocuments(steps: WorkflowStep[], states: Record<string, WorkflowStepState>, id: string): string[];
+export interface StepDocumentLabels {
+    open: string;
+    /** An approval's documents, before it is done. */
+    toApprove: string;
+    approved: string;
+    produced: string;
+    /** `{version}` is replaced. */
+    version: string;
+}
+export declare const DEFAULT_STEP_DOCUMENT_LABELS: StepDocumentLabels;
+/** A step's documents as cards: the name, the version, and Open (the host's viewer or editor). */
+export declare function StepDocumentCards({ refs, heading, nameOfDoc, onOpen, labels, testId, }: {
+    refs: string[];
+    heading: string;
+    nameOfDoc?: (id: string) => string | undefined;
+    onOpen?: (ref: string) => void;
+    labels?: Partial<StepDocumentLabels>;
+    testId: string;
+}): import("react").JSX.Element | null;
+export interface StepRecordLabels {
+    /** `{name}` is replaced. */
+    doneBy: string;
+    approvedBy: string;
+    someone: string;
+}
+export declare const DEFAULT_STEP_RECORD_LABELS: StepRecordLabels;
+/** A recorded time, in the reader's locale. */
+export declare const formatDate: (iso: string | undefined) => string;
+/** A recorded answer as text: a person's name, an option's label, a tick… */
+export declare const shownValue: (v: unknown, field: WorkflowField, nameOf?: (id: string) => string | undefined) => string;
+/** What a finished step recorded: who did it (approved it) and when, and the answers it took. */
+export declare function StepRecord({ step, state, inputs, nameOf, labels, className, testId, }: {
+    step: WorkflowStep;
+    state: WorkflowStepState | undefined;
+    inputs: Record<string, unknown>;
+    nameOf?: (id: string) => string | undefined;
+    labels?: Partial<StepRecordLabels>;
+    className?: string;
+    testId: string;
+}): import("react").JSX.Element | null;
+/**
+ * A step's document, one click from its chip: a button joined to the chip's right that opens the
+ * latest version — the drafted letter, or the draft an approval is for. Icon-only where room is
+ * short (the thread's bar), with the document's name in the chat.
+ */
+export declare function StepDocumentButton({ kind, name, onOpen, showName, label, testId, }: {
+    kind: string;
+    name: string;
+    onOpen: () => void;
+    showName?: boolean;
+    /** Its accessible name; `{name}` is replaced. */
+    label?: string;
+    testId?: string;
+}): import("react").JSX.Element;

package/dist/agents/workflows/WorkflowStepBar.d.ts

@@ -7,8 +7,7 @@
 import type { ReactNode } from 'react';
 import type { WorkflowRunView } from './useWorkflowView';
 import type { WorkflowStep } from './types';
-import { PhaseMark, type StepBarLabels } from './StepBarFrame';
-export { PhaseMark };
+import { type StepBarLabels } from './StepBarFrame';
 export interface WorkflowStepBarProps {
     run: WorkflowRunView;
     levels: WorkflowStep[][];

package/dist/agents/workflows/index.d.ts

@@ -15,4 +15,6 @@ export { useWorkflowPreview, type UseWorkflowPreviewOptions } from './useWorkflo
 export { WorkflowRunner, DEFAULT_WORKFLOW_RUNNER_LABELS, type WorkflowRunnerProps, type WorkflowRunnerLabels, type WorkflowRunnerFile, } from './WorkflowRunner';
 export { stepWindow, activeStepId, type StepWindow, type StepWindowLevel, type StepWindowOptions, type StepWindowStep, } from './stepWindow';
 export { DEFAULT_STEP_BAR_LABELS, type StepBarLabels } from './StepBarFrame';
+export { stepDocuments, StepDocumentCards, StepDocumentButton, StepRecord, DEFAULT_STEP_DOCUMENT_LABELS, DEFAULT_STEP_RECORD_LABELS, type StepDocumentLabels, type StepRecordLabels, } from './StepDocuments';
+export { WORKFLOW_STEP_KINDS, STEP_KIND_ICONS, DEFAULT_STEP_KIND_LABELS, stepKindOf, type WorkflowStepKind, } from './stepKinds';
 export { ActionStepBody, ApprovalEvidence, AssigneeLine, SendBackControl, DEFAULT_WORKFLOW_STEP_PARTS_LABELS, type WorkflowRunnerActions, type WorkflowStepPartsLabels, } from './StepParts';

package/dist/agents/workflows/stepKinds.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The kinds of step, as every view of a workflow shows them: the builder's canvas, the runner's
+ * stepper, a thread's top bar and the threads list. Each kind has one icon here and one colour in
+ * `blocks.css` (`.wf-kind-<kind>`, on the `--wf-*` variables), so a step looks the same wherever
+ * it appears.
+ */
+import type { WorkflowStep } from './types';
+/** Each kind of step, with each platform action (an `action` step) as a kind of its own. */
+export type WorkflowStepKind = 'form' | 'upload' | 'agent' | 'review' | 'sign' | 'email_draft' | 'tabular_review';
+/** Every kind, in the order the add menus list them. */
+export declare const WORKFLOW_STEP_KINDS: readonly WorkflowStepKind[];
+/** A step's kind: an action step is its action's type. */
+export declare const stepKindOf: (step: WorkflowStep) => WorkflowStepKind;
+export declare const STEP_KIND_ICONS: {
+    readonly form: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly upload: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly agent: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly review: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly sign: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly email_draft: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly tabular_review: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+};
+/** Each kind's name, as the canvas cards and the thread bar label a step. */
+export declare const DEFAULT_STEP_KIND_LABELS: Record<WorkflowStepKind, string>;

package/dist/artifacts/VersionTimeline.d.ts

@@ -12,6 +12,8 @@ export interface VersionTimelineLabels {
     reasons: Record<string, string>;
     open: string;
     compare: string;
+    /** Before the thread a version was made in: "in {thread}". */
+    madeIn: string;
 }
 export declare const DEFAULT_VERSION_TIMELINE_LABELS: VersionTimelineLabels;
 export interface VersionTimelineTestIds {
@@ -36,6 +38,11 @@ export interface VersionEntry {
     savedFromId?: string | null;
     /** Why the version exists: upload | edit | signed | sync. Shown as a label on the row. */
     reason?: string | null;
+    /** The thread whose turn made this version: named on the row, opening it at that turn. */
+    madeIn?: {
+        label: string;
+        onOpen: () => void;
+    } | null;
 }
 export interface VersionTimelineProps {
     /** Versions in creation order (oldest first). */