@arbidocs/blocks 0.4.15 → 0.4.17

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

@@ -0,0 +1,19 @@
+export interface TaskThreadChipLabels {
+    open: string;
+    watch: string;
+    none: string;
+}
+export declare const DEFAULT_TASK_THREAD_CHIP_LABELS: TaskThreadChipLabels;
+export interface TaskThreadChipProps {
+    /** Task id: keys the test id (`task-thread-{id}`). */
+    id: string;
+    /** The task's conversation (a task is a conversation: its own id). */
+    conversationId?: string | null;
+    /** An agent is writing into the thread right now. */
+    generating?: boolean;
+    onOpen: (conversationId: string) => void;
+    testId?: string;
+    labels?: Partial<TaskThreadChipLabels>;
+}
+/** The link from a task to its thread — live-pulsing while the agent works, muted before there is one. */
+export declare function TaskThreadChip({ id, conversationId, generating, onOpen, testId, labels, }: TaskThreadChipProps): import("react").JSX.Element;

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

@@ -0,0 +1,24 @@
+import type { WorkflowTriggerType } from './taskLabels';
+export interface TaskTriggerChipLabels {
+    /** "After “X” is done" — the workflow waits on a task. */
+    after: (taskName: string) => string;
+    /** The workflow waits on a task that is not visible to the viewer. */
+    afterUnknown: string;
+    /** No trigger: it runs when someone presses Run. */
+    onDemand: string;
+}
+export declare const DEFAULT_TASK_TRIGGER_CHIP_LABELS: TaskTriggerChipLabels;
+export interface TaskTriggerChipProps {
+    /** Workflow id: keys the test id (`task-trigger-{id}`). */
+    id: string;
+    triggerType: WorkflowTriggerType;
+    /** Host-formatted summary for time and event triggers ("Every weekday at 9:00", "On document uploaded"). */
+    summary: string;
+    /** Set when this workflow waits on a task; the name it shows (or undefined if not visible). */
+    afterTaskId?: string | null;
+    afterTaskName?: string;
+    testId?: string;
+    labels?: Partial<TaskTriggerChipLabels>;
+}
+/** What starts a workflow, in one line: a time, a repeat, an event, or a task finishing. */
+export declare function TaskTriggerChip({ id, triggerType, summary, afterTaskId, afterTaskName, testId, labels, }: TaskTriggerChipProps): import("react").JSX.Element;

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

@@ -2,15 +2,12 @@
 export interface TasksChromeLabels {
     tasksTab: string;
     newTask: string;
-    delete: string;
 }
 export declare const DEFAULT_TASKS_CHROME_LABELS: TasksChromeLabels;
 export interface TasksToolbarProps {
     /** Number of tasks (shown on the single "Tasks" tab). */
     count: number;
     onNewTask: () => void;
-    /** The list is empty: its empty state carries the one filled button, so this one goes tonal. */
-    isEmpty?: boolean;
     testIds?: Partial<{
         tab: string;
         newTask: string;
@@ -18,19 +15,22 @@ export interface TasksToolbarProps {
     labels?: Partial<TasksChromeLabels>;
 }
 /** The Tasks page header: one "Tasks" tab with a count, and New task (the page's primary action). */
-export declare function TasksToolbar({ count, onNewTask, isEmpty, testIds, labels }: TasksToolbarProps): import("react").JSX.Element;
-/** Empty-state action for the Tasks grid. */
-export declare function NewTaskEmptyAction({ onNewTask, testId, labels, }: {
-    onNewTask: () => void;
-    testId?: string;
-    labels?: Partial<TasksChromeLabels>;
-}): import("react").JSX.Element;
-export interface TasksBulkBarProps {
+export declare function TasksToolbar({ count, onNewTask, testIds, labels }: TasksToolbarProps): import("react").JSX.Element;
+/** Fixed strings of the Workflows page chrome. */
+export interface WorkflowsChromeLabels {
+    workflowsTab: string;
+    newWorkflow: string;
+}
+export declare const DEFAULT_WORKFLOWS_CHROME_LABELS: WorkflowsChromeLabels;
+export interface WorkflowsToolbarProps {
+    /** Number of workflows (shown on the single "Workflows" tab). */
     count: number;
-    onClear: () => void;
-    onDelete: () => void;
-    testId?: string;
-    labels?: Partial<TasksChromeLabels>;
+    onNewWorkflow: () => void;
+    testIds?: Partial<{
+        tab: string;
+        newWorkflow: string;
+    }>;
+    labels?: Partial<WorkflowsChromeLabels>;
 }
-/** Bulk bar for selected tasks (Delete). */
-export declare function TasksBulkBar({ count, onClear, onDelete, testId, labels }: TasksBulkBarProps): import("react").JSX.Element;
+/** The Workflows page header: one "Workflows" tab with a count, and New workflow. */
+export declare function WorkflowsToolbar({ count, onNewWorkflow, testIds, labels }: WorkflowsToolbarProps): import("react").JSX.Element;

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

@@ -0,0 +1,10 @@
+import { type TaskComposerProps } from './taskComposerTypes';
+/**
+ * The workflow dialog, where a skill is run: what it does, when it runs (Now by default, or on a date, a
+ * repeat, an event or after a task) and who runs it (the person, or an agent), up front and in that
+ * order, each saying in plain words what is missing. "Now" runs it at once and saves nothing; every
+ * other start saves a workflow, which needs an agent because nobody is present when it fires. The name, details, sign-off, visibility, plan and unattended
+ * access are optional and sit behind "More options". A blank name is derived from the template or the
+ * instruction and shown as the placeholder, so the Create button needs only the three required parts.
+ */
+export declare function WorkflowComposer({ open, onOpenChange, isEdit, workflows, agents, people, tasks, values: valuesProp, initialValues, onValuesChange, timezones, goal, standingAccess, scopeSource, renderScope, renderDocuments, addFilesAction, onDropFiles, defaultAgentId, isPending, planDrafting, hasPlan, onSubmit, renderIcon, labels, formLabels, recurrence, testId, }: TaskComposerProps): import("react").JSX.Element;

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

@@ -0,0 +1,72 @@
+import { type ReactNode } from 'react';
+import { type TaskPerson } from './PersonPill';
+import { type TaskTriggerChipLabels } from './TaskTriggerChip';
+import { type WorkflowListRow } from './workflowRows';
+import { type WorkflowListLabels } from './workflowTableLabels';
+export interface WorkflowsTableProps<T extends WorkflowListRow> {
+    /** Everything the viewer can run: saved workflows, and skills as virtual rows (`kind: 'skill'`). */
+    workflows: T[];
+    isLoading?: boolean;
+    /** Human summary of when a workflow starts ("Every weekday at 9:00", "On document uploaded"). */
+    describeTrigger: (workflow: T) => string;
+    /** Friendly display of an ISO timestamp. */
+    formatDate: (iso: string) => string;
+    /** Pause or resume a workflow that starts by itself (an on-demand one has no switch). */
+    onToggleActive: (workflow: T, active: boolean) => void;
+    /** Share a workflow with the workspace or make it private (the toggle appears with it). */
+    onToggleShared?: (workflow: T, shouldShare: boolean) => void;
+    /** Open the workflow in the composer (workflow-edit mode). */
+    onEdit: (workflow: T) => void;
+    /**
+     * Run it. A saved workflow just runs (its inputs are stored); a skill needs its inputs, so the host
+     * opens the run dialog with that skill selected.
+     */
+    onRun: (row: T) => void;
+    /** Run a skill later: the run dialog, on its schedule view. Offered on skill rows. */
+    onRunLater?: (skill: T) => void;
+    onDelete: (workflow: T) => void;
+    /** Show the tasks this workflow created. */
+    onViewRuns?: (workflow: T) => void;
+    /** Click on a row (not on one of its controls): a skill's detail, a workflow's editor. */
+    onOpenRow?: (row: T) => void;
+    /** Open the task a workflow's last run created. */
+    onOpenThread?: (conversationId: string) => void;
+    /** Each workflow's latest run: the newest task it created, by workflow id. */
+    lastRuns?: Record<string, {
+        conversationId: string;
+        at: string;
+    }>;
+    /** Bulk actions on the selected workflows (skills are skipped). */
+    onDeleteMany?: (workflows: T[]) => void;
+    onToggleActiveMany?: (workflows: T[], active: boolean) => void;
+    /** Agent names by id, for the Agent column (falls back to "Agent"). */
+    agentNames?: Record<string, string>;
+    /** Skill names by `skill_ref`, for the action cell (falls back to the reference). */
+    skillNames?: Record<string, string>;
+    /** Task names by id, for an "after <task>" trigger. */
+    taskNames?: Record<string, string>;
+    /** How an agent appears in the Agent column; defaults to the app's user pill. */
+    renderPerson?: (person: TaskPerson) => ReactNode;
+    /**
+     * The viewer edits the workspace (owner or collaborator): they may then edit, pause, resume and run a
+     * workflow shared with it. A guest leaves this off.
+     */
+    canEditShared?: boolean;
+    /** The viewer owns the workspace: with the creator, the only one who deletes a workflow. Who can see it stays the creator's alone. */
+    isWorkspaceOwner?: boolean;
+    /** Workflow id with a request in flight: its row disables its controls. */
+    busyId?: string | null;
+    header?: ReactNode;
+    gridId?: string;
+    labels?: Partial<WorkflowListLabels>;
+    triggerChipLabels?: Partial<TaskTriggerChipLabels>;
+    testId?: string;
+}
+/**
+ * Everything the viewer can run, in one list: skills (they run on demand) and saved workflows (they start
+ * on a date, a repeat, an event or after a task, or on demand). Each row has its type, when it starts, what
+ * it does, who runs it, its status (Active or Paused with a switch; On demand has none), when it last ran
+ * (linking to the task that run created) and runs next, and a visible Run. The same grid as every other
+ * list in the app.
+ */
+export declare function WorkflowsTable<T extends WorkflowListRow>(props: WorkflowsTableProps<T>): import("react").JSX.Element;

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

@@ -0,0 +1,11 @@
+/**
+ * Drop the least useful columns as a grid gets narrower, so the actions column (Approve, Run, the menu)
+ * is never pushed off the edge. Each rule keeps its column while the grid is at least `minWidth` wide.
+ */
+import type { GridApi } from 'ag-grid-community';
+export interface ColumnWidthRule {
+    colId: string;
+    /** The narrowest grid (px) that still shows the column. */
+    minWidth: number;
+}
+export declare function applyColumnWidthRules(api: Pick<GridApi, 'getColumn' | 'setColumnsVisible'>, gridWidth: number, rules: readonly ColumnWidthRule[]): void;

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

@@ -2,13 +2,29 @@ export { TaskPlan, DEFAULT_TASK_PLAN_LABELS, nextCriterionId, type TaskPlanLabel
 export { UploadTaskItem, DEFAULT_UPLOAD_TASK_ITEM_LABELS, type UploadTaskItemProps, type UploadTaskItemLabels, type UploadTaskItemTestIds, } from './UploadTaskItem';
 export { formatElapsed } from './elapsed';
 export { UploadTaskList, DEFAULT_UPLOAD_TASK_LIST_LABELS, type UploadTaskListProps, type UploadTaskListLabels, type UploadTaskView, } from './UploadTaskList';
-export { LiveRunsBanner, DEFAULT_LIVE_RUNS_BANNER_LABELS, type LiveRun, type LiveRunsBannerProps, type LiveRunsBannerLabels, } from './LiveRunsBanner';
 export { RecurrenceBuilder, DEFAULT_RECURRENCE_BUILDER_LABELS, type RecurrenceBuilderProps, type RecurrenceBuilderLabels, type RecurrenceBuilderTestIds, } from './RecurrenceBuilder';
 export * from './rrule';
-export { ACTION_LABELS, STATUS_LABELS, TRIGGER_LABELS, goalProgress, statusBadgeVariant, type TaskActionType, type TaskBadgeVariant, type TaskGoalState, type TaskStatusKey, type TaskTriggerType, } from './taskLabels';
-export { TaskRowActions, DEFAULT_TASK_ROW_ACTIONS_LABELS, type TaskRowActionsProps, type TaskRowActionsLabels, type TaskRowActionsTestIds, } from './TaskRowActions';
-export { createTaskColumns, DEFAULT_TASK_COLUMN_LABELS, type TaskColumnSlots, type TaskColumnLabels, type TaskColumnTestIds, type TaskRowView, } from './taskColumns';
+export { STATUS_LABELS, STATUS_ORDER, STATUS_TONE, TRIGGER_LABELS, asTaskStatus, goalProgress, type TaskGoalState, type TaskStatusKey, type WorkflowTriggerType, } from './taskLabels';
+export { TaskTable, type TaskTableProps } from './TaskTable';
+export { DEFAULT_TASK_LIST_LABELS, type TaskListLabels } from './taskTableLabels';
+export { createTaskColumns, TASK_COLUMN_ORDER, type CreateTaskColumnsOptions } from './taskColumns';
+export { NewThreadDialog, DEFAULT_NEW_THREAD_DIALOG_LABELS, type NewThreadDialogProps, type NewThreadDialogLabels, } from './NewThreadDialog';
+export { MAX_TASK_DEPTH, buildTaskRows, ownerExtId, descendantIds, indexTasks, isPlainTodo, moveTargets, type BuildTaskRowsOptions, type TaskTree, type TaskFilter, type TaskGridRow, type TaskListRow, } from './taskRows';
+export { WorkflowsTable, type WorkflowsTableProps } from './WorkflowsTable';
+export { WORKFLOW_COLUMN_ORDER, createWorkflowColumns } from './workflowColumns';
+export { hasTrigger, isSkillRow, workflowStatus, workflowTriggerType, type WorkflowListRow, type WorkflowStatusKey, } from './workflowRows';
+export { DEFAULT_WORKFLOW_LIST_LABELS, type WorkflowListLabels } from './workflowTableLabels';
+export { TaskMoveDialog, type TaskMoveDialogProps, type TaskMoveDialogLabels, type TaskMoveOption, } from './TaskMoveDialog';
+export { PersonPill, type PersonPillProps, type TaskPerson } from './PersonPill';
+export { TaskStatusPill, DEFAULT_TASK_STATUS_PILL_LABELS, type TaskStatusPillProps, type TaskStatusPillLabels, } from './TaskStatusPill';
+export { TaskActivityTimeline, DEFAULT_TASK_ACTIVITY_LABELS, type TaskActivityEvent, type TaskActivityKind, type TaskActivityLabels, type TaskActivityTimelineProps, } from './TaskActivityTimeline';
+export { TaskActivityDialog, type TaskActivityDialogProps } from './TaskActivityDialog';
+export { TaskOutputsCell, DEFAULT_TASK_OUTPUTS_CELL_LABELS, type TaskOutput, type TaskOutputsCellProps, type TaskOutputsCellLabels, } from './TaskOutputsCell';
+export { TaskThreadChip, DEFAULT_TASK_THREAD_CHIP_LABELS, type TaskThreadChipProps, type TaskThreadChipLabels, } from './TaskThreadChip';
+export { TaskTriggerChip, DEFAULT_TASK_TRIGGER_CHIP_LABELS, type TaskTriggerChipProps, type TaskTriggerChipLabels, } from './TaskTriggerChip';
+export { TaskReviewActions, DEFAULT_TASK_REVIEW_ACTIONS_LABELS, type TaskReviewActionsProps, type TaskReviewActionsLabels, } from './TaskReviewActions';
 export { TaskRunsDialog, DEFAULT_TASK_RUNS_DIALOG_LABELS, type TaskRunsDialogProps, type TaskRunsDialogLabels, type TaskRunsDialogTestIds, type TaskRunView, } from './TaskRunsDialog';
-export { TasksToolbar, NewTaskEmptyAction, TasksBulkBar, DEFAULT_TASKS_CHROME_LABELS, type TasksChromeLabels, type TasksToolbarProps, type TasksBulkBarProps, } from './TasksChrome';
-export { TaskComposer, DEFAULT_TASK_COMPOSER_LABELS, defaultTaskComposerValues, type TaskComposerProps, type TaskComposerLabels, type TaskComposerValues, type TaskWhen, type TaskAccessMode, } from './TaskComposer';
-export { authModeFor, workflowTaskFields, isAgenticWorkflow, taskComposerToCreateRequest, taskComposerToUpdateRequest, taskToComposerValues, taskNeedsAccess, isoToLocalInput, localInputToIso, type TaskAuthMode, type TaskActionKind, type WorkflowTaskFields, type TaskRequestContext, type TaskValuesWorkflows, } from './taskRequest';
+export { TasksToolbar, DEFAULT_TASKS_CHROME_LABELS, type TasksChromeLabels, type TasksToolbarProps, WorkflowsToolbar, DEFAULT_WORKFLOWS_CHROME_LABELS, type WorkflowsChromeLabels, type WorkflowsToolbarProps, } from './TasksChrome';
+export { TaskComposer, DEFAULT_TASK_COMPOSER_LABELS, defaultTaskComposerValues, type TaskComposerProps, type TaskComposerLabels, type TaskComposerValues, type TaskOption, type PersonOption, type TaskWhen, type TaskAccessMode, type TaskAssignee, } from './TaskComposer';
+export { authModeFor, workflowTaskFields, isAgenticWorkflow, createsWork, EMPTY_NEW_THREAD, hasTaskFields, newThreadToRequest, type NewThreadRequest, type NewThreadValues, deriveWorkflowName, firstWords, DERIVED_NAME_WORDS, composerToWorkRequest, composerToTaskQuery, inputDocumentIds, composerToWorkflowRequest, composerToWorkflowUpdate, taskComposerToCreateRequest, taskComposerToUpdateRequest, taskToComposerValues, workflowToComposerValues, workflowWhen, taskNeedsAccess, isoToLocalInput, localInputToIso, type TaskAuthMode, type ComposerCreate, type TaskQuery, type ThreadQuery, type WorkflowTaskFields, type TaskRequestContext, type TaskValuesWorkflows, } from './taskRequest';
+export { PillSelect, DEFAULT_PILL_SELECT_LABELS, type PillSelectProps, type PillSelectLabels, type PillOption, } from './PillSelect';

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

@@ -1,68 +1,44 @@
 /**
- * Column definitions for the Tasks grid. Every column has an explicit `colId` (AG Grid persists
- * column state by id: see CLAUDE.md). The app supplies the row actions and formatters as slots.
+ * Column definitions for the tasks grid. Every column has an
+ * explicit `colId` (AG Grid persists column state by id: see CLAUDE.md). The table supplies behaviour and
+ * the cells that need it through slots; the structure, widths and headers live here. The slots must be
+ * stable functions (the table keeps the latest handlers behind them) so the definitions are built once
+ * and the grid never refreshes its columns on a selection or expand.
+ *
+ * Every conversation is a task: Owner (who has the next step), due, shared, thread link,
+ *   status, outputs. Rows are `TaskGridRow`s: a task plus where it sits in the sub-task tree, so the
+ *   order is the tree's. A column's header still shows and reports the sort, but the grid's own sort is
+ *   a no-op (`keepOrder`): that would tear sub-tasks away from their parent, so the table sorts within
+ *   each level instead (see `buildTaskRows`).
  */
 import type { ReactNode } from 'react';
 import type { ColDef } from 'ag-grid-community';
-/** The fields of a task the grid reads. Callers' richer types are accepted as-is. */
-export interface TaskRowView {
-    external_id: string;
-    name: string;
-    trigger_type: string;
-    action_type: string;
-    skill_ref?: string | null;
-    is_goal_task?: boolean | null;
-    goal_state?: unknown;
-    workspace_ext_id?: string | null;
-    agent_ext_id?: string | null;
-    status: string;
-    in_progress?: boolean | null;
-    next_run_at?: string | null;
-    last_run_at?: string | null;
-    last_error?: string | null;
-    /** Set while a run waits for the owner to grant access. */
-    pending_auth_request_id?: string | null;
+import type { TaskGridRow, TaskListRow } from './taskRows';
+import type { TaskListLabels } from './taskTableLabels';
+/** The actions column's usual width (Approve, ask someone, the menu). */
+export declare const ACTIONS_WIDTH = 210;
+export declare const TASK_COLUMN_ORDER: readonly ["name", "owner", "due", "status", "outputs", "shared", "actions"];
+export type TaskColumnId = (typeof TASK_COLUMN_ORDER)[number];
+export interface CreateTaskColumnsOptions<T extends TaskListRow> {
+    labels: TaskListLabels;
+    renderName: (row: TaskGridRow<T>) => ReactNode;
+    /** Who has the next step. */
+    renderOwner: (row: TaskGridRow<T>) => ReactNode;
+    renderDue: (row: TaskGridRow<T>) => ReactNode;
+    renderShared: (row: TaskGridRow<T>) => ReactNode;
+    /** The documents the task generated. */
+    renderOutputs: (row: TaskGridRow<T>) => ReactNode;
+    /** A phone-width grid: the actions column is just the menu. */
+    narrow?: boolean;
+    /** Whether the Outputs column is shown: only worth the room once some task has outputs. */
+    showOutputs?: boolean;
+    renderStatus: (row: TaskGridRow<T>) => ReactNode;
+    /** Who is in the thread (Threads view). */
+    renderActions: (row: TaskGridRow<T>) => ReactNode;
+    /** Plain text of the owner cell, for sorting, filters and the clipboard. */
+    getOwnerName: (row: TaskGridRow<T>) => string;
 }
-/** Fixed strings of the Tasks grid. */
-export interface TaskColumnLabels {
-    name: string;
-    trigger: string;
-    action: string;
-    target: string;
-    status: string;
-    nextRun: string;
-    lastRun: string;
-    untitled: string;
-    goal: string;
-    workspace: string;
-    defaultAgent: string;
-    running: string;
-    /** A run is waiting for the owner to allow access. */
-    waitingForAccess: string;
-    never: string;
-    /** Goal progress, e.g. "2/3 met". */
-    goalMet: (met: number, total: number) => string;
-}
-export declare const DEFAULT_TASK_COLUMN_LABELS: TaskColumnLabels;
-/** Per-task test ids derived from the task id (defaults `task-name-{id}`, ...). */
-export interface TaskColumnTestIds {
-    name: (id: string) => string;
-    goalBadge: (id: string) => string;
-    goalProgress: (id: string) => string;
-    error: (id: string) => string;
-}
-export interface TaskColumnSlots<T extends TaskRowView> {
-    /** Human summary of when the task fires. */
-    describeTrigger: (task: T) => string;
-    /** Friendly display of an ISO timestamp. */
-    formatDate: (iso: string) => string;
-    /** The row actions cell (`TaskRowActions` bound to the app's mutations). */
-    renderActions: (task: T) => ReactNode;
-    /** Destination of a task's name; makes it a real link (modified clicks go to the browser). */
-    getHref?: (task: T) => string | undefined;
-    /** Plain click on the linked name (owns navigation); without `getHref` the name is plain text. */
-    onOpen?: (task: T) => void;
-    testIds?: Partial<TaskColumnTestIds>;
-    labels?: Partial<TaskColumnLabels>;
-}
-export declare function createTaskColumns<T extends TaskRowView>(slots: TaskColumnSlots<T>): ColDef<T>[];
+/** Columns the user can sort by, per view. */
+export declare const SORTABLE_TASK_COLUMNS: readonly ["name", "owner", "due", "status", "updated", "messages"];
+export type SortableTaskColumn = (typeof SORTABLE_TASK_COLUMNS)[number];
+export declare function createTaskColumns<T extends TaskListRow>(o: CreateTaskColumnsOptions<T>): ColDef<TaskGridRow<T>>[];

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

@@ -0,0 +1,217 @@
+import type { ReactNode } from 'react';
+import type { AgentOption } from '../workflows/AgentSelect';
+import type { SchemaFormLabels } from '../workflows/SchemaForm';
+import type { WorkflowScopeSource } from '../workflows/WorkflowConfigDialog';
+import type { WorkflowDefinition, WorkflowField, WorkflowInputs, WorkflowScope } from '../workflows/types';
+import type { RecurrenceBuilderProps } from './RecurrenceBuilder';
+/**
+ * When the assistant starts. `manual` means it only acts when asked (an @mention, or sending work back);
+ * `now` starts it at once; `once`, `repeat`, `event` and `task` (after another task is signed off) start
+ * it unattended.
+ */
+export type TaskWhen = 'manual' | 'now' | 'once' | 'repeat' | 'event' | 'task';
+export type TaskAccessMode = 'ask_each_run' | 'standing';
+/**
+ * Whether the assistant has been given work. Every task has an assistant; `agent` means it was configured
+ * to prepare the task (it has an instruction and a start), `me` means it is on standby.
+ */
+export type TaskAssignee = 'me' | 'agent';
+/** Everything the composer collects. The host maps it onto its API. */
+export interface TaskComposerValues {
+    assignee: TaskAssignee;
+    workflowId: string;
+    inputs: WorkflowInputs;
+    when: TaskWhen;
+    /** datetime-local value (`once`). */
+    runAt: string;
+    rrule: string;
+    timezone: string;
+    eventKind: string;
+    /** `task`: the id (`con-…`) of the task (conversation) this one waits on. */
+    afterTaskId: string;
+    /** The task this is a sub-task of (`con-…`); `''` = a top-level task. */
+    parentTaskId: string;
+    /** The person who signs the task off (`usr-…`); `''` = me. Always a human. */
+    signoffUserId: string;
+    /** Shared with the workspace's members (like a document); off keeps it private to its owner. */
+    shared: boolean;
+    /** What the task is, in the owner's words. */
+    description: string;
+    /** datetime-local value; empty = no due date. */
+    dueAt: string;
+    /** `''` = the user's own assistant. */
+    agentId: string;
+    /** The task's title. */
+    name: string;
+    /** The reviewer is always told when the assistant finishes; kept so hosts can map it. */
+    notifyOnComplete: boolean;
+    /** Only asked for tasks the assistant starts unattended. */
+    access: TaskAccessMode;
+    /** A workflow's saved equality filters on its event; carried through an edit unchanged (no control). */
+    eventFilter?: Record<string, string | number | boolean> | null;
+}
+export interface TaskComposerLabels {
+    titleNew: string;
+    titleEdit: string;
+    description: string;
+    titleNewWorkflow: string;
+    titleRunTemplate: (name: string) => string;
+    titleEditWorkflow: string;
+    descriptionWorkflow: string;
+    workflowNamePlaceholder: string;
+    createWorkflow: string;
+    /** The workflow dialog's three required parts, in order, and what is missing from each. */
+    whenHeading: string;
+    whoHeading: string;
+    /** "Run as": the person themself (the default for Run now) or an agent (required for a scheduled run). */
+    runAs: string;
+    runLater: string;
+    addFilesReason: string;
+    needDocument: string;
+    addPlan: string;
+    hidePlan: string;
+    /** The toggle when the workflow already has a plan. */
+    showPlan: string;
+    runAsMe: string;
+    runAsAgentHint: string;
+    needAgent: string;
+    runNow: string;
+    saveWorkflow: string;
+    needWhat: string;
+    needRunAt: string;
+    needRrule: string;
+    needEvent: string;
+    needAfterTask: string;
+    /** The "More options" disclosure (name, details, sign-off, visibility, plan, unattended access). */
+    moreOptions: string;
+    fewerOptions: string;
+    nameHint: string;
+    titleLabel: string;
+    titlePlaceholder: string;
+    descriptionLabel: string;
+    descriptionPlaceholder: string;
+    signoff: string;
+    signoffMe: string;
+    due: string;
+    dueNone: string;
+    dueClear: string;
+    parentTask: string;
+    parentTaskNone: string;
+    visibility: string;
+    visibilityWorkspace: string;
+    visibilityPrivate: string;
+    assistant: string;
+    assistantStandby: string;
+    assistantPreparing: (when: string) => string;
+    configure: string;
+    configureClose: string;
+    what: string;
+    template: string;
+    whatPlaceholder: string;
+    plan: string;
+    planHint: string;
+    start: string;
+    whenOptions: Record<TaskWhen, string>;
+    runAt: string;
+    /** Shown when the start time is already past: the server refuses it. */
+    runAtPast: string;
+    event: string;
+    eventPlaceholder: string;
+    eventHint: ReactNode;
+    afterTask: string;
+    afterTaskPlaceholder: string;
+    which: string;
+    myAssistant: string;
+    permission: string;
+    /** The disclosure that holds who runs it, access, name, owner and visibility. */
+    runOptions: string;
+    /** Its summary line: "Runs as Assistant · ask me each time". */
+    runOptionsSummary: (agent: string, access: string) => string;
+    permissionHint: string;
+    accessOptions: Record<TaskAccessMode, {
+        label: string;
+        hint: string;
+    }>;
+    timezone: string;
+    search: string;
+    empty: string;
+    cancel: string;
+    addTask: string;
+    addAndStart: string;
+    addAndSchedule: string;
+    save: string;
+    saving: string;
+}
+export declare const DEFAULT_TASK_COMPOSER_LABELS: TaskComposerLabels;
+export interface TaskOption {
+    id: string;
+    name: string;
+}
+/** A person who can be asked to sign a task off. */
+export interface PersonOption {
+    id: string;
+    label: string;
+    /** Small line after the name (e.g. their role). */
+    description?: string;
+}
+export interface TaskComposerProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /**
+     * `work` (default) adds a task: "Now" starts it at once and any other start saves a workflow.
+     * `workflow` is the workflow dialog itself (new or edit): a trigger and an action are required, and
+     * the task-only properties (due date, parent) are hidden.
+     */
+    kind?: 'work' | 'workflow';
+    /**
+     * Editing an existing task, or a workflow. A task keeps the start and assistant it was created with;
+     * a workflow can change both.
+     */
+    isEdit?: boolean;
+    /** Workflows the assistant can run. The host includes its "my own instruction" entry. */
+    workflows: WorkflowDefinition[];
+    agents: AgentOption[];
+    /** People who can sign a task off (humans who can edit the workspace, besides me). Omit to hide the field. */
+    people?: PersonOption[];
+    /** Tasks a new task can be part of, or wait on (`when: 'task'`) — conversations with a status. */
+    tasks?: TaskOption[];
+    /**
+     * The owner's Assistant (an agent id). A scheduled workflow needs an agent, so switching away from
+     * "Now" selects this one when "Run as" is still the person themself.
+     */
+    defaultAgentId?: string;
+    /** Controlled values; omit to let the composer hold them (seeded by `initialValues`). */
+    values?: TaskComposerValues;
+    initialValues?: Partial<TaskComposerValues>;
+    onValuesChange?: (values: TaskComposerValues) => void;
+    timezones?: string[];
+    /** The plan editor, shown inline when the assistant is configured. Omit when not applicable. */
+    goal?: ReactNode | ((values: TaskComposerValues) => ReactNode);
+    /** What "always allowed" means for this assistant (e.g. the workspaces it will hold standing access to). */
+    standingAccess?: ReactNode | ((values: TaskComposerValues) => ReactNode);
+    isPending?: boolean;
+    /** A plan is being drafted: saving waits for it, or the plan would be dropped. */
+    planDrafting?: boolean;
+    /** The plan already stored (an edit): the toggle offers to show it rather than to add one. */
+    hasPlan?: boolean;
+    onSubmit: (values: TaskComposerValues) => void;
+    /**
+     * The workspace's files behind `scope` fields (the folder/label picker) and a `documents` field (an
+     * explicit pick). The host owns the file data; without these those fields render nothing. A scope pick
+     * is resolved to explicit file ids on submit (`scopeSource.resolveDocuments`).
+     */
+    scopeSource?: WorkflowScopeSource;
+    renderScope?: (field: WorkflowField, value: WorkflowScope, onChange: (s: WorkflowScope) => void) => ReactNode;
+    renderDocuments?: (field: WorkflowField, value: WorkflowScope, onChange: (s: WorkflowScope) => void) => ReactNode;
+    /** The host's "Add files" control, offered instead of the form when a template needs files and there are none. */
+    addFilesAction?: ReactNode;
+    /** Files dropped on the "add files" state: the host uploads them. */
+    onDropFiles?: (files: File[]) => void;
+    /** The assistant's workflow input forms: `renderIcon` maps a field option's icon key. */
+    renderIcon?: (key: string) => ReactNode;
+    labels?: Partial<TaskComposerLabels>;
+    formLabels?: Partial<SchemaFormLabels>;
+    recurrence?: Pick<RecurrenceBuilderProps, 'testIds' | 'labels'>;
+    testId?: string;
+}
+export declare function defaultTaskComposerValues(workflows: WorkflowDefinition[], initial?: Partial<TaskComposerValues>): TaskComposerValues;

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

@@ -1,12 +1,30 @@
-export type TaskTriggerType = 'one_time' | 'recurring' | 'event';
-export type TaskActionType = 'notify' | 'agent_prompt' | 'run_skill';
-export type TaskStatusKey = 'active' | 'paused' | 'completed' | 'failed';
-export declare const TRIGGER_LABELS: Record<TaskTriggerType, string>;
-export declare const ACTION_LABELS: Record<TaskActionType, string>;
+import type { Tone } from '../../components/tones';
+/**
+ * What starts a workflow: a moment (`one_time`), a repeating schedule (`recurring`), a notification
+ * (`event`), another conversation finishing (`after`), or nothing but someone pressing Run (`on_demand`).
+ */
+export type WorkflowTriggerType = 'one_time' | 'recurring' | 'event' | 'after' | 'on_demand';
+/**
+ * Where a task (a conversation with a status) is in the human workflow. Agents prepare work; only a
+ * person marks it `done`.
+ * - `todo`: nothing automated pending.
+ * - `generating`: an agent run is in flight.
+ * - `ready_for_review`: prepared, waiting for a person.
+ * - `done`: a person accepted it.
+ * - `chat`: no status at all: a plain conversation, listed beside the tasks.
+ */
+export type TaskStatusKey = 'todo' | 'generating' | 'ready_for_review' | 'done' | 'chat';
+export declare const TRIGGER_LABELS: Record<WorkflowTriggerType, string>;
 export declare const STATUS_LABELS: Record<TaskStatusKey, string>;
-export type TaskBadgeVariant = 'default' | 'secondary' | 'destructive' | 'outline';
-export declare function statusBadgeVariant(status: string): TaskBadgeVariant;
-/** The goal-state fields the grid reads from a goal task's last run. */
+/** The order sections appear in the list: what needs a person first, finished work last. */
+export declare const STATUS_ORDER: readonly TaskStatusKey[];
+export declare const STATUS_TONE: Record<TaskStatusKey, Tone>;
+/**
+ * A status string from the API narrowed to the known set. No status is a plain chat; anything else
+ * unexpected reads as a to-do.
+ */
+export declare function asTaskStatus(status: string | null | undefined): TaskStatusKey;
+/** The goal-state fields the list reads from a goal task's last run. */
 export interface TaskGoalState {
     done?: boolean;
     criteria_met?: number;
@@ -14,10 +32,9 @@ export interface TaskGoalState {
 }
 /**
  * Goal progress from a goal task's last run (its `/goal` gate verdict), or null when the task
- * isn't a goal task or hasn't run yet.
+ * has no goal state yet.
  */
 export declare function goalProgress(task: {
-    is_goal_task?: boolean | null;
     goal_state?: unknown;
 }): {
     met: number;