@kortix/ui 0.14.12 → 0.14.14

package/dist/session/tool/tools/workflow-run.d.ts

@@ -0,0 +1,128 @@
+/**
+ * The `workflow` tool's part metadata, parsed defensively, and the pure helpers
+ * its card draws from.
+ *
+ * The shape is `WorkflowRunMetadata` in `packages/api-contract/src/kortix-tool-card.ts`.
+ * `@kortix/ui` does not depend on that package, so the types are mirrored here
+ * and every field is checked. pi pushes it live with every change of the run,
+ * and the final copy when the call returns.
+ */
+export type WorkflowRunStatus = 'running' | 'done' | 'failed' | 'stopped';
+/** `pending`: declared in the script's `meta.phases`, not started yet. */
+export type WorkflowPhaseStatus = WorkflowRunStatus | 'pending';
+export type WorkflowAgentStatus = 'starting' | 'running' | 'done' | 'failed' | 'stopped';
+export interface WorkflowRunPhase {
+    title: string;
+    status: WorkflowPhaseStatus;
+}
+export interface WorkflowRunAgent {
+    id: string;
+    label: string;
+    agent?: string;
+    phase?: string;
+    status: WorkflowAgentStatus;
+    sessionId?: string;
+    summary?: string;
+    /** Resumed run: the saved result of the earlier run was reused; no session started. */
+    cached?: true;
+    /** The model the script asked for. */
+    model?: string;
+    /** The answer is JSON checked against a schema. */
+    structured?: true;
+    /** 1 for the first attempt; a stalled agent restarts with the same prompt. */
+    attempt?: number;
+    /** Epoch ms. */
+    startedAt?: number;
+    endedAt?: number;
+}
+export interface WorkflowRun {
+    runId: string;
+    title: string;
+    status: WorkflowRunStatus;
+    phases: WorkflowRunPhase[];
+    agents: WorkflowRunAgent[];
+    startedAt?: number;
+    endedAt?: number;
+    error?: string;
+    /** The most agents this run may start. */
+    maxAgents?: number;
+    /** A saved workflow run by name. */
+    name?: string;
+    /** The script's newest `log()` lines, oldest first. */
+    logs: string[];
+    /** More than 25 agents: the card warns, as Claude Code's "Large workflow". */
+    large?: true;
+    /** The run this one resumed. */
+    resumedFrom?: string;
+    /** The run goes on in its own runner session; this call returned at once. */
+    background?: {
+        sessionId: string;
+    };
+    /** `pause` held new agents back; running agents finish. Cleared by `resume`. */
+    paused?: true;
+}
+/** The run in a `workflow` call's metadata; `null` when the metadata is not a run. */
+export declare function parseWorkflowRun(metadata: unknown): WorkflowRun | null;
+/** True for pi's `workflow` tool, under any of its spellings, and for no other name ending in `workflow`. */
+export declare function isWorkflowTool(name: string): boolean;
+/** The filter of the agent list, as Claude Code's `f` cycles it. */
+export type AgentFilter = 'all' | 'running' | 'failed' | 'done';
+export declare const AGENT_FILTERS: readonly AgentFilter[];
+/** Whether an agent belongs under a filter. `stopped` is listed under `all` only. */
+export declare function agentMatches(agent: WorkflowRunAgent, filter: AgentFilter): boolean;
+export interface AgentCounts {
+    total: number;
+    running: number;
+    failed: number;
+    done: number;
+}
+export declare function countAgents(agents: readonly WorkflowRunAgent[]): AgentCounts;
+/** One group of the progress list: a phase and its agents, or the agents started before any phase. */
+export interface AgentGroup {
+    /** `null`: the agents that belong to no phase. They come first and have no header. */
+    phase: WorkflowRunPhase | null;
+    agents: WorkflowRunAgent[];
+}
+/**
+ * The agents grouped under their phases, in the run's phase order. An agent whose
+ * phase the list does not name gets a group of its own after the named ones, as a
+ * `phase()` title with no `meta.phases` entry does in Claude Code.
+ */
+export declare function groupAgents(run: Pick<WorkflowRun, 'phases' | 'agents'>): AgentGroup[];
+/** `12s`, `3m 04s`, `1h 05m`. Seconds and minutes are zero-padded so a ticking label keeps its width. */
+export declare function formatElapsed(ms: number): string;
+/** How long a run or an agent took, or has taken by `now`; undefined when its start is unknown or it never ran. */
+export declare function elapsedMs(item: {
+    startedAt?: number;
+    endedAt?: number;
+}, live: boolean, now: number): number | undefined;
+export type StructuredSummary = {
+    kind: 'object';
+    keys: number;
+    pretty: string;
+} | {
+    kind: 'array';
+    items: number;
+    pretty: string;
+} | {
+    kind: 'value';
+    pretty: string;
+} | {
+    kind: 'text';
+    pretty: string;
+};
+/** A `structured` agent's summary: the JSON it holds, or its text when it does not parse (a cut answer). */
+export declare function structuredSummary(summary: string): StructuredSummary;
+export type WorkflowResult = {
+    kind: 'json';
+    text: string;
+} | {
+    kind: 'markdown';
+    text: string;
+};
+/**
+ * The script's return value in a finished call's output (`<workflow_result>…</workflow_result>`):
+ * pretty JSON when it parses as an object or a list, else Markdown. Null when the output has no
+ * result block (an older run, or a run that failed).
+ */
+export declare function parseWorkflowResult(output: string): WorkflowResult | null;

package/dist/session/tool/tools/workflow-run.js

@@ -0,0 +1,251 @@
+/**
+ * The `workflow` tool's part metadata, parsed defensively, and the pure helpers
+ * its card draws from.
+ *
+ * The shape is `WorkflowRunMetadata` in `packages/api-contract/src/kortix-tool-card.ts`.
+ * `@kortix/ui` does not depend on that package, so the types are mirrored here
+ * and every field is checked. pi pushes it live with every change of the run,
+ * and the final copy when the call returns.
+ */
+const RUN_STATUSES = new Set(['running', 'done', 'failed', 'stopped']);
+const PHASE_STATUSES = new Set(['pending', 'running', 'done', 'failed', 'stopped']);
+const AGENT_STATUSES = new Set(['starting', 'running', 'done', 'failed', 'stopped']);
+/** A run's rows stay a list a person can read; the rest is the session list's job. */
+const MAX_AGENTS = 200;
+/** The contract sends at most 5 `log()` lines; a longer list keeps the newest 5. */
+const MAX_LOGS = 5;
+const MAX_LOG_CHARS = 500;
+const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const text = (value) => typeof value === 'string' && value.trim() ? value.trim() : undefined;
+const time = (value) => typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+const count = (value) => typeof value === 'number' && Number.isFinite(value) && value >= 1 ? Math.floor(value) : undefined;
+function phase(entry) {
+    if (!isObject(entry))
+        return undefined;
+    const title = text(entry.title);
+    return title && PHASE_STATUSES.has(entry.status)
+        ? { title, status: entry.status }
+        : undefined;
+}
+function agent(entry, index) {
+    if (!isObject(entry) || !AGENT_STATUSES.has(entry.status))
+        return undefined;
+    const label = text(entry.label) ?? text(entry.agent);
+    if (!label)
+        return undefined;
+    const name = text(entry.agent);
+    const phaseTitle = text(entry.phase);
+    const sessionId = text(entry.sessionId);
+    const summary = text(entry.summary);
+    const model = text(entry.model);
+    const attempt = count(entry.attempt);
+    const startedAt = time(entry.startedAt);
+    const endedAt = time(entry.endedAt);
+    return {
+        id: text(entry.id) ?? `a${index + 1}`,
+        label,
+        ...(name ? { agent: name } : {}),
+        ...(phaseTitle ? { phase: phaseTitle } : {}),
+        status: entry.status,
+        ...(sessionId ? { sessionId } : {}),
+        ...(summary ? { summary } : {}),
+        ...(entry.cached === true ? { cached: true } : {}),
+        ...(model ? { model } : {}),
+        ...(entry.structured === true ? { structured: true } : {}),
+        ...(attempt !== undefined ? { attempt } : {}),
+        ...(startedAt !== undefined ? { startedAt } : {}),
+        ...(endedAt !== undefined ? { endedAt } : {}),
+    };
+}
+function logs(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map((line) => text(line))
+        .filter((line) => line !== undefined)
+        .slice(-MAX_LOGS)
+        .map((line) => line.slice(0, MAX_LOG_CHARS));
+}
+/** The run in a `workflow` call's metadata; `null` when the metadata is not a run. */
+export function parseWorkflowRun(metadata) {
+    if (!isObject(metadata))
+        return null;
+    // A background call that handed its run to a runner may say `started`: the run runs.
+    if (metadata.status === 'started')
+        metadata = { ...metadata, status: 'running', agents: Array.isArray(metadata.agents) ? metadata.agents : [] };
+    if (!isObject(metadata) || !RUN_STATUSES.has(metadata.status))
+        return null;
+    if (!Array.isArray(metadata.agents))
+        return null;
+    const agents = [];
+    for (const [index, entry] of metadata.agents.slice(0, MAX_AGENTS).entries()) {
+        const parsed = agent(entry, index);
+        if (parsed)
+            agents.push(parsed);
+    }
+    const phases = Array.isArray(metadata.phases)
+        ? metadata.phases.map(phase).filter((p) => p !== undefined)
+        : [];
+    const startedAt = time(metadata.startedAt);
+    const endedAt = time(metadata.endedAt);
+    const error = text(metadata.error);
+    const maxAgents = count(metadata.maxAgents);
+    const name = text(metadata.name);
+    const resumedFrom = text(metadata.resumedFrom);
+    // A background run names its runner session as `background.sessionId`, or (a started call's
+    // details) as `runnerSessionId` / `runner_session_id`.
+    const backgroundSession = (isObject(metadata.background) ? text(metadata.background.sessionId) : undefined) ??
+        text(metadata.runnerSessionId) ??
+        text(metadata.runner_session_id);
+    return {
+        runId: text(metadata.runId) ?? '',
+        title: text(metadata.title) ?? '',
+        status: metadata.status,
+        phases,
+        agents,
+        ...(startedAt !== undefined ? { startedAt } : {}),
+        ...(endedAt !== undefined ? { endedAt } : {}),
+        ...(error ? { error } : {}),
+        ...(maxAgents !== undefined ? { maxAgents } : {}),
+        ...(name ? { name } : {}),
+        logs: logs(metadata.logs),
+        ...(metadata.large === true ? { large: true } : {}),
+        ...(resumedFrom ? { resumedFrom } : {}),
+        ...(backgroundSession ? { background: { sessionId: backgroundSession } } : {}),
+        ...(metadata.paused === true ? { paused: true } : {}),
+    };
+}
+/** True for pi's `workflow` tool, under any of its spellings, and for no other name ending in `workflow`. */
+export function isWorkflowTool(name) {
+    return name.replace(/^oc[-_]/, '') === 'workflow';
+}
+export const AGENT_FILTERS = ['all', 'running', 'failed', 'done'];
+/** Whether an agent belongs under a filter. `stopped` is listed under `all` only. */
+export function agentMatches(agent, filter) {
+    switch (filter) {
+        case 'all':
+            return true;
+        case 'running':
+            return agent.status === 'starting' || agent.status === 'running';
+        case 'failed':
+            return agent.status === 'failed';
+        case 'done':
+            return agent.status === 'done';
+    }
+}
+export function countAgents(agents) {
+    const counts = { total: agents.length, running: 0, failed: 0, done: 0 };
+    for (const agent of agents) {
+        if (agentMatches(agent, 'running'))
+            counts.running += 1;
+        else if (agent.status === 'failed')
+            counts.failed += 1;
+        else if (agent.status === 'done')
+            counts.done += 1;
+    }
+    return counts;
+}
+/**
+ * The agents grouped under their phases, in the run's phase order. An agent whose
+ * phase the list does not name gets a group of its own after the named ones, as a
+ * `phase()` title with no `meta.phases` entry does in Claude Code.
+ */
+export function groupAgents(run) {
+    const loose = [];
+    const byPhase = new Map();
+    for (const phase of run.phases)
+        if (!byPhase.has(phase.title))
+            byPhase.set(phase.title, []);
+    const extra = [];
+    for (const agent of run.agents) {
+        if (!agent.phase) {
+            loose.push(agent);
+            continue;
+        }
+        let list = byPhase.get(agent.phase);
+        if (!list) {
+            list = [];
+            byPhase.set(agent.phase, list);
+            extra.push(agent.phase);
+        }
+        list.push(agent);
+    }
+    const groups = loose.length > 0 ? [{ phase: null, agents: loose }] : [];
+    const seen = new Set();
+    for (const phase of run.phases) {
+        if (seen.has(phase.title))
+            continue;
+        seen.add(phase.title);
+        groups.push({ phase, agents: byPhase.get(phase.title) ?? [] });
+    }
+    for (const title of extra) {
+        const agents = byPhase.get(title) ?? [];
+        groups.push({ phase: { title, status: derivedStatus(agents) }, agents });
+    }
+    return groups;
+}
+function derivedStatus(agents) {
+    if (agents.some((agent) => agentMatches(agent, 'running')))
+        return 'running';
+    if (agents.some((agent) => agent.status === 'failed'))
+        return 'failed';
+    return 'done';
+}
+// ── Time ─────────────────────────────────────────────────────────────────────
+/** `12s`, `3m 04s`, `1h 05m`. Seconds and minutes are zero-padded so a ticking label keeps its width. */
+export function formatElapsed(ms) {
+    const seconds = Math.max(0, Math.floor(ms / 1000));
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ${String(seconds % 60).padStart(2, '0')}s`;
+    return `${Math.floor(minutes / 60)}h ${String(minutes % 60).padStart(2, '0')}m`;
+}
+/** How long a run or an agent took, or has taken by `now`; undefined when its start is unknown or it never ran. */
+export function elapsedMs(item, live, now) {
+    if (item.startedAt === undefined)
+        return undefined;
+    if (item.endedAt !== undefined)
+        return Math.max(0, item.endedAt - item.startedAt);
+    return live ? Math.max(0, now - item.startedAt) : undefined;
+}
+/** A `structured` agent's summary: the JSON it holds, or its text when it does not parse (a cut answer). */
+export function structuredSummary(summary) {
+    try {
+        const value = JSON.parse(summary);
+        const pretty = JSON.stringify(value, null, 2);
+        if (Array.isArray(value))
+            return { kind: 'array', items: value.length, pretty };
+        if (isObject(value))
+            return { kind: 'object', keys: Object.keys(value).length, pretty };
+        return { kind: 'value', pretty };
+    }
+    catch {
+        return { kind: 'text', pretty: summary };
+    }
+}
+/**
+ * The script's return value in a finished call's output (`<workflow_result>…</workflow_result>`):
+ * pretty JSON when it parses as an object or a list, else Markdown. Null when the output has no
+ * result block (an older run, or a run that failed).
+ */
+export function parseWorkflowResult(output) {
+    const open = output.indexOf('<workflow_result>');
+    if (open === -1)
+        return null;
+    const start = open + '<workflow_result>'.length;
+    const close = output.indexOf('</workflow_result>', start);
+    const body = (close === -1 ? output.slice(start) : output.slice(start, close)).trim();
+    if (!body)
+        return null;
+    if (body.startsWith('{') || body.startsWith('[')) {
+        try {
+            return { kind: 'json', text: JSON.stringify(JSON.parse(body), null, 2) };
+        }
+        catch {
+            // A cut or hand-written block: show it as text.
+        }
+    }
+    return { kind: 'markdown', text: body };
+}

package/dist/session/tool/tools/workflow-tool.d.ts

@@ -0,0 +1,9 @@
+import type { ToolProps } from '../shared/types.js';
+import { type ProjectSession } from '@kortix/sdk';
+import { type WorkflowRun } from './workflow-run.js';
+/**
+ * A live run read from this session's children: each `agent()` is a child session named after
+ * its label, started after the call. Null until the first child exists.
+ */
+export declare function runFromChildren(children: ProjectSession[], startedMs: number, input: unknown): WorkflowRun | null;
+export declare function WorkflowTool(props: ToolProps): import("react").JSX.Element;

package/dist/session/tool/tools/workflow-tool.js

@@ -0,0 +1,253 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Badge } from '../../../primitives/badge.js';
+import { Hint } from '../../../primitives/hint.js';
+import { TextShimmer } from '../../../primitives/text-shimmer.js';
+import { errorToast } from '../../../primitives/toast.js';
+import { SubagentDialog } from '../../agents/subagent-view.js';
+import { GenericTool } from '../generic-tool.js';
+import { BasicTool, partError, partMetadata, partOutput, partStatus, ToolOutcomeContext, ToolRunningContext, useToolIndent, } from '../shared/infrastructure.js';
+import { FoldedSection, OutputBlock } from '../shared/output-block.js';
+import { ToolRegistry } from '../shared/registry.js';
+import { ToolError } from '../tool-error.js';
+import { useTranslations } from '../../../i18n/index.js';
+import { cn } from '../../../lib/utils.js';
+import { FlowArrowIcon } from '@phosphor-icons/react';
+import { useCallback, useContext, useEffect, useMemo, useState } from 'react';
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { qk, useProjectSession, useSessionChildren } from '@kortix/sdk/react';
+import { stopProjectSession } from '@kortix/sdk';
+import { useSessionIds } from '../../../providers/session-ids.js';
+import { WorkflowLogs, WorkflowProgress } from './workflow-progress.js';
+import { isLargeRun, LargeRunBadge, useLiveWorkflowRun, useRestartAgent, WorkflowRunControls, } from '../../agents/workflow-run-controls.js';
+import { countAgents, elapsedMs, formatElapsed, isWorkflowTool, parseWorkflowResult, parseWorkflowRun, } from './workflow-run.js';
+/**
+ * The card of pi's `workflow` tool: one script that runs several agents, each in
+ * its own child session. It is Claude Code's `/workflows` progress view, inside the chat.
+ *
+ * The run arrives as part metadata (`WorkflowRunMetadata` in
+ * `packages/api-contract/src/kortix-tool-card.ts`), pushed live with every change.
+ * The header says what runs and how far it got ("3 of 8 done · 1 failed · 2m 04s"),
+ * with a "Large run" chip past 25 agents and a "Resumed" chip for a relaunch. The
+ * body is the script's newest log lines, then the phases with their agents
+ * (`workflow-progress.tsx`): a row opens that agent's session in place, as a task
+ * row does (`SubagentDialog`), and a running row has a Stop button. A finished run
+ * folds the script's result away under "Result".
+ *
+ * A run started with `background: true` returned at once: its progress lives in its
+ * own runner session, so the card is one row that opens that session.
+ *
+ * A call that settled with metadata that is not a run renders as the generic card.
+ */
+function WorkflowTrigger({ title, subtitle, chips, live, }) {
+    return (_jsxs("div", { className: "flex min-w-0 flex-1 items-center gap-1.5 overflow-hidden text-sm", children: [live ? (_jsx(TextShimmer, { duration: 1, spread: 2, className: "min-w-0 truncate text-sm", children: title })) : (_jsx("span", { className: "text-foreground min-w-0 truncate", title: title, children: title })), chips, subtitle && (_jsx("span", { className: "text-muted-foreground min-w-0 flex-1 truncate tabular-nums", title: subtitle, children: subtitle }))] }));
+}
+function RunChips({ run }) {
+    const t = useTranslations('tools.workflow');
+    const large = isLargeRun(run);
+    if (!large && !run.resumedFrom)
+        return null;
+    return (_jsxs(_Fragment, { children: [run.resumedFrom && (_jsx(Hint, { label: t('resumedHint'), side: "top", children: _jsx(Badge, { variant: "default", children: t('resumed') }) })), large && _jsx(LargeRunBadge, {})] }));
+}
+/**
+ * The way into a run's own session, at the right edge of the header. A `span
+ * role="button"`: the header renders inside the row's own `role="button"`, and a
+ * button inside a button is invalid HTML (the task row's "Full view" is the same).
+ */
+function OpenRunAction({ onOpen }) {
+    const t = useTranslations('tools.workflow');
+    return (_jsx("span", { role: "button", tabIndex: 0, "aria-label": t('openRunLabel'), onClick: (event) => {
+            event.stopPropagation();
+            onOpen();
+        }, onKeyDown: (event) => {
+            if (event.key !== 'Enter' && event.key !== ' ')
+                return;
+            event.preventDefault();
+            event.stopPropagation();
+            onOpen();
+        }, className: "text-muted-foreground hover:text-foreground cursor-pointer text-xs whitespace-nowrap underline-offset-2 hover:underline", children: t('openRun') }));
+}
+/** The current time, every second while `active`: a live run's elapsed labels tick. */
+function useNow(active) {
+    const [now, setNow] = useState(() => Date.now());
+    useEffect(() => {
+        if (!active)
+            return;
+        const timer = setInterval(() => setNow(Date.now()), 1_000);
+        return () => clearInterval(timer);
+    }, [active]);
+    return now;
+}
+/**
+ * A live run read from this session's children: each `agent()` is a child session named after
+ * its label, started after the call. Null until the first child exists.
+ */
+export function runFromChildren(children, startedMs, input) {
+    const mine = children.filter((child) => !Number.isFinite(startedMs) || Date.parse(child.created_at) >= startedMs - 5_000);
+    if (mine.length === 0)
+        return null;
+    const description = typeof input?.description === 'string' ? input.description : '';
+    return {
+        runId: '',
+        title: description,
+        status: 'running',
+        phases: [],
+        logs: [],
+        ...(Number.isFinite(startedMs) ? { startedAt: startedMs } : {}),
+        agents: mine
+            .slice()
+            .sort((a, b) => Date.parse(a.created_at) - Date.parse(b.created_at))
+            .map((child, index) => {
+            const status = child.status === 'completed' ? 'done' : child.status === 'failed' ? 'failed' : 'running';
+            const created = Date.parse(child.created_at);
+            return {
+                id: `a${index + 1}`,
+                label: (child.name ?? '').replace(/\s*\([^)]*\)\s*$/, '') || child.agent_name || child.session_id.slice(0, 8),
+                ...(child.agent_name ? { agent: child.agent_name } : {}),
+                status,
+                sessionId: child.session_id,
+                // A child that settled has no end time in the list: only a running one shows its elapsed time.
+                ...(status === 'running' && Number.isFinite(created) ? { startedAt: created } : {}),
+            };
+        }),
+    };
+}
+export function WorkflowTool(props) {
+    const { call, defaultOpen, forceOpen, locked } = props;
+    const t = useTranslations('tools.workflow');
+    const tm = useTranslations('multiAgent.workflow');
+    const running = useContext(ToolRunningContext);
+    const status = partStatus(call);
+    const settled = status === 'completed' || status === 'error';
+    const metadata = partMetadata(call);
+    const parsed = useMemo(() => parseWorkflowRun(metadata), [metadata]);
+    // The session log carries a running call's run document only once the call settles, so a
+    // page that reads it (the v2 stream) has no live run. The run's agents are this session's
+    // children started since the call began: list them until the document arrives.
+    const ids = useSessionIds();
+    const startedMs = call.started_at ? Date.parse(call.started_at) : NaN;
+    const needChildren = !settled && !parsed && !!ids.projectId && !!ids.sessionId;
+    const { sessions: children } = useSessionChildren(ids.projectId ?? '', ids.sessionId ?? '', { enabled: needChildren, limit: 20 });
+    const cardRun = useMemo(() => parsed ?? (needChildren ? runFromChildren(children, startedMs, call.input) : null), [parsed, needChildren, children, startedMs, call.input]);
+    // A background run's progress lives on its runner's box: read it from there, so the card
+    // keeps updating after this session's turn ended (the call settled long ago).
+    const { run, controlSessionId, fromRunner } = useLiveWorkflowRun(ids.projectId, ids.sessionId, cardRun);
+    // A background run's own session: whether it still works says what the header reads.
+    const runner = useProjectSession(ids.projectId, run?.background?.sessionId, { enabled: !!run?.background && !fromRunner });
+    // Live: a foreground run while its call runs, or a background run its runner still runs.
+    const live = !!run && run.status === 'running' && (fromRunner || (!settled && !run.background && running));
+    const restart = useRestartAgent(ids.projectId, controlSessionId, live ? run : null);
+    const now = useNow(live);
+    const [open, setOpen] = useState(null);
+    const onOpen = useCallback((agent) => {
+        if (agent.sessionId)
+            setOpen({ sessionId: agent.sessionId, title: agent.agent ? `${agent.label} · ${agent.agent}` : agent.label });
+    }, []);
+    // Claude Code's `x` on an agent: stop that child session. The run sees the child stop and
+    // marks the agent `stopped`; until the next update the row shows the stop in flight.
+    const queryClient = useQueryClient();
+    const [stopping, setStopping] = useState(() => new Set());
+    const stopAgent = useMutation({
+        mutationFn: (agent) => stopProjectSession(ids.projectId, agent.sessionId),
+        onSuccess: () => {
+            if (ids.projectId)
+                void queryClient.invalidateQueries({ queryKey: qk.project.sessionsScope(ids.projectId) });
+        },
+        onError: (error, agent) => {
+            setStopping((previous) => {
+                const next = new Set(previous);
+                next.delete(agent.sessionId);
+                return next;
+            });
+            errorToast(t('stopFailed', { label: agent.label }), {
+                description: error instanceof Error ? error.message : undefined,
+            });
+        },
+    });
+    const { mutate: mutateStop } = stopAgent;
+    const { enabled: canRestart, restarting, restart: restartAgent } = restart;
+    const stop = useMemo(() => ({
+        enabled: !!ids.projectId,
+        pending: stopping,
+        stop: (agent) => {
+            if (!agent.sessionId)
+                return;
+            setStopping((previous) => new Set(previous).add(agent.sessionId));
+            mutateStop(agent);
+        },
+        ...(canRestart ? { restart: { pending: restarting, run: restartAgent } } : {}),
+    }), [ids.projectId, stopping, mutateStop, canRestart, restarting, restartAgent]);
+    if (!isWorkflowTool(call.name) || (settled && !run)) {
+        return _jsx(GenericTool, { call: call, defaultOpen: defaultOpen, forceOpen: forceOpen, locked: locked });
+    }
+    const icon = _jsx(FlowArrowIcon, { className: "size-4 shrink-0" });
+    if (!run) {
+        return (_jsx(BasicTool, { icon: icon, trigger: _jsx(WorkflowTrigger, { title: t('starting'), live: running }), defaultOpen: defaultOpen, forceOpen: forceOpen, locked: locked }));
+    }
+    const title = run.title || run.name || t('fallbackTitle');
+    const modal = open && (_jsx(SubagentDialog, { open: true, onOpenChange: (next) => {
+            if (!next)
+                setOpen(null);
+        }, sessionId: open.sessionId, title: open.title }));
+    if (run.background && !fromRunner) {
+        const runnerSession = run.background.sessionId;
+        const openRunner = () => setOpen({ sessionId: runnerSession, title });
+        const subtitle = runner.data?.working?.state === 'idle' ? t('backgroundIdle') : t('background');
+        return (_jsxs(_Fragment, { children: [_jsx(BasicTool, { icon: icon, trigger: _jsx(WorkflowTrigger, { title: title, subtitle: subtitle, chips: _jsx(RunChips, { run: run }), live: false }), triggerAction: _jsx(OpenRunAction, { onOpen: openRunner }), onClick: openRunner, locked: locked }), modal] }));
+    }
+    const counts = countAgents(run.agents);
+    const progress = counts.total > 0 ? t('progress', { done: counts.done, total: counts.total }) : undefined;
+    const failedPart = counts.failed > 0 ? t('failedSuffix', { count: counts.failed }) : undefined;
+    const runElapsed = elapsedMs(run, live, now);
+    const elapsed = runElapsed !== undefined && runElapsed >= 1_000 ? formatElapsed(runElapsed) : undefined;
+    const join = (...parts) => parts.filter(Boolean).join(' · ') || undefined;
+    const paused = run.paused ? tm('paused') : undefined;
+    const subtitle = run.status === 'running'
+        ? // A call that returned while its run goes on: the run works on without this turn.
+            settled || run.background
+                ? join(paused ?? t('background'), progress, failedPart)
+                : join(paused, progress, failedPart, elapsed)
+        : run.status === 'failed'
+            ? (run.error?.split('\n')[0] ?? (counts.total > 0 ? t('failedCount', { failed: counts.failed, total: counts.total }) : undefined))
+            : run.status === 'stopped'
+                ? join(t('status.stopped'), progress)
+                : join(counts.total === 0 ? undefined : counts.failed > 0 ? t('failedCount', { failed: counts.failed, total: counts.total }) : t('agents', { count: counts.total }), elapsed);
+    const callError = status === 'error' ? partError(call) : undefined;
+    const runError = run.error ?? callError;
+    const output = status === 'completed' ? partOutput(call) : '';
+    const result = output && run.status === 'done' ? parseWorkflowResult(output) : null;
+    // A failed or stopped run's output is its error block, which the error row above already says.
+    const rawOutput = !result && output && !output.trimStart().startsWith('<workflow_error>') ? output : '';
+    const hasProgress = run.agents.length > 0 || run.phases.length > 0;
+    const facts = [
+        run.name && run.name !== title ? t('savedName', { name: run.name }) : undefined,
+        run.status === 'running' && run.maxAgents ? t('upTo', { count: run.maxAgents }) : undefined,
+    ].filter((fact) => !!fact);
+    return (
+    // A failed run leads with the shared failure triangle, as every failed call does. A
+    // completed call whose run did not fail is not a failure, whatever its output says.
+    _jsxs(ToolOutcomeContext.Provider, { value: run.status === 'failed' || status === 'error' ? 'failed' : 'ok', children: [_jsx(BasicTool, { icon: icon, trigger: _jsx(WorkflowTrigger, { title: title, subtitle: subtitle, chips: _jsx(RunChips, { run: run }), live: live }), defaultOpen: defaultOpen, 
+                // A running run is the thing to watch, and a failure must not hide behind a closed
+                // row: either opens itself, so the rows say which agent is at work or broke.
+                forceOpen: forceOpen || (hasProgress && (run.status === 'running' || run.status === 'failed' || status === 'error')), locked: locked, children: _jsxs(_Fragment, { children: [_jsx(RunToolbar, { facts: facts, controls: live || (!!run.runId && !run.name && !!ids.sessionId) ? (_jsx(WorkflowRunControls, { projectId: ids.projectId, controlSessionId: live ? controlSessionId : undefined, ownerSessionId: ids.sessionId, run: run })) : null, onOpen: run.background ? () => setOpen({ sessionId: run.background.sessionId, title }) : undefined }), _jsx(WorkflowLogs, { logs: run.logs }), hasProgress && _jsx(WorkflowProgress, { run: run, live: live, now: now, onOpen: onOpen, stop: stop }), runError && run.status !== 'running' && _jsx(ToolError, { error: runError, toolName: call.name }), result ? _jsx(WorkflowResultFold, { result: result }) : rawOutput ? _jsx(WorkflowDetails, { output: rawOutput }) : null] }) }), modal] }));
+}
+/** The facts line and the run's controls, above the progress. A background run opens its runner session here too. */
+function RunToolbar({ facts, controls, onOpen }) {
+    const t = useTranslations('tools.workflow');
+    const indent = useToolIndent();
+    if (facts.length === 0 && !controls && !onOpen)
+        return null;
+    return (_jsxs("div", { className: cn('flex min-h-6 items-center gap-2 text-xs', indent && 'mt-1.5', indent), children: [_jsx("p", { className: "text-muted-foreground min-w-0 flex-1 truncate", children: facts.join(' · ') }), onOpen && (_jsx("button", { type: "button", "aria-label": t('openRunLabel'), onClick: onOpen, className: "text-muted-foreground hover:text-foreground cursor-pointer whitespace-nowrap underline-offset-2 transition-colors hover:underline", children: t('openRun') })), controls] }));
+}
+/** The script's return value, folded: pretty JSON in mono, anything else as Markdown. */
+function WorkflowResultFold({ result }) {
+    const t = useTranslations('tools.workflow');
+    const indent = useToolIndent();
+    return (_jsx("div", { className: cn(indent && 'mt-1.5', indent), children: _jsx(FoldedSection, { label: t('result'), children: _jsx(OutputBlock, { text: result.text, markdown: result.kind === 'markdown' }) }) }));
+}
+function WorkflowDetails({ output }) {
+    const t = useTranslations('tools.workflow');
+    const indent = useToolIndent();
+    return (_jsx("div", { className: cn(indent && 'mt-1.5', indent), children: _jsx(FoldedSection, { label: t('showDetails'), children: _jsx(OutputBlock, { text: output.length > 8_000 ? `${output.slice(0, 8_000)}\n…` : output }) }) }));
+}
+ToolRegistry.register('workflow', WorkflowTool);

package/dist/session/turn/notice-batch-group.d.ts

@@ -0,0 +1,12 @@
+import type { NoticeBatchItem } from './subagent-notice.js';
+/**
+ * Several notices the API coalesced into one delivered prompt
+ * (`session-notice-batch.ts`): background subagents that ended, teammates that
+ * went idle, sessions that answered a `notify_when_idle`. One header line ("3
+ * agents finished") and one compact row each, with no user bubble around them:
+ * nobody typed this turn.
+ */
+export declare function NoticeBatchGroup({ items, actions }: {
+    items: NoticeBatchItem[];
+    actions?: React.ReactNode;
+}): import("react").JSX.Element;