@arbidocs/blocks 0.4.16 → 0.4.17

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

@@ -1,19 +1,29 @@
 /**
  * TaskComposer values to API requests (and back): the pure mapping every host would write the same
- * way. No SDK call is made here; hand the result to `useCreateTask` / `useUpdateTask` from
- * `@arbidocs/react`.
+ * way. No SDK call is made here; hand the result to the hooks from `@arbidocs/react`.
+ *
+ * "Now" (or a plain to-do) creates work: a conversation with a status (`useCreateWork`). Any other
+ * start (a date, a repeat, an event, after another task) saves a workflow (`useCreateWorkflow`) that
+ * creates the work when it fires.
  */
 import type { components } from '@arbidocs/client';
+import { type WorkflowComposeContext } from '../workflows/workflow';
 import type { WorkflowDefinition, WorkflowInputs } from '../workflows/types';
-import type { TaskComposerValues } from './TaskComposer';
-type CreateTaskRequest = components['schemas']['CreateTaskRequest'];
-type UpdateTaskRequest = components['schemas']['UpdateTaskRequest'];
-type TaskResponse = components['schemas']['TaskResponse'];
-export type TaskAuthMode = NonNullable<CreateTaskRequest['auth_mode']>;
-export type TaskActionKind = NonNullable<CreateTaskRequest['action_type']>;
+import type { TaskComposerValues, TaskWhen } from './taskComposerTypes';
+type Schemas = components['schemas'];
+type ConversationResponse = Schemas['ConversationResponse'];
+type CreateWorkRequest = Schemas['CreateWorkRequest'];
+type CreateWorkflowRequest = Schemas['CreateWorkflowRequest'];
+type TaskPlan = Schemas['TaskPlan'];
+type TaskOptions = Schemas['TaskOptions'];
+type UpdateConversationRequest = Schemas['UpdateConversationRequest'];
+type UpdateWorkflowRequest = Schemas['UpdateWorkflowRequest'];
+type WorkflowResponse = Schemas['WorkflowResponse'];
+/** The authorization tier of a run (the same three values for work and for workflows). */
+export type TaskAuthMode = CreateWorkRequest['auth_mode'];
 /**
- * The plain-language access choice becomes the backend authorisation tier: a run-now task is
- * authorised for that one run, a scheduled one either keeps standing access or asks each run.
+ * The plain-language access choice becomes the backend authorisation tier: run-now work is
+ * authorised for that one run, a workflow either keeps standing access or asks each run.
  */
 export declare function authModeFor(values: Pick<TaskComposerValues, 'when' | 'access'>): TaskAuthMode;
 /** `datetime-local` value (no zone) to an ISO instant. Throws on an empty or invalid value. */
@@ -21,41 +31,157 @@ export declare function localInputToIso(local: string): string;
 /** An ISO instant to the `datetime-local` value the composer edits; empty for none or invalid. */
 export declare function isoToLocalInput(iso: string | null | undefined): string;
 export interface WorkflowTaskFields {
+    /** The title of the work or the name of the workflow. */
     name: string;
-    action_type: TaskActionKind;
     prompt: string;
     skill_ref: string | null;
+    /** The skill's saved inputs (only for a skill). */
+    skill_inputs: WorkflowInputs | null;
 }
+/** How many words of an instruction a derived name keeps. */
+export declare const DERIVED_NAME_WORDS = 6;
+/** The first `count` words of a text, with an ellipsis when there is more; empty for blank text. */
+export declare function firstWords(text: string, count?: number): string;
 /**
- * How a workflow becomes the body of a task:
- * - `options.agent === false` is a reminder (`notify`): the composed text is the notification;
- * - a workflow with a `skill` runs that skill, its `args` input being the arguments;
+ * The name a workflow (or task) gets when its owner types none: the template's title or, for a template
+ * that is a free-text instruction or reminder (its form is just an `instruction` or `message`), the
+ * first few words of what was written, falling back to the title while it is still blank.
+ */
+export declare function deriveWorkflowName(workflow: WorkflowDefinition, inputs: WorkflowInputs): string;
+/**
+ * How a workflow definition becomes an action:
+ * - `options.agent === false` is a reminder: the composed text is the title and there is no prompt or
+ *   skill (the backend makes a to-do and notifies the owner);
+ * - a definition with a `skill` runs that skill, its `args` input being the arguments;
  * - anything else is an agent prompt, the composed workflow prompt.
- * `name` (typed by the user) wins over the derived one.
+ * `name` (typed by the user) wins over the derived one (see {@link deriveWorkflowName}).
  */
-export declare function workflowTaskFields(workflow: WorkflowDefinition, inputs: WorkflowInputs, name?: string): WorkflowTaskFields;
+/** Does any input name files (an explicit pick, or a resolved scope)? Those bind the run. */
+export declare const hasDocumentInputs: (inputs: WorkflowInputs) => boolean;
+export declare function workflowTaskFields(workflow: WorkflowDefinition, inputs: WorkflowInputs, name?: string, context?: WorkflowComposeContext): WorkflowTaskFields;
 /** Does this workflow need a workspace to run (everything except a plain reminder)? */
 export declare const isAgenticWorkflow: (workflow: WorkflowDefinition) => boolean;
 export interface TaskRequestContext {
+    /** File names for the prompt's wording ("the document <name>"), by file id. */
+    documentTitles?: Record<string, string>;
     workflow: WorkflowDefinition;
     values: TaskComposerValues;
+    /** The goal checklist drafted for agent work, if any. */
+    plan?: TaskPlan | null;
+}
+/** Does this composer submission create work straight away (rather than save a workflow)? */
+export declare const createsWork: (values: Pick<TaskComposerValues, "assignee" | "when">) => boolean;
+/**
+ * The create-work request: a plain to-do (a title, no agent) or agent work that starts now. Agent work
+ * throws when there is no workspace open.
+ */
+export declare function composerToWorkRequest({ workflow, values, plan, documentTitles }: TaskRequestContext, workspaceId: string | undefined): CreateWorkRequest;
+/**
+ * Run now is a plain assistant query that carries `task` options: the thread it starts becomes a task
+ * (generating, then ready for review). The query is the person's own run, so there is no agent and no
+ * access tier. The host turns this into a `POST /v1/responses` body.
+ */
+export interface TaskQuery {
+    /** The message sent: the prompt, or `/skill-name arguments` for a skill. */
+    input: string;
+    workspaceId: string;
+    /** Files the run is bound to (the ids under any input's `documents`). */
+    docIds: string[];
+    task: TaskOptions;
 }
+/** A thread to start: a task's query, or (no `task`) a plain conversation. */
+export type ThreadQuery = Omit<TaskQuery, 'task'> & {
+    task?: TaskOptions;
+};
+/** The ids of the files a form's inputs name (an explicit pick, or a resolved scope), without repeats. */
+export declare function inputDocumentIds(inputs: WorkflowInputs): string[];
+/** The query that runs agent work now (a prompt or a skill) as the person asking. Throws without a workspace. */
+export declare function composerToTaskQuery({ workflow, values, plan, documentTitles }: TaskRequestContext, workspaceId: string | undefined): TaskQuery;
+/**
+ * The create-workflow request: exactly one trigger (a date, a repeat, an event, or another task being
+ * done) and the action it runs. An agent workflow throws when there is no workspace open.
+ */
+export declare function composerToWorkflowRequest({ workflow, values, plan, documentTitles }: TaskRequestContext, workspaceId: string | undefined): CreateWorkflowRequest;
+/** What a composer submission asks the host to do. */
+export type ComposerCreate = {
+    kind: 'work';
+    body: CreateWorkRequest;
+} | {
+    kind: 'query';
+    query: TaskQuery;
+} | {
+    kind: 'workflow';
+    body: CreateWorkflowRequest;
+};
+/**
+ * Route a submission: agent work now is an assistant query, a plain to-do or reminder creates work,
+ * every other start creates a workflow.
+ * `forceWorkflow` is for the workflow dialog, where even a reminder is saved as a workflow.
+ */
+export declare function taskComposerToCreateRequest(ctx: TaskRequestContext, workspaceId: string | undefined, forceWorkflow?: boolean): ComposerCreate;
 /**
- * The create request for a composer submission. An agent task is bound to `workspaceId` (throws
- * when there is none); a reminder is not. A run-now task is a one-time task due immediately: the
- * host starts it explicitly with `useRunTask` after creating it.
+ * The patch for editing a task (`PATCH /v1/conversation/{id}`): title, description, due date, sign-off
+ * person, parent (`null` detaches) and sharing. What the agent was told to do stays as created.
  */
-export declare function taskComposerToCreateRequest({ workflow, values }: TaskRequestContext, workspaceId: string | undefined): CreateTaskRequest;
-/** The patch for editing a task (the trigger kind, workspace and agent stay as created). */
-export declare function taskComposerToUpdateRequest({ workflow, values, }: TaskRequestContext): UpdateTaskRequest;
+export declare function taskComposerToUpdateRequest({ values, plan, }: TaskRequestContext): UpdateConversationRequest;
+/** The patch for editing a workflow: name, trigger (the other triggers are cleared) and action. */
+export declare function composerToWorkflowUpdate({ workflow, values, plan, documentTitles, }: TaskRequestContext): UpdateWorkflowRequest;
 /** Does the task need the owner to authorise workspace access before it can run? */
-export declare const taskNeedsAccess: (task: Pick<TaskResponse, "pending_auth_request_id">) => boolean;
+export declare const taskNeedsAccess: (task: Pick<ConversationResponse, "pending_auth_request_id">) => boolean;
 export interface TaskValuesWorkflows {
     /** The workflow that stands for an instruction task (its first input is `instruction`). */
     customWorkflowId: string;
     /** The workflow that stands for a reminder (its first input is `message`). */
     reminderWorkflowId: string;
+    /** The definitions a saved skill can be matched to (by `skill`), to restore a skill workflow's form. */
+    definitions?: WorkflowDefinition[];
+}
+/** What an existing task (a conversation with a status) looks like when reopened in the composer. */
+export declare function taskToComposerValues(task: ConversationResponse, workflows: TaskValuesWorkflows): Partial<TaskComposerValues>;
+/** Which start a saved workflow has. */
+export declare function workflowWhen(workflow: WorkflowResponse): TaskWhen;
+/** What an existing workflow looks like when reopened in the workflow dialog. */
+export declare function workflowToComposerValues(workflow: WorkflowResponse, workflows: TaskValuesWorkflows): Partial<TaskComposerValues>;
+/** What the New task dialog collects: a prompt, who sees it, and optional task details. */
+export interface NewThreadValues {
+    /** What to ask or get done: the first message, which the assistant answers. The title is made from it. */
+    prompt: string;
+    /** A name instead of the generated one. Optional. */
+    title: string;
+    /** Shared with the workspace's members (the default), or private to its creator. */
+    shared: boolean;
+    /** The person who has the next step (`usr-…`); `''` = me. A task field. */
+    ownerId: string;
+    /** datetime-local value; empty = none. A task field. */
+    dueAt: string;
+    /** The task this is a sub-task of (`con-…`); `''` = none. A task field. */
+    parentId: string;
+    /** Whether the assistant starts on the prompt now. Off: it is a to-do, tracked and not run. */
+    assistant: boolean;
+}
+export declare const EMPTY_NEW_THREAD: NewThreadValues;
+/** Is any task detail filled in (the dialog opens its details when one is preset)? */
+export declare const hasTaskFields: (v: NewThreadValues) => boolean;
+/** A new task: the prompt as the first message (the assistant answers it) and the task's options. */
+export interface NewThreadRequest {
+    input: string;
+    shared: boolean;
+    task: TaskOptions;
+    /** False: nothing is asked of the assistant: the host adds a plain to-do from `todo`. */
+    startAssistant: boolean;
+    /** The to-do to add when `startAssistant` is false: a title and the rest of what the person wrote. */
+    todo?: {
+        title: string;
+        description: string;
+    };
 }
-/** What an existing task looks like when reopened in the composer. */
-export declare function taskToComposerValues(task: TaskResponse, workflows: TaskValuesWorkflows): Partial<TaskComposerValues>;
+/** The first line of a prompt, kept to a title's length. */
+export declare function titleFromPrompt(prompt: string, max?: number): string;
+/**
+ * The request for a New task submission. Every ask is a task, so the options always ride along; the owner,
+ * due date and parent are only set when filled in. The title is only sent when the person wrote one;
+ * otherwise the server names the task from the prompt. With the assistant switched off nothing is run: it
+ * is a to-do.
+ */
+export declare function newThreadToRequest(values: NewThreadValues): NewThreadRequest;
 export {};

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

@@ -0,0 +1,111 @@
+import { type TaskStatusKey } from './taskLabels';
+/**
+ * The deepest a task may nest, counting the top-level task as level 1 (a task, its sub-tasks, their
+ * sub-tasks, and so on). The table indents no further than the last level, and "Move to…" offers
+ * only parents that keep the moved subtree within it. The backend is asked to enforce the same cap.
+ */
+export declare const MAX_TASK_DEPTH = 5;
+/**
+ * The fields of a task the table reads. A task is a conversation with a `status`
+ * (`GET /v1/conversation/list`); callers' richer conversation types are accepted as-is, and the
+ * host keeps only the rows whose `status` is set (a chat has none).
+ */
+export interface TaskListRow {
+    external_id: string;
+    /** The conversation title; null until a run (which holds the key) names it. */
+    title?: string | null;
+    description?: string | null;
+    /** `todo | generating | ready_for_review | done`; null for a plain chat. */
+    status?: string | null;
+    in_progress?: boolean | null;
+    run_started_at?: string | null;
+    due_at?: string | null;
+    last_error?: string | null;
+    /** Set while a run waits for the owner to grant access. */
+    pending_auth_request_id?: string | null;
+    goal_state?: unknown;
+    /** Shared with the workspace's members (false = private to its owner). */
+    is_shared?: boolean | null;
+    /** False for a teammate's shared task: they can finish it, but not run, edit or delete it. */
+    is_owner?: boolean | null;
+    /** The person who created the task (it is assigned to them when no agent works on it). */
+    owner_ext_id?: string | null;
+    /** The task this is a sub-task of. */
+    parent_conversation_ext_id?: string | null;
+    /** The workflow that created it, if any. */
+    workflow_ext_id?: string | null;
+    /** The agent that prepares the work (none for a plain to-do). */
+    agent_ext_id?: string | null;
+    skill_ref?: string | null;
+    /** The person who signs the task off; `can_signoff` is true when that is the viewer. */
+    signoff_ext_id?: string | null;
+    can_signoff?: boolean | null;
+    /** Who started the thread. */
+    created_by_ext_id?: string | null;
+    message_count?: number | null;
+    updated_at?: string | null;
+}
+/**
+ * Who has the next step on a task: its sign-off person if there is one, else its creator. They are
+ * notified when the previous step finishes, and they approve. Not necessarily the creator, and never
+ * the agent that did the work.
+ */
+export declare const ownerExtId: (task: TaskListRow) => string | null;
+/** A plain to-do (no agent, no skill): a person marks it done without a review. */
+export declare const isPlainTodo: (task: TaskListRow) => boolean;
+export type TaskFilter = 'all' | TaskStatusKey;
+/** One line of the table: a task, how deep it sits under its parent and what its children add up to. */
+export interface TaskGridRow<T extends TaskListRow> {
+    external_id: string;
+    task: T;
+    depth: number;
+    /** Present when the task has sub-tasks (all of them, whatever the filter shows). */
+    childStats?: {
+        done: number;
+        total: number;
+    };
+    expanded: boolean;
+    parentId: string | null;
+    /** Number of siblings shown at this level, and this row's 1-based place among them. */
+    setSize: number;
+    posInSet: number;
+    /** Shown only as the ancestor of a match (the filter or search did not select it itself). */
+    context: boolean;
+}
+/** The parent/child index of a task list. A parent that is not in the list (hidden, deleted) is ignored. */
+export interface TaskTree<T extends TaskListRow> {
+    byId: Map<string, T>;
+    kids: Map<string, T[]>;
+    parentOf: Map<string, string>;
+}
+export declare function indexTasks<T extends TaskListRow>(tasks: T[]): TaskTree<T>;
+/** Every task below `id`, at any depth (collapsed or filtered out included), without repeats. */
+export declare function descendantIds<T extends TaskListRow>(tree: TaskTree<T>, id: string): string[];
+/**
+ * The tasks `task` can be moved under: any other task that is not one of its own descendants and
+ * keeps the moved subtree within {@link MAX_TASK_DEPTH}.
+ */
+export declare function moveTargets<T extends TaskListRow>(tasks: T[], task: T): T[];
+export interface BuildTaskRowsOptions<T extends TaskListRow> {
+    /** Case-insensitive text matched against the title and description. */
+    query?: string;
+    /** The text shown for a task (defaults to its title): what the search reads. */
+    titleOf?: (task: T) => string;
+    /**
+     * Rows built last time, by id. A row whose task, depth, place and counts are unchanged is reused
+     * (same object), so the grid only refreshes the rows that really changed. Updated in place.
+     */
+    cache?: Map<string, TaskGridRow<T>>;
+}
+/**
+ * The table's lines, in order. The full view is the sub-task forest grouped by the status of each root
+ * (what needs review first, then what an agent is generating, to-dos, and finally what is done). A
+ * status filter or a search keeps every match together with its ancestors, which show as `context`
+ * rows rather than leaving their children orphaned. A task whose parent is not in the list (not
+ * visible, or deleted) is top-level, and a collapsed task hides its sub-tasks.
+ *
+ * With `compare` (the user sorted a column) tasks are sorted within their own level: roots among roots
+ * (no longer grouped by status) and each task's sub-tasks among themselves, so a sub-task never leaves
+ * its parent. AG Grid cannot do this itself without its Enterprise tree data.
+ */
+export declare function buildTaskRows<T extends TaskListRow>(tasks: T[], filter: TaskFilter, collapsed: ReadonlySet<string>, compare?: (a: T, b: T) => number, options?: BuildTaskRowsOptions<T>): TaskGridRow<T>[];

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

@@ -0,0 +1,64 @@
+import type { TaskStatusKey } from './taskLabels';
+export interface TaskListLabels {
+    agent: string;
+    filterAll: string;
+    emptyTitle: string;
+    emptyMessage: string;
+    noMatches: string;
+    due: (when: string) => string;
+    overdue: (when: string) => string;
+    colTask: string;
+    colOwner: string;
+    ownerHint: string;
+    colOutputs: string;
+    changeOwner: string;
+    changeOwnerTitle: (taskName: string) => string;
+    changeOwnerMe: string;
+    preparedBy: (agentName: string) => string;
+    colDue: string;
+    colStatus: string;
+    me: string;
+    someone: string;
+    noDue: string;
+    colShared: string;
+    shared: string;
+    sharedOwnerOnly: string;
+    deleteOwnerOnly: string;
+    goalMet: (met: number, total: number) => string;
+    subtasksDone: (done: number, total: number) => string;
+    expandSubtasks: string;
+    collapseSubtasks: string;
+    selectAll: string;
+    selectTask: (name: string) => string;
+    markDone: string;
+    reopen: string;
+    markDoneMany: string;
+    markDoneManyHint: string;
+    deleteMany: string;
+    approve: string;
+    moveTo: string;
+    untitled: string;
+    fromWorkflow: (workflowName: string) => string;
+    searchLabel: string;
+    searchPlaceholder: string;
+    expandAll: string;
+    collapseAll: string;
+    moveToTitle: (taskName: string) => string;
+    moveToNone: string;
+    moveToSearch: string;
+    moveToEmpty: string;
+    moveToCancel: string;
+    subtasksSelected: (count: number) => string;
+    addSubtask: string;
+    edit: string;
+    rename: string;
+    delete: string;
+    grantAccess: string;
+    allowAccess: string;
+    moreActions: string;
+    activity: string;
+    /** Status tooltip: the latest step, how long ago, and who it is for. */
+    statusHint: (status: string, ago: string, forWho?: string) => string;
+    status: Partial<Record<TaskStatusKey, string>>;
+}
+export declare const DEFAULT_TASK_LIST_LABELS: TaskListLabels;

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

@@ -0,0 +1,23 @@
+/**
+ * Column definitions for the Workflows grid. Every column has an explicit `colId` (AG Grid persists
+ * column state by id: see CLAUDE.md). The table supplies the cells that need behaviour through slots,
+ * which must be stable functions so the definitions are built once.
+ */
+import type { ReactNode } from 'react';
+import type { ColDef } from 'ag-grid-community';
+import { type WorkflowListRow } from './workflowRows';
+import type { WorkflowListLabels } from './workflowTableLabels';
+export declare const WORKFLOW_COLUMN_ORDER: readonly ["name", "trigger", "last_run", "status", "shared", "actions"];
+export type WorkflowColumnId = (typeof WORKFLOW_COLUMN_ORDER)[number];
+export interface CreateWorkflowColumnsOptions<T extends WorkflowListRow> {
+    labels: WorkflowListLabels;
+    renderName: (workflow: T) => ReactNode;
+    renderTrigger: (workflow: T) => ReactNode;
+    renderStatus: (workflow: T) => ReactNode;
+    renderShared: (workflow: T) => ReactNode;
+    renderLastRun: (workflow: T) => ReactNode;
+    renderActions: (workflow: T) => ReactNode;
+    /** Plain text of the trigger cell, for sorting and the clipboard. */
+    getTriggerText: (workflow: T) => string;
+}
+export declare function createWorkflowColumns<T extends WorkflowListRow>(o: CreateWorkflowColumnsOptions<T>): ColDef<T>[];

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

@@ -0,0 +1,44 @@
+import type { WorkflowTriggerType } from './taskLabels';
+/**
+ * A row of the Workflows table: a saved workflow, or a skill (a virtual row: skills are global, not in
+ * the workflows table, and run on demand). Callers' richer types (`WorkflowResponse`) are accepted as-is.
+ */
+export interface WorkflowListRow {
+    external_id: string;
+    name: string;
+    /** `skill` for a skill row; anything else is a saved workflow. */
+    kind?: 'workflow' | 'skill' | null;
+    description?: string | null;
+    /** Active: the trigger can start it. A spent one-shot pauses itself. Skills ignore it. */
+    active: boolean;
+    /** Shared with the workspace's members (false = private to its owner). */
+    shared?: boolean | null;
+    rrule?: string | null;
+    run_at?: string | null;
+    event_kind?: string | null;
+    after_conversation_ext_id?: string | null;
+    /** No trigger of its own: it only runs when someone presses Run. */
+    on_demand?: boolean | null;
+    prompt?: string | null;
+    skill_ref?: string | null;
+    agent_ext_id?: string | null;
+    last_fired_at?: string | null;
+    next_fire_at?: string | null;
+    last_error?: string | null;
+    /** False for a teammate's shared workflow: they can see it, but not change who sees it or delete it. */
+    is_owner?: boolean | null;
+    owner_ext_id?: string | null;
+    /** The user who created it (for the creator-or-workspace-owner rule). */
+    created_by_ext_id?: string | null;
+}
+export type WorkflowStatusKey = 'active' | 'paused' | 'on_demand';
+export declare const isSkillRow: (row: WorkflowListRow) => boolean;
+/** Does it start by itself (a time, a repeat, an event, or another task finishing)? */
+export declare const hasTrigger: (row: WorkflowListRow) => boolean;
+/**
+ * What a row is doing: a skill, or a workflow with no trigger of its own, only runs when someone presses
+ * Run (`on_demand`, no on/off switch); one with a trigger is `active` or `paused`.
+ */
+export declare function workflowStatus(row: WorkflowListRow): WorkflowStatusKey;
+/** What starts a workflow: another task being done, an event, a repeat, a single moment, or nothing. */
+export declare function workflowTriggerType(workflow: WorkflowListRow): WorkflowTriggerType;

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

@@ -0,0 +1,53 @@
+export interface WorkflowListLabels {
+    colName: string;
+    colType: string;
+    colTrigger: string;
+    colAction: string;
+    colAgent: string;
+    colStatus: string;
+    colShared: string;
+    colLastRun: string;
+    colNextRun: string;
+    shared: string;
+    sharedOwnerOnly: string;
+    deleteOwnerOnly: string;
+    typeSkill: string;
+    typeWorkflow: string;
+    statusActive: string;
+    statusPaused: string;
+    statusOnDemand: string;
+    activeSwitch: (name: string) => string;
+    agent: string;
+    myAssistant: string;
+    me: string;
+    someone: string;
+    never: string;
+    none: string;
+    reminder: string;
+    failed: string;
+    lastRunFailed: string;
+    openLastRun: string;
+    editWorkflow: string;
+    run: string;
+    runLater: string;
+    runNow: string;
+    runs: string;
+    delete: string;
+    moreActions: string;
+    searchLabel: string;
+    searchPlaceholder: string;
+    emptyTitle: string;
+    emptyMessage: string;
+    firstRun: string;
+    noMatches: string;
+    filterAll: string;
+    filterSkills: string;
+    filterWorkflows: string;
+    filterActive: string;
+    filterPaused: string;
+    makeActive: string;
+    makePaused: string;
+    selectAll: string;
+    selectWorkflow: (name: string) => string;
+}
+export declare const DEFAULT_WORKFLOW_LIST_LABELS: WorkflowListLabels;

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

@@ -11,6 +11,11 @@ export interface WorkflowScopeSource {
     totalCount: number;
     /** How many files a scope selects. */
     countMatching: (scope: WorkflowScope) => number;
+    /**
+     * The ids of the files a scope selects. A run is bound to explicit file ids, so a folder/label pick is
+     * resolved here, on the client, before anything is sent.
+     */
+    resolveDocuments?: (scope: WorkflowScope) => string[];
 }
 export interface WorkflowConfigDialogLabels {
     /** Primary button when the workflow gives no label of its own. */

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

@@ -3,4 +3,5 @@ export { composeWorkflowPrompt, buildLaunch, defaultInputs, validateInputs, isWo
 export { SchemaForm, DEFAULT_SCHEMA_FORM_LABELS, type SchemaFormProps, type SchemaFormLabels, } from './SchemaForm';
 export { AgentSelect, DEFAULT_AGENT_SELECT_LABELS, type AgentSelectProps, type AgentSelectLabels, type AgentOption, } from './AgentSelect';
 export { WorkflowConfigDialog, DEFAULT_WORKFLOW_CONFIG_DIALOG_LABELS, type WorkflowConfigDialogProps, type WorkflowConfigDialogLabels, type WorkflowScopeSource, } from './WorkflowConfigDialog';
+export { defaultScopeRenderer, resolveScopeInputs } from './scopeRender';
 export { WorkflowLauncher, type WorkflowLauncherProps } from './WorkflowLauncher';

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

@@ -0,0 +1,10 @@
+import type { ReactNode } from 'react';
+import type { WorkflowScopeSource } from './WorkflowConfigDialog';
+import type { WorkflowDefinition, WorkflowField, WorkflowInputs, WorkflowScope } from './types';
+/** The folder/label picker over the workspace's files: what a `scope` field renders by default. */
+export declare function defaultScopeRenderer(scopeSource: WorkflowScopeSource | undefined): ((field: WorkflowField, value: WorkflowScope, onChange: (s: WorkflowScope) => void) => ReactNode) | undefined;
+/**
+ * The inputs with every `scope` field resolved to explicit file ids (`documents`), so what is sent says
+ * exactly which files a run is bound to. The folders and labels stay, for showing the pick again.
+ */
+export declare function resolveScopeInputs(workflow: Pick<WorkflowDefinition, 'inputs'>, inputs: WorkflowInputs, scopeSource: Pick<WorkflowScopeSource, 'resolveDocuments'> | undefined): WorkflowInputs;

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

@@ -100,6 +100,8 @@ export interface WorkflowDefinition {
     requiresFiles?: boolean;
     /** Default agent; absent = the user's own assistant. */
     defaultAgentId?: string;
+    /** A free-form entry ("my own instruction", "remind me"), not a named skill: it does not name the dialog. */
+    generic?: boolean;
     /** Can be the body of a task (unattended). `action` workflows are not. */
     schedulable?: boolean;
     /** Run options the form offers (all shown by default). */

package/dist/chat/AssistantModeToggle.d.ts

@@ -0,0 +1,25 @@
+/** When the assistant answers in a conversation (the API's `AssistantMode`). */
+export type AssistantMode = 'always' | 'mentioned';
+/** Every fixed string of the toggle. Pass a partial `labels` to reword. */
+export interface AssistantModeToggleLabels {
+    always: string;
+    mentioned: string;
+    /** Tooltip / accessible description per mode. */
+    alwaysHint: string;
+    mentionedHint: string;
+}
+export declare const DEFAULT_ASSISTANT_MODE_TOGGLE_LABELS: AssistantModeToggleLabels;
+export interface AssistantModeToggleProps {
+    mode: AssistantMode;
+    onModeChange: (mode: AssistantMode) => void;
+    disabled?: boolean;
+    labels?: Partial<AssistantModeToggleLabels>;
+    className?: string;
+    /** Test id (default `assistant-mode-toggle`); the current mode lands on `data-mode`. */
+    testId?: string;
+}
+/**
+ * Composer-toolbar switch between an ordinary chat (`always`: every message gets an answer) and a
+ * thread (`mentioned`: the assistant only answers when @mentioned).
+ */
+export declare function AssistantModeToggle({ mode, onModeChange, disabled, labels, className, testId, }: AssistantModeToggleProps): import("react").JSX.Element;

package/dist/chat/MentionMenu.d.ts

@@ -0,0 +1,52 @@
+import type { MentionCandidate, MentionKind } from './mentions';
+/** Every fixed string of the mention menu and chips. Pass a partial `labels` to reword. */
+export interface MentionLabels {
+    hint: string;
+    /** Accessible name of the list. */
+    list: string;
+    /** Polite count announced as the menu opens or narrows. */
+    resultCount: (count: number) => string;
+    /** Badge next to the assistant row. */
+    assistantBadge: string;
+    /** Chip tooltip: who a mention points at. */
+    chipTitle: (label: string, kind: MentionKind) => string;
+}
+export declare const DEFAULT_MENTION_LABELS: MentionLabels;
+export interface MentionMenuProps {
+    open: boolean;
+    /** The chat composer sits at the bottom (menu above); a top-of-page field opens below. */
+    placement?: 'above' | 'below';
+    items: ReadonlyArray<MentionCandidate>;
+    /** Highlighted row (see `useListKeyNav`). */
+    selectedIndex: number;
+    setSelectedIndex: (i: number) => void;
+    /** Listbox id from `useListKeyNav`, so the textarea's `aria-controls` points here. */
+    listboxId?: string;
+    onSelect: (item: MentionCandidate) => void;
+    className?: string;
+    labels?: Partial<MentionLabels>;
+    /** Test id of the menu (default `mention-menu`). */
+    testId?: string;
+    /** Row prefix (`<prefix>-<id>`); default `mention-item`. */
+    itemTestIdPrefix?: string;
+}
+/**
+ * `@mention` autocomplete that floats over the composer. Presentational: the host (or
+ * {@link useMentionAutocomplete}) owns the query, the candidates and what picking does.
+ */
+export declare const MentionMenu: import("react").NamedExoticComponent<MentionMenuProps>;
+export interface MentionChipProps {
+    /** Text shown after the `@`. */
+    label: string;
+    kind: MentionKind;
+    /** Mentioned user's id (or `assistant`); lands on `data-mention-id`. */
+    id?: string;
+    /** Highlights a mention of the person reading. */
+    isSelf?: boolean;
+    labels?: Partial<MentionLabels>;
+    className?: string;
+    /** Test id; default `mention-chip-<id>`. */
+    testId?: string;
+}
+/** An `@mention` inside message text. Inline, so it sits in a markdown paragraph. */
+export declare function MentionChip({ label, kind, id, isSelf, labels, className, testId, }: MentionChipProps): import("react").JSX.Element;