@arbidocs/blocks 0.4.15 → 0.4.17

package/dist/agents/index.js

@@ -1,11 +1,13 @@
 "use client";
-export { ACTION_LABELS, 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, 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_LIVE_RUNS_BANNER_LABELS, DEFAULT_RECURRENCE, DEFAULT_RECURRENCE_BUILDER_LABELS, DEFAULT_SCHEMA_FORM_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_COLUMN_LABELS, DEFAULT_TASK_COMPOSER_LABELS, DEFAULT_TASK_PLAN_LABELS, DEFAULT_TASK_ROW_ACTIONS_LABELS, DEFAULT_TASK_RUNS_DIALOG_LABELS, DEFAULT_TUPLE_ARRAY_FIELD_LABELS, DEFAULT_UPLOAD_TASK_ITEM_LABELS, DEFAULT_UPLOAD_TASK_LIST_LABELS, DEFAULT_WORKFLOW_CONFIG_DIALOG_LABELS, EMPTY_WORKFLOW_SCOPE, GoalCriteria, LiveRunsBanner, NewTaskEmptyAction, RecurrenceBuilder, SKILL_PROMPT_FALLBACK_PLACEHOLDER, SKILL_PROMPT_LABEL, STATUS_LABELS, SchemaForm, SkillActionButton, SkillCard, SkillDetail, SkillDetailSection, SkillEditForm, SkillFilterChips, SkillGenerateForm, SkillGlobalBadge, SkillRow, SkillTile, SkillTypeBadge, SkillViewToggle, StepDetail, StepNarration, StepOutcome, StepParams, StepRow, StepSummary, StepTrace, StepTraceSummary, SubAgentLane, SubStepGroup, SubagentRoster, TRIGGER_LABELS, TaskComposer, TaskPlan, TaskRowActions, TaskRunsDialog, TasksBulkBar, TasksToolbar, TupleArrayField, UploadTaskItem, UploadTaskList, WEEKDAYS, WorkflowConfigDialog, WorkflowLauncher, agentConfigSectionToValues, agentCreatorToConfigSection, authModeFor, buildLaunch, buildRRule, composePersona, composeWorkflowPrompt, createTaskColumns, defaultInputs, defaultTaskComposerValues, deriveAgentName, describeRRule, formatElapsed, goalProgress, humanizeSection, inferType, inputsFromContext, isAgenticWorkflow, isEmptyWorkflowScope, isOutOfBounds, isValidAgentName, isWorkflowScope, isoToLocalInput, localInputToIso, nextCriterionId, parseRRule, prettifyKey, promptFieldName, skillToWorkflow, statusBadgeVariant, stripPersonaPreamble, summarizeAgent, summarizeCapabilities, taskComposerToCreateRequest, taskComposerToUpdateRequest, taskNeedsAccess, taskToComposerValues, validateInputs, workflowAccepts, workflowFromFrontmatter, workflowTaskFields, workflowsAccepting, workflowsForHost } from '../chunk-CVFBSUXL.js';
-import '../chunk-NUNKSZKU.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, 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_SCHEMA_FORM_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_ACTIVITY_LABELS, DEFAULT_TASK_COMPOSER_LABELS, DEFAULT_TASK_LIST_LABELS, DEFAULT_TASK_OUTPUTS_CELL_LABELS, DEFAULT_TASK_PLAN_LABELS, DEFAULT_TASK_REVIEW_ACTIONS_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, DERIVED_NAME_WORDS, EMPTY_NEW_THREAD, EMPTY_WORKFLOW_SCOPE, GoalCriteria, MAX_TASK_DEPTH, NewThreadDialog, PersonPill, PillSelect, RecurrenceBuilder, SKILL_PROMPT_FALLBACK_PLACEHOLDER, SKILL_PROMPT_LABEL, STATUS_LABELS, STATUS_ORDER, STATUS_TONE, SchemaForm, 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, TaskActivityTimeline, TaskComposer, TaskMoveDialog, TaskOutputsCell, TaskPlan, TaskReviewActions, TaskRunsDialog, TaskStatusPill, TaskTable, TaskThreadChip, TaskTriggerChip, TasksToolbar, TupleArrayField, UploadTaskItem, UploadTaskList, WEEKDAYS, WORKFLOW_COLUMN_ORDER, WorkflowConfigDialog, WorkflowLauncher, WorkflowsTable, WorkflowsToolbar, agentConfigSectionToValues, agentCreatorToConfigSection, asTaskStatus, authModeFor, buildLaunch, buildRRule, buildTaskRows, composePersona, composeWorkflowPrompt, composerToTaskQuery, composerToWorkRequest, composerToWorkflowRequest, composerToWorkflowUpdate, createTaskColumns, createWorkflowColumns, createsWork, defaultInputs, defaultScopeRenderer, defaultTaskComposerValues, deriveAgentName, deriveWorkflowName, descendantIds, describeRRule, firstWords, formatElapsed, goalProgress, hasTaskFields, hasTrigger, humanizeSection, indexTasks, inferType, inputDocumentIds, inputsFromContext, isAgenticWorkflow, isEmptyWorkflowScope, isOutOfBounds, isPlainTodo, isSkillRow, isValidAgentName, isWorkflowScope, isoToLocalInput, localInputToIso, moveTargets, newThreadToRequest, nextCriterionId, ownerExtId, parseRRule, prettifyKey, promptFieldName, resolveScopeInputs, skillToWorkflow, stripPersonaPreamble, summarizeAgent, summarizeCapabilities, taskComposerToCreateRequest, taskComposerToUpdateRequest, taskNeedsAccess, taskToComposerValues, validateInputs, workflowAccepts, workflowFromFrontmatter, workflowStatus, workflowTaskFields, workflowToComposerValues, workflowTriggerType, workflowWhen, workflowsAccepting, workflowsForHost } from '../chunk-OMF7444S.js';
+import '../chunk-NUPVHEJW.js';
 import '../chunk-NJL4LIXX.js';
 import '../chunk-CQCC7LE7.js';
 import '../chunk-UBNVIIBT.js';
+import '../chunk-DPLRHEJZ.js';
 import '../chunk-P6GHJSLR.js';
 import '../chunk-S7PSMMRG.js';
+import '../chunk-SLSBJRWW.js';
 import '../chunk-76JDDMSP.js';
 import '../chunk-CPMNAJLF.js';
 import '../chunk-NPLYHR2E.js';

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

@@ -0,0 +1,32 @@
+export interface DueDateMenuLabels {
+    today: string;
+    tomorrow: string;
+    nextMonday: string;
+    inAWeek: string;
+    pick: string;
+    clear: string;
+}
+export declare const DEFAULT_DUE_DATE_MENU_LABELS: DueDateMenuLabels;
+/** A date as the `datetime-local` value the form holds: "2026-10-12T17:00" (local time). */
+export declare function toLocalInput(date: Date): string;
+export interface DuePreset {
+    id: 'today' | 'tomorrow' | 'nextMonday' | 'inAWeek';
+    value: string;
+}
+/**
+ * The quick choices, each at the end of the working day. "Today" is left out once that time has passed.
+ * `now` is a parameter so the choices are testable.
+ */
+export declare function duePresets(now?: Date): DuePreset[];
+interface DueDateMenuProps {
+    value: string;
+    onChange: (value: string) => void;
+    /** Keys the input's id and test ids. */
+    id: string;
+    /** The accessible name of the date input. */
+    label: string;
+    labels?: Partial<DueDateMenuLabels>;
+}
+/** The body of a due-date popover: quick choices first, the exact date and time for the rest. */
+export declare function DueDateMenu({ value, onChange, id, label, labels }: DueDateMenuProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,53 @@
+import type { PersonOption, TaskOption } from './taskComposerTypes';
+import { type NewThreadValues } from './taskRequest';
+export interface NewThreadDialogLabels {
+    title: string;
+    description: string;
+    promptLabel: string;
+    promptPlaceholder: string;
+    titleLabel: string;
+    titlePlaceholder: string;
+    visibility: string;
+    taskDetails: string;
+    /** Under the prompt: which files the assistant can use. */
+    files: (count: number) => string;
+    taskDetailsHint: string;
+    owner: string;
+    ownerMe: string;
+    due: string;
+    dueNone: string;
+    dueClear: string;
+    parentTask: string;
+    parentTaskNone: string;
+    search: string;
+    empty: string;
+    cancel: string;
+    createTask: string;
+    /** The switch under the prompt, and the button when it is off. */
+    assistantStart: string;
+    assistantStartHint: string;
+    addTodo: string;
+    saving: string;
+}
+export declare const DEFAULT_NEW_THREAD_DIALOG_LABELS: NewThreadDialogLabels;
+export interface NewThreadDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** People who can have the next step (humans who can edit the workspace). Omit to hide the field. */
+    people?: PersonOption[];
+    /** Tasks this can be a sub-task of. Omit or leave empty to hide the field. */
+    tasks?: TaskOption[];
+    initialValues?: Partial<NewThreadValues>;
+    /** How many files the assistant will be able to use; omit to say nothing. */
+    fileCount?: number;
+    isPending?: boolean;
+    onSubmit: (values: NewThreadValues) => void;
+    labels?: Partial<NewThreadDialogLabels>;
+    testId?: string;
+}
+/**
+ * "New task": the one way to start something. Type the prompt (what to ask or get done) and who sees it (the
+ * workspace, by default); the title is made from the prompt. Every ask is a task: the details (owner, due
+ * date, parent, a title of your own) are optional and folded away.
+ */
+export declare function NewThreadDialog({ open, onOpenChange, people, tasks, initialValues, fileCount, isPending, onSubmit, labels, testId, }: NewThreadDialogProps): import("react").JSX.Element;

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

@@ -0,0 +1,22 @@
+/** A person (or agent) as the table shows them. */
+export interface TaskPerson {
+    /** The user's external id; absent when the person is not known (the pill then reads as their label). */
+    id?: string | null;
+    label: string;
+    /** The viewer: shown as "You" by the host's pill, and as the label here. */
+    isMe?: boolean;
+    isAgent?: boolean;
+}
+export interface PersonPillProps {
+    person: TaskPerson;
+    size?: 'xs' | 'sm' | 'md' | 'lg';
+    testId?: string;
+}
+/**
+ * A person as the app's own user pill: the same avatar, initials and tint as everywhere else. This is
+ * the default; a host that knows more (presence, a direct-message click, the rich tooltip) hands the
+ * table its own `renderPerson` instead.
+ */
+export declare function PersonPill({ person, size, testId }: PersonPillProps): import("react").JSX.Element;
+/** Just the avatar: the same user avatar and tint, for lists and pills that carry their own name. */
+export declare function PersonAvatar({ person, size }: PersonPillProps): import("react").JSX.Element;

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

@@ -0,0 +1,39 @@
+import { type ReactNode } from 'react';
+export interface PillOption {
+    id: string;
+    label: string;
+    /** Small line after the label in the list (e.g. a role). */
+    description?: string;
+    /** Glyph before the label in the list and, when chosen, on the pill. */
+    icon?: ReactNode;
+}
+export interface PillSelectLabels {
+    /** The search box placeholder. */
+    search: string;
+    /** Shown when the search matches nothing. */
+    empty: string;
+}
+export declare const DEFAULT_PILL_SELECT_LABELS: PillSelectLabels;
+export interface PillSelectProps {
+    /** The pill's glyph when nothing (or an option without its own icon) is chosen. */
+    icon: ReactNode;
+    /** Names the property on the pill: "Sign-off: Me". */
+    prefix: string;
+    /** The chosen option id; `''` is the "none" entry when `noneOption` is set. */
+    value: string;
+    options: PillOption[];
+    onChange: (id: string) => void;
+    /** Adds an entry that clears the choice (id `''`), e.g. "Me" or "Nothing". */
+    noneOption?: PillOption;
+    /** Show a search box (for long lists such as people or tasks). */
+    searchable?: boolean;
+    disabled?: boolean;
+    testId?: string;
+    labels?: Partial<PillSelectLabels>;
+    className?: string;
+}
+/**
+ * A property as a pill that opens a list, like every other entity reference in the app: the pill shows
+ * `Prefix: choice`, the popover lists the options (searchable when long), one is chosen and it closes.
+ */
+export declare function PillSelect({ icon, prefix, value, options, onChange, noneOption, searchable, disabled, testId, labels, className, }: PillSelectProps): import("react").JSX.Element;

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

@@ -0,0 +1,14 @@
+import { type TaskActivityEvent, type TaskActivityLabels, type TaskActivityTimelineProps } from './TaskActivityTimeline';
+export interface TaskActivityDialogProps extends Omit<TaskActivityTimelineProps, 'events' | 'labels' | 'testId'> {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** The task's name, shown under the title. */
+    taskName: string;
+    events: readonly TaskActivityEvent[] | undefined;
+    isLoading?: boolean;
+    isError?: boolean;
+    labels?: Partial<TaskActivityLabels>;
+    testId?: string;
+}
+/** The task's history in a dialog: newest at the bottom, scrolled into view as events arrive. */
+export declare function TaskActivityDialog({ open, onOpenChange, taskName, events, isLoading, isError, labels, testId, ...timeline }: TaskActivityDialogProps): import("react").JSX.Element;

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

@@ -0,0 +1,54 @@
+import type { ReactNode } from 'react';
+export type TaskActivityKind = 'created' | 'run_started' | 'awaiting_access' | 'access_granted' | 'ready_for_review' | 'handed_off' | 'changes_requested' | 'done' | 'reopened' | 'failed';
+/** One event of a task's history, as the backend returns it (oldest first). */
+export interface TaskActivityEvent {
+    external_id: string;
+    kind: TaskActivityKind;
+    actor_ext_id?: string | null;
+    to_ext_id?: string | null;
+    /** The feedback of a send-back, the message of a hand-off. */
+    note?: string | null;
+    /** `run_id`, `agent_ext_id`, `as_user`, `from_workflow`, `error`. */
+    detail?: Record<string, unknown> | null;
+    created_at: string;
+}
+export interface TaskActivityLabels {
+    title: string;
+    empty: string;
+    loading: string;
+    error: string;
+    close: string;
+    created: string;
+    createdFromWorkflow: string;
+    runStarted: string;
+    runStartedBy: (agentName: string) => string;
+    awaitingAccess: string;
+    accessGranted: string;
+    readyForReview: string;
+    handedOff: string;
+    changesRequested: string;
+    done: string;
+    reopened: string;
+    failed: string;
+    handedOverNote: (note: string) => string;
+    sentBackNote: (note: string) => string;
+    failureLine: (error: string) => string;
+    /** The actor is not known (a system step). */
+    system: string;
+}
+export declare const DEFAULT_TASK_ACTIVITY_LABELS: TaskActivityLabels;
+export interface TaskActivityTimelineProps {
+    events: readonly TaskActivityEvent[];
+    /** Draw a person (an id, or none for a system step). */
+    renderPerson: (id: string | null | undefined) => ReactNode;
+    /** An agent's display name by id. */
+    agentName?: (agentExtId: string) => string | undefined;
+    /** "2 min ago". */
+    formatRelative: (iso: string) => string;
+    /** The exact time, shown on hover. */
+    formatExact: (iso: string) => string;
+    labels?: Partial<TaskActivityLabels>;
+    testId?: string;
+}
+/** A task's history as a vertical timeline, oldest first, one entry per event. */
+export declare function TaskActivityTimeline({ events, renderPerson, agentName, formatRelative, formatExact, labels, testId, }: TaskActivityTimelineProps): import("react").JSX.Element;

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

@@ -1,108 +1,8 @@
-import { type ReactNode } from 'react';
-import { type AgentOption, type AgentSelectLabels } from '../workflows/AgentSelect';
-import { type SchemaFormLabels } from '../workflows/SchemaForm';
-import type { WorkflowDefinition, WorkflowInputs } from '../workflows/types';
-import { type RecurrenceBuilderProps } from './RecurrenceBuilder';
-/** When the task runs. `now` is on demand; the rest are scheduled. */
-export type TaskWhen = 'now' | 'once' | 'repeat' | 'event';
-export type TaskAccessMode = 'ask_each_run' | 'standing';
-/** Everything the composer collects. The host maps it onto its API. */
-export interface TaskComposerValues {
-    workflowId: string;
-    inputs: WorkflowInputs;
-    when: TaskWhen;
-    /** datetime-local value (`once`). */
-    runAt: string;
-    rrule: string;
-    timezone: string;
-    eventKind: string;
-    /** `''` = the user's own assistant. */
-    agentId: string;
-    /** Empty = derived from the workflow title by the host. */
-    name: string;
-    notifyOnComplete: boolean;
-    /** Draft the plan first and let the user approve it before anything is created. */
-    reviewPlan: boolean;
-    /** Only asked for scheduled tasks, folded under More options. */
-    access: TaskAccessMode;
-}
-export interface TaskComposerLabels {
-    titleNew: string;
-    titleEdit: string;
-    description: string;
-    what: string;
-    whatHint: string;
-    whatPlaceholder: string;
-    when: string;
-    whenOptions: Record<TaskWhen, string>;
-    runAt: string;
-    event: string;
-    eventPlaceholder: string;
-    eventHint: ReactNode;
-    who: string;
-    more: string;
-    goalAndPlan: string;
-    reviewPlan: string;
-    reviewPlanHint: string;
-    outputs: string;
-    outputChat: string;
-    outputChatHint: string;
-    outputArtifacts: string;
-    outputFileMetadata: string;
-    tools: string;
-    toolsFromAgent: string;
-    notSupportedYet: string;
-    name: string;
-    namePlaceholder: string;
-    timezone: string;
-    notify: string;
-    notifyHint: string;
-    access: string;
-    accessOptions: Record<TaskAccessMode, {
-        label: string;
-        hint: string;
-    }>;
-    accessNow: string;
-    lockedAfterCreation: string;
-    cancel: string;
-    runNow: string;
-    schedule: string;
-    save: string;
-    saving: string;
-}
-export declare const DEFAULT_TASK_COMPOSER_LABELS: TaskComposerLabels;
-export interface TaskComposerProps {
-    open: boolean;
-    onOpenChange: (open: boolean) => void;
-    /** Editing an existing task: the schedule kind and the agent are fixed. */
-    isEdit?: boolean;
-    /** Workflows a task can run. The host includes its "my own instruction" entry. */
-    workflows: WorkflowDefinition[];
-    agents: AgentOption[];
-    /** Controlled values; omit to let the composer hold them (seeded by `initialValues`). */
-    values?: TaskComposerValues;
-    initialValues?: Partial<TaskComposerValues>;
-    onValuesChange?: (values: TaskComposerValues) => void;
-    timezones?: string[];
-    /** The goal and success-criteria editor, in its own folded section. Omit when not applicable. */
-    goal?: ReactNode | ((values: TaskComposerValues) => ReactNode);
-    /** What "always allowed" means for this agent (e.g. the workspaces it will hold standing access to). */
-    standingAccess?: ReactNode | ((values: TaskComposerValues) => ReactNode);
-    /** Offer the "show me the plan first" switch (needs a host that can draft a plan). */
-    canReviewPlan?: boolean;
-    isPending?: boolean;
-    onSubmit: (values: TaskComposerValues) => void;
-    /** The task's workflow input forms: `renderIcon` maps a field option's icon key. */
-    renderIcon?: (key: string) => ReactNode;
-    labels?: Partial<TaskComposerLabels>;
-    formLabels?: Partial<SchemaFormLabels>;
-    agentLabels?: Partial<AgentSelectLabels>;
-    recurrence?: Pick<RecurrenceBuilderProps, 'testIds' | 'labels'>;
-    testId?: string;
-}
-export declare function defaultTaskComposerValues(workflows: WorkflowDefinition[], initial?: Partial<TaskComposerValues>): TaskComposerValues;
+import { type TaskComposerProps } from './taskComposerTypes';
+export * from './taskComposerTypes';
 /**
- * One dialog to create or schedule a task: pick a workflow, fill its form, say when, say who.
- * Name, notification, access mode and the goal checklist live folded under More options.
+ * The dialog behind "New task" (a title, with the assistant optional) and, with `kind="workflow"`, the
+ * workflow dialog (see {@link WorkflowComposer}: what, when and who up front, the rest under More
+ * options).
  */
-export declare function TaskComposer({ open, onOpenChange, isEdit, workflows, agents, values: valuesProp, initialValues, onValuesChange, timezones, goal, canReviewPlan, standingAccess, isPending, onSubmit, renderIcon, labels, formLabels, agentLabels, recurrence, testId, }: TaskComposerProps): import("react").JSX.Element;
+export declare function TaskComposer(props: TaskComposerProps): import("react").JSX.Element;

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

@@ -0,0 +1,25 @@
+export interface TaskMoveOption {
+    id: string;
+    label: string;
+}
+export interface TaskMoveDialogLabels {
+    title: string;
+    none: string;
+    search: string;
+    empty: string;
+    cancel: string;
+}
+export interface TaskMoveDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** Where the task can go (the host excludes the task itself and its descendants). */
+    options: TaskMoveOption[];
+    /** The task's current parent, marked in the list. */
+    currentParentId?: string | null;
+    /** `null` moves the task to the top level. */
+    onPick: (parentId: string | null) => void;
+    labels: TaskMoveDialogLabels;
+    testId?: string;
+}
+/** A parent picker: choose the task another task becomes a sub-task of, or the top level. */
+export declare function TaskMoveDialog({ open, onOpenChange, options, currentParentId, onPick, labels, testId, }: TaskMoveDialogProps): import("react").JSX.Element;

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

@@ -0,0 +1,23 @@
+/** A document a task produced, as the Outputs cell needs it. */
+export interface TaskOutput {
+    id: string;
+    name: string;
+}
+export interface TaskOutputsCellLabels {
+    none: string;
+    /** Menu trigger's accessible name. */
+    open: (count: number) => string;
+    /** "+2" next to the first file name. */
+    more: (count: number) => string;
+}
+export declare const DEFAULT_TASK_OUTPUTS_CELL_LABELS: TaskOutputsCellLabels;
+export interface TaskOutputsCellProps {
+    /** Task id: keys the test ids (`task-outputs-{id}`, `task-output-{id}-{docId}`). */
+    id: string;
+    outputs?: readonly TaskOutput[];
+    onOpen: (documentId: string) => void;
+    testId?: string;
+    labels?: Partial<TaskOutputsCellLabels>;
+}
+/** The documents a task generated: the first file name and a count, with a menu that opens each. */
+export declare function TaskOutputsCell({ id, outputs, onOpen, testId, labels }: TaskOutputsCellProps): import("react").JSX.Element;

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

@@ -30,7 +30,7 @@ export interface TaskPlanLabels {
     add: string;
     noCriteria: string;
     criterionPlaceholder: string;
-    removeCriterion: (id: string) => string;
+    removeCriterion: (n: number) => string;
     retryBudget: string;
     /** e.g. "up to 3 passes". */
     passes: (count: number) => string;
@@ -66,6 +66,8 @@ export interface TaskPlanProps<P extends TaskPlanView> {
     workspaceName: string | null;
     /** The objective the planner drafts from (the task's prompt). */
     objective: string;
+    /** Document id → file name, so the plan shows names instead of ids. */
+    documentNames?: Record<string, string>;
     testIds?: Partial<TaskPlanTestIds>;
     labels?: Partial<TaskPlanLabels>;
 }
@@ -75,4 +77,4 @@ export declare function nextCriterionId(criteria: TaskPlanCriterionView[]): stri
  * Goal-plan editor: empty-state pitch with a single Generate action, or (with a plan) goal,
  * acceptance checklist, retry budget and working documents.
  */
-export declare function TaskPlan<P extends TaskPlanView>({ plan, onChange, onGenerate, isGenerating, workspaceName, objective, testIds, labels, }: TaskPlanProps<P>): import("react").JSX.Element;
+export declare function TaskPlan<P extends TaskPlanView>({ plan, onChange, onGenerate, isGenerating, workspaceName, objective, documentNames, testIds, labels, }: TaskPlanProps<P>): import("react").JSX.Element;

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

@@ -0,0 +1,44 @@
+export interface TaskReviewActionsLabels {
+    approve: string;
+    requestChanges: string;
+    feedbackLabel: string;
+    feedbackPlaceholder: string;
+    send: string;
+    cancel: string;
+    askApproval: string;
+    askApprovalPerson: string;
+    askApprovalSearch: string;
+    askApprovalEmpty: string;
+    askApprovalNote: string;
+    askApprovalSend: string;
+}
+export declare const DEFAULT_TASK_REVIEW_ACTIONS_LABELS: TaskReviewActionsLabels;
+export interface TaskReviewActionsProps {
+    /** Task id: keys the test ids (`task-approve-{id}`, ...). */
+    id: string;
+    /** Disables both actions while a request is in flight. */
+    busy?: boolean;
+    /** Hide "Request changes" for work no agent can revise (a plain reminder). */
+    canRequestChanges?: boolean;
+    onApprove: () => void;
+    onRequestChanges: (feedback: string) => void;
+    /** Hand sign-off to someone else: they are notified and become the person who can approve. */
+    onRequestApproval?: (userId: string, note: string) => void;
+    /** People who can be asked (humans only). The action shows only when there is someone to ask. */
+    people?: {
+        id: string;
+        label: string;
+    }[];
+    /** Icon-only secondary buttons (for a table cell); they keep their accessible names. */
+    compact?: boolean;
+    /** Whether the viewer is the one who can approve (the sign-off person). Without it Approve is not offered. */
+    canApprove?: boolean;
+    /** Approve as an outline button, for a list where every row has one; the default is the one filled button. */
+    quiet?: boolean;
+    labels?: Partial<TaskReviewActionsLabels>;
+}
+/**
+ * The human half of the workflow: accept prepared work (Approve closes the task), or send it back
+ * with feedback so the agent revises it in the task's own thread.
+ */
+export declare function TaskReviewActions({ id, busy, canRequestChanges, onApprove, onRequestChanges, onRequestApproval, people, compact, quiet, canApprove, labels, }: TaskReviewActionsProps): import("react").JSX.Element;

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

@@ -0,0 +1,28 @@
+import { type TaskListRow } from './taskRows';
+import type { TaskStatusKey } from './taskLabels';
+import type { TaskListLabels } from './taskTableLabels';
+export interface TaskRowMenuProps {
+    task: TaskListRow;
+    status: TaskStatusKey;
+    busy: boolean;
+    /** The viewer owns the task: only they delete it, grant its agent access, or change who sees it. */
+    isOwner: boolean;
+    /** The viewer may change who sees it and delete it: its creator, or an owner of the workspace. */
+    canAdmin: boolean;
+    /** The viewer can edit it: its owner, or an editor of the workspace a shared task sits in. */
+    canEdit: boolean;
+    labels: TaskListLabels;
+    onMarkDone: () => void;
+    onReopen: () => void;
+    onAddSubtask?: () => void;
+    onEdit: () => void;
+    onDelete: () => void;
+    onMoveTo?: () => void;
+    /** Hand the task to someone else (who then has the next step). Tasks only. */
+    onChangeOwner?: () => void;
+    /** Open the task's activity timeline. */
+    onOpenActivity?: () => void;
+    /** Present only when a run is waiting for access. */
+    onGrantAccess?: () => void;
+}
+export declare function TaskRowMenu({ task, status, busy, isOwner, canAdmin, canEdit, labels, onMarkDone, onReopen, onAddSubtask, onEdit, onDelete, onMoveTo, onChangeOwner, onOpenActivity, onGrantAccess, }: TaskRowMenuProps): import("react").JSX.Element;

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

@@ -0,0 +1,24 @@
+export interface TaskStatusPillLabels {
+    waitingForAccess: string;
+    lastRunFailed: string;
+    /** The visible word beside the status when the last run failed. */
+    failed: string;
+}
+export declare const DEFAULT_TASK_STATUS_PILL_LABELS: TaskStatusPillLabels;
+export interface TaskStatusPillProps {
+    /** Task id: keys the test id (`task-status-{id}`). */
+    id: string;
+    status: string | null | undefined;
+    /** When the in-flight run started (ISO); a generating pill shows a live elapsed time. */
+    runStartedAt?: string | null;
+    /** The last run's error, shown as a danger dot with the message on hover. */
+    lastError?: string | null;
+    /** A run is waiting for the owner to grant workspace access. */
+    awaitingAccess?: boolean;
+    testId?: string;
+    labels?: Partial<TaskStatusPillLabels>;
+    /** Tooltip with the latest step ("Ready for review · 2 min ago · for You"). */
+    hint?: string;
+}
+/** A task's workflow status as one tinted pill: To do, Generating (live), Ready for review, Done. */
+export declare function TaskStatusPill({ id, status, runStartedAt, lastError, awaitingAccess, testId, labels, hint, }: TaskStatusPillProps): import("react").JSX.Element;

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

@@ -0,0 +1,99 @@
+import { type ReactNode } from 'react';
+import { type TaskPerson } from './PersonPill';
+import { type TaskOutput, type TaskOutputsCellLabels } from './TaskOutputsCell';
+import { type TaskReviewActionsLabels } from './TaskReviewActions';
+import { type TaskStatusPillLabels } from './TaskStatusPill';
+import type { TaskThreadChipLabels } from './TaskThreadChip';
+import { type TaskListRow } from './taskRows';
+import { type TaskListLabels } from './taskTableLabels';
+export interface TaskTableProps<T extends TaskListRow> {
+    /** The workspace's tasks: the conversations that have a status (the host drops plain chats). */
+    tasks: T[];
+    isLoading?: boolean;
+    /** Friendly display of an ISO timestamp. */
+    formatDate: (iso: string) => string;
+    /** Open the task's thread (its conversation). */
+    onOpenThread: (conversationId: string, task: T) => void;
+    /** A person marks a plain to-do done / reopens a finished one / accepts prepared work. */
+    onMarkDone: (task: T) => void;
+    onReopen: (task: T) => void;
+    onApprove: (task: T) => void;
+    onRequestChanges: (task: T, feedback: string) => void;
+    /** Ask another person to sign the task off (shown with `people`). */
+    onRequestApproval?: (task: T, userId: string, note: string) => void;
+    /** People who can be asked to approve (humans only); also names the sign-off column. */
+    people?: {
+        id: string;
+        label: string;
+    }[];
+    /** Agent names by id, for the Assigned to column (falls back to "Agent"). */
+    agentNames?: Record<string, string>;
+    /** Workflow names by id: names a task whose title the run has not generated yet, and its origin chip. */
+    workflowNames?: Record<string, string>;
+    /**
+     * How a person appears in the Assigned to and Sign-off columns. Defaults to the app's user pill from
+     * `@arbidocs/react`; a host with presence and direct messages passes its own.
+     */
+    renderPerson?: (person: TaskPerson) => ReactNode;
+    /** Share a task with the workspace or make it private (the shared/private toggle appears with it). */
+    onToggleShared?: (task: T, shouldShare: boolean) => void;
+    onEdit: (task: T) => void;
+    onDelete: (task: T) => void;
+    /** Start a new task that is a child of this one. */
+    onAddSubtask?: (task: T) => void;
+    /** Re-parent a task (`null` = top level). With it, the row menu offers "Move to…". */
+    onMove?: (task: T, parentId: string | null) => void;
+    /** Bulk actions on the selected rows (the selection bar shows only the ones provided). */
+    onMarkDoneMany?: (tasks: T[]) => void;
+    onDeleteMany?: (tasks: T[]) => void;
+    /** When set, a run waiting for access shows a one-click "allow access" action. */
+    onGrantAccess?: (task: T) => void;
+    /** Task id with a request in flight: its row disables its actions. */
+    busyId?: string | null;
+    /** Slot above the table (e.g. a live-runs banner). */
+    header?: ReactNode;
+    /**
+     * Extra bulk actions for the selection bar (an export, a share): called with the selected tasks, whether
+     * the bar is compact, and a function that clears the selection.
+     */
+    selectionActions?: (selected: T[], isCompact: boolean, clearSelection: () => void) => ReactNode;
+    /** Text from outside the table (a topbar filter) that narrows the rows like the search box does. */
+    filterText?: string;
+    /**
+     * The viewer edits the workspace (owner or collaborator): a row they do not own is always shared, and
+     * they may then edit, run, move and add sub-tasks to it. The share toggle, Delete and Allow access stay
+     * with the row's owner, and Approve with its sign-off person. A guest leaves this off and only reads.
+     */
+    canEditShared?: boolean;
+    /** The viewer owns the workspace: with a row's creator, the only one who deletes it. Who can see it stays the creator's alone. */
+    isWorkspaceOwner?: boolean;
+    /**
+     * Hand a task to someone: its owner (who has the next step) becomes `userId`, and they are notified;
+     * `null` hands it back to the viewer. Shown in the row menu as "Change owner…" with `people`.
+     */
+    onChangeOwner?: (task: T, userId: string | null) => void;
+    /** Saved column state key (AG Grid persists by it). */
+    gridId?: string;
+    labels?: Partial<TaskListLabels>;
+    testId?: string;
+    statusPillLabels?: Partial<TaskStatusPillLabels>;
+    threadChipLabels?: Partial<TaskThreadChipLabels>;
+    /** Generated documents per task id (latest versions only); a task with none shows a dash. */
+    outputsByTask?: Record<string, readonly TaskOutput[]>;
+    /** Open one generated document (Tasks view's Outputs column). */
+    onOpenOutput?: (documentId: string, task: T) => void;
+    outputsLabels?: Partial<TaskOutputsCellLabels>;
+    /** Open a task's activity timeline (row menu: "Activity"). */
+    onOpenActivity?: (task: T) => void;
+    /** "2 min ago" for the status tooltip; without it the tooltip is left out. */
+    formatRelative?: (iso: string) => string;
+    reviewLabels?: Partial<TaskReviewActionsLabels>;
+}
+/**
+ * The tasks of a workspace as a person's work list, in the same grid as every other list in the app:
+ * what needs review first, then what an agent is generating, plain to-dos and, last, what is done.
+ * Sub-tasks sit indented under their parent. Rows are selected with the grid's checkboxes (shift-click
+ * for a range; ticking a parent ticks its sub-tasks) and acted on from the selection bar. Agents prepare
+ * work; only a person closes it.
+ */
+export declare function TaskTable<T extends TaskListRow>(props: TaskTableProps<T>): import("react").JSX.Element;