@kortix/ui 0.14.11 → 0.14.13

package/dist/session/agents/agent-strip.js

@@ -0,0 +1,259 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Badge } from '../../primitives/badge.js';
+import { Button } from '../../primitives/button.js';
+import { CountBadge } from '../../primitives/count-badge.js';
+import { Hint } from '../../primitives/hint.js';
+import Loading from '../../primitives/loading.js';
+import { Popover, PopoverContent, PopoverTrigger } from '../../primitives/popover.js';
+import { Tabs, TabsContent, TabsListCompact, TabsTriggerCompact } from '../../primitives/tabs.js';
+import { errorToast } from '../../primitives/toast.js';
+import { useTranslations } from '../../i18n/index.js';
+import { agentDisplayName } from '../../internal/components/agent-mark.js';
+import { cn } from '../../lib/utils.js';
+import { AgentStateMark } from './agent-state-mark.js';
+import { SubagentDialog } from './subagent-view.js';
+import { ArrowUpRightIcon, CaretUpIcon, SquareIcon } from '@phosphor-icons/react';
+import { useMemo, useState } from 'react';
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { stopProjectSession } from '@kortix/sdk';
+import { qk, useFeatureFlag, useSessionChildren, useSessionWorkflows, useTeamTasks, useTeammates, } from '@kortix/sdk/react';
+import { countAgents, parseWorkflowRun } from '../tool/tools/workflow-run.js';
+import { WorkflowProgress } from '../tool/tools/workflow-progress.js';
+import { isActive, lineSummary, shortElapsed, stripGroups, } from './agent-model.js';
+import { TasksPanel } from './tasks-panel.js';
+import { isLargeRun, LargeRunBadge, useLiveWorkflowRun, useNow, useRestartAgent, WorkflowRunControls, } from './workflow-run-controls.js';
+/**
+ * The agents line: one muted control in the composer's under-row, right of the
+ * agent picker (Claude Code's agent panel, folded to one line).
+ *
+ *   ● 2 agents · 1 working ⌃        ✓ 2 agents · poet done ⌃
+ *
+ * It names the state of what this session started (its child sessions, the
+ * teammates of a team it leads, its workflow runs) and opens a popover above
+ * the line with one row per agent: open its session, stop it while it works,
+ * and the Tasks tab of a team it leads. It renders nothing while the session
+ * started nothing, and it never holds the composer: the agents run in their own
+ * sessions, and the person keeps talking to this one.
+ */
+/** How often the child list polls while the line is mounted. */
+const CHILDREN_POLL_MS = 5_000;
+/** A finished workflow run stays listed this long after it ended. */
+const RECENT_RUN_MS = 60 * 60_000;
+/** The popover lists at most this many runs. */
+const MAX_RUNS = 5;
+const LINE_STATE = {
+    needs_input: 'needs_input',
+    working: 'working',
+    failed: 'failed',
+    done: 'completed',
+};
+/** The runs the line lists: running ones, and ones that ended in the last hour; newest first. */
+export function stripRuns(runs, now) {
+    const out = [];
+    for (const raw of runs) {
+        const run = parseWorkflowRun(raw);
+        if (!run)
+            continue;
+        if (run.status !== 'running' && (run.endedAt === undefined || now - run.endedAt > RECENT_RUN_MS))
+            continue;
+        out.push(run);
+        if (out.length >= MAX_RUNS)
+            break;
+    }
+    return out;
+}
+/** Every session a run owns: its runner and its agents. They show under the run, not as agent rows. */
+export function runSessionIds(runs) {
+    const ids = new Set();
+    for (const run of runs) {
+        if (run.background)
+            ids.add(run.background.sessionId);
+        for (const agent of run.agents)
+            if (agent.sessionId)
+                ids.add(agent.sessionId);
+    }
+    return ids;
+}
+/** The text of the line: `2 agents · 1 working`, `2 agents · poet done`, `1 workflow running`. */
+function useLineText(rows, runs, compact) {
+    const t = useTranslations('multiAgent.strip');
+    const summary = lineSummary(rows, runs);
+    const parts = [];
+    if (summary.agents > 0)
+        parts.push(t('agents', { count: summary.agents }));
+    if (summary.runs > 0) {
+        parts.push(summary.runningRuns > 0
+            ? t('workflowsRunning', { count: summary.runningRuns })
+            : t('workflows', { count: summary.runs }));
+    }
+    if (!compact && summary.agents > 0) {
+        if (summary.needsInput > 0)
+            parts.push(t('state.needs_input'));
+        else if (summary.working > 0)
+            parts.push(t('working', { count: summary.working }));
+        else if (summary.newest)
+            parts.push(t('newest', { name: summary.newest.handle, state: t(`state.${summary.newest.state}`) }));
+    }
+    return { summary, text: parts.join(' · ') };
+}
+export function AgentsLineView({ projectId, sessionId, agents, team, runs, tasks, onOpen, onStop, stopping, compact = false, defaultOpen = false, }) {
+    const t = useTranslations('multiAgent.strip');
+    const [open, setOpen] = useState(defaultOpen);
+    const rows = useMemo(() => [...agents, ...team], [agents, team]);
+    const { summary, text } = useLineText(rows, runs, compact);
+    if (rows.length === 0 && runs.length === 0)
+        return null;
+    return (_jsxs(Popover, { open: open, onOpenChange: setOpen, children: [_jsx(PopoverTrigger, { asChild: true, children: _jsxs(Button, { type: "button", variant: "ghost", size: "sm", "data-testid": "agents-line", "aria-label": compact ? `${t('label')}: ${text}` : undefined, className: "text-muted-foreground hit-area-y-3 min-w-0 shrink gap-1.5 rounded-lg px-2 text-xs font-normal tabular-nums", children: [_jsx(AgentStateMark, { state: LINE_STATE[summary.mark] }), _jsx("span", { className: "max-w-64 min-w-0 truncate", children: text }), _jsx(CaretUpIcon, { "aria-hidden": true, className: cn('size-3 shrink-0', open && 'rotate-180') })] }) }), _jsx(PopoverContent, { side: "top", align: "start", sideOffset: 8, "aria-label": t('label'), "data-testid": "agents-line-popover", tabIndex: -1, 
+                // Focus the panel, not its first row action: a focused action opens its
+                // tooltip, and the first Escape would close the tooltip, not the popover.
+                onOpenAutoFocus: (event) => {
+                    event.preventDefault();
+                    event.currentTarget?.focus();
+                }, className: "flex w-[min(360px,calc(100vw-1.5rem))] flex-col p-0", children: _jsx(AgentsPanel, { projectId: projectId, sessionId: sessionId, agents: agents, team: team, runs: runs, tasks: tasks, onOpen: (target) => {
+                        setOpen(false);
+                        onOpen(target);
+                    }, onStop: onStop, stopping: stopping, live: open }) })] }));
+}
+/** The popover body: Agents, Team, Workflows, and a Tasks tab when this session leads a team. */
+export function AgentsPanel({ projectId, sessionId, agents, team, runs, tasks, onOpen, onStop, stopping, live }) {
+    const t = useTranslations('multiAgent.strip');
+    const anyWorking = live && [...agents, ...team].some((row) => row.state === 'working');
+    const now = useNow(anyWorking);
+    const sections = [agents.length > 0, team.length > 0, runs.length > 0].filter(Boolean).length;
+    const renderRows = (list, teammate) => (_jsx("ul", { children: list.map((row) => (_jsx(AgentLineRow, { row: row, teammate: teammate, now: now, stopping: stopping.has(row.sessionId), onOpen: () => onOpen({ sessionId: row.sessionId, title: row.handle }), onStop: () => onStop(row) }, row.sessionId))) }));
+    const list = (_jsxs("div", { className: "max-h-96 overflow-y-auto p-1", children: [agents.length > 0 && (_jsxs("section", { "aria-label": t('label'), children: [sections > 1 && _jsx(GroupLabel, { children: t('label') }), renderRows(agents, false)] })), team.length > 0 && (_jsxs("section", { "aria-label": t('team'), children: [_jsx(GroupLabel, { children: t('team') }), renderRows(team, true)] })), runs.length > 0 && (_jsxs("section", { "aria-label": t('workflowsGroup'), children: [_jsx(GroupLabel, { children: t('workflowsGroup') }), _jsx("ul", { children: runs.map((run) => (_jsx(WorkflowLineRow, { projectId: projectId, sessionId: sessionId, run: run, onOpen: onOpen }, run.runId || run.title))) })] }))] }));
+    if (tasks === null)
+        return list;
+    const openTasks = tasks.filter((task) => task.status !== 'completed').length;
+    return (_jsxs(Tabs, { defaultValue: "agents", className: "gap-0", children: [_jsx(TabsContent, { value: "agents", children: list }), _jsx(TabsContent, { value: "tasks", className: "max-h-96 overflow-y-auto p-1", children: _jsx(TasksPanel, { tasks: tasks }) }), _jsx("div", { className: "border-t p-1", children: _jsxs(TabsListCompact, { animate: "none", className: "w-full", children: [_jsx(TabsTriggerCompact, { value: "agents", children: t('label') }), _jsxs(TabsTriggerCompact, { value: "tasks", className: "gap-1.5", children: [t('tasks'), openTasks > 0 && _jsx(CountBadge, { count: openTasks })] })] }) })] }));
+}
+function GroupLabel({ children }) {
+    return _jsx("div", { className: "text-muted-foreground px-2 pt-1.5 pb-0.5 text-xs font-medium", children: children });
+}
+/** Row actions: shown on hover and on keyboard focus, always on a touch screen. */
+const ROW_ACTIONS = 'flex shrink-0 items-center opacity-0 group-hover/row:opacity-100 group-focus-within/row:opacity-100 [@media(hover:none)]:opacity-100';
+/** The short state of a row: `working · 1m`, `done`, `needs you`, `failed`. */
+function rowState(row, now, t) {
+    if (row.state === 'working' && row.workingSinceMs !== null) {
+        return t('workingFor', { elapsed: shortElapsed(now - row.workingSinceMs) });
+    }
+    return t(`state.${row.state}`);
+}
+function AgentLineRow({ row, teammate, now, stopping, onOpen, onStop, }) {
+    const t = useTranslations('multiAgent.strip');
+    // The result, or what it waits for: one line on hover, never inline.
+    const detail = row.state === 'needs_input' ? (row.line ?? t(`attention.${row.attention ?? 'question'}`)) : row.line;
+    const handle = (_jsx("span", { className: "text-foreground min-w-0 truncate font-medium", title: teammate ? undefined : row.handle, children: row.handle }));
+    const state = (_jsx("span", { className: "text-muted-foreground shrink-0 tabular-nums", children: rowState(row, now, t) }));
+    return (_jsxs("li", { "data-testid": "agents-line-row", "data-agent-row": row.sessionId, className: "group/row hover:bg-hover focus-within:bg-hover flex min-w-0 items-center gap-1 rounded-sm", children: [_jsxs("div", { onClick: onOpen, className: "flex min-w-0 flex-1 cursor-pointer items-center gap-2 py-1.5 pl-2 text-xs", children: [_jsx(AgentStateMark, { state: row.state }), _jsxs("div", { className: "min-w-0 flex-1", children: [_jsxs("div", { className: "flex min-w-0 items-baseline gap-2", children: [teammate ? (_jsx(Hint, { label: t('teamRole'), side: "top", children: handle })) : (handle), detail ? (_jsx(Hint, { label: _jsx("span", { className: "block max-w-72 truncate", children: detail }), side: "top", children: state })) : (state)] }), row.named && row.agent && (_jsx("p", { className: "text-muted-foreground truncate", children: t('runsAs', { agent: agentDisplayName(row.agent) }) }))] })] }), _jsxs("div", { className: cn(ROW_ACTIONS, 'pr-1', stopping && 'opacity-100'), children: [_jsx(Hint, { label: t('openAgent', { name: row.handle }), side: "top", children: _jsx(Button, { type: "button", variant: "ghost", size: "icon-xs", "aria-label": t('openAgent', { name: row.handle }), onClick: onOpen, className: "text-muted-foreground hover:text-foreground", children: _jsx(ArrowUpRightIcon, { className: "size-3.5 shrink-0" }) }) }), stopping ? (_jsx("span", { className: "flex size-6 items-center justify-center", children: _jsx(Loading, { className: "text-muted-foreground size-3" }) })) : isActive(row.state) ? (_jsx(Hint, { label: t('stopHint'), side: "top", children: _jsx(Button, { type: "button", variant: "ghost", size: "icon-xs", "aria-label": t('stopAgent', { name: row.handle }), onClick: onStop, className: "text-muted-foreground hover:text-foreground", children: _jsx(SquareIcon, { weight: "fill", className: "size-2.5" }) }) })) : null] })] }));
+}
+const RUN_STATE = {
+    running: 'working',
+    done: 'completed',
+    failed: 'failed',
+    stopped: 'stopped',
+};
+/** One workflow run: its live progress and controls; it unfolds into its agents. */
+function WorkflowLineRow({ projectId, sessionId, run: listed, onOpen, }) {
+    const t = useTranslations('multiAgent.strip');
+    const tw = useTranslations('multiAgent.workflow');
+    const [open, setOpen] = useState(false);
+    // A background run's progress is read from its runner, so it keeps moving after this turn ended.
+    const { run, controlSessionId } = useLiveWorkflowRun(projectId, sessionId, listed);
+    const now = useNow(open && run?.status === 'running');
+    const restart = useRestartAgent(projectId, controlSessionId, run);
+    const queryClient = useQueryClient();
+    const stopAgent = useMutation({
+        mutationFn: (agent) => stopProjectSession(projectId, agent.sessionId),
+        onSuccess: () => projectId && queryClient.invalidateQueries({ queryKey: qk.project.sessionsScope(projectId) }),
+        onError: (error) => errorToast(t('stopFailed'), { description: error instanceof Error ? error.message : undefined }),
+    });
+    if (!run)
+        return null;
+    const counts = countAgents(run.agents);
+    const progress = counts.total > 0 ? t('runProgress', { done: counts.done, total: counts.total }) : undefined;
+    const line = (run.status === 'running'
+        ? [run.paused ? tw('paused') : run.background ? t('runBackground') : t('runRunning'), progress]
+        : [progress])
+        .filter(Boolean)
+        .join(' · ');
+    const live = run.status === 'running';
+    const stop = {
+        enabled: !!projectId,
+        pending: new Set(stopAgent.isPending && stopAgent.variables?.sessionId ? [stopAgent.variables.sessionId] : []),
+        stop: (agent) => agent.sessionId && stopAgent.mutate(agent),
+        ...(restart.enabled ? { restart: { pending: restart.restarting, run: restart.restart } } : {}),
+    };
+    const title = run.title || run.name || t('runFallback');
+    return (_jsxs("li", { "data-testid": "agents-line-row", "data-workflow-run": run.runId, children: [_jsxs("div", { className: "group/row hover:bg-hover focus-within:bg-hover flex min-w-0 items-center gap-1 rounded-sm", children: [_jsxs("button", { type: "button", "aria-expanded": open, onClick: () => setOpen((value) => !value), className: "flex min-w-0 flex-1 cursor-pointer items-center gap-2 py-1.5 pl-2 text-left text-xs outline-none", children: [_jsx(AgentStateMark, { state: RUN_STATE[run.status] }), _jsxs("div", { className: "min-w-0 flex-1", children: [_jsxs("div", { className: "flex min-w-0 items-baseline gap-2", children: [_jsx("span", { className: "text-foreground min-w-0 truncate font-medium", title: title, children: title }), _jsx("span", { className: "text-muted-foreground shrink-0", children: t(`state.${RUN_STATE[run.status]}`) })] }), line && _jsx("p", { className: "text-muted-foreground truncate tabular-nums", children: line })] })] }), isLargeRun(run) && _jsx(LargeRunBadge, {}), _jsxs("div", { className: cn(ROW_ACTIONS, 'pr-1'), children: [run.background && (_jsx(Hint, { label: t('openRun'), side: "top", children: _jsx(Button, { type: "button", variant: "ghost", size: "icon-xs", "aria-label": t('openRun'), onClick: () => onOpen({ sessionId: run.background.sessionId, title }), className: "text-muted-foreground hover:text-foreground", children: _jsx(ArrowUpRightIcon, { className: "size-3.5 shrink-0" }) }) })), _jsx(WorkflowRunControls, { projectId: projectId, controlSessionId: live ? controlSessionId : undefined, ownerSessionId: sessionId, run: run })] })] }), open && run.agents.length > 0 && (_jsx("div", { className: "pl-5", children: _jsx(WorkflowProgress, { run: run, live: live, now: now, onOpen: (agent) => agent.sessionId && onOpen({ sessionId: agent.sessionId, title: agent.agent ? `${agent.label} · ${agent.agent}` : agent.label }), stop: stop }) })), open && run.agents.length === 0 && (_jsx(Badge, { variant: "muted", size: "sm", className: "ml-7", children: t('runNoAgents') }))] }));
+}
+/**
+ * The agents of one session, read live: its children (polled every 5 s), its
+ * teammates and team tasks (flag `agent_teams`) and its workflow runs; and the
+ * stop of one agent.
+ */
+export function useAgentsLine(projectId, sessionId) {
+    const t = useTranslations('multiAgent.strip');
+    const pid = projectId ?? '';
+    const sid = sessionId ?? '';
+    const ready = !!projectId && !!sessionId;
+    const teams = useFeatureFlag(projectId, 'agent_teams').enabled;
+    const childList = useSessionChildren(pid, sid, { enabled: ready, refetchInterval: CHILDREN_POLL_MS, limit: 50 });
+    const children = childList.sessions;
+    const { data: teammates, dataUpdatedAt: teammatesAt } = useTeammates(projectId, sessionId, { enabled: ready && teams });
+    const { data: tasks } = useTeamTasks(projectId, sessionId, { enabled: ready && teams });
+    const { data: runData, dataUpdatedAt: runsAt } = useSessionWorkflows(projectId, sessionId, { enabled: ready });
+    const [stopping, setStopping] = useState(() => new Set());
+    const queryClient = useQueryClient();
+    const stopMutation = useMutation({
+        mutationFn: (row) => stopProjectSession(pid, row.sessionId),
+        onSettled: (_data, _error, row) => {
+            setStopping((previous) => {
+                const next = new Set(previous);
+                next.delete(row.sessionId);
+                return next;
+            });
+            void queryClient.invalidateQueries({ queryKey: qk.project.sessionsScope(pid) });
+        },
+        onError: (error, row) => errorToast(t('stopAgentFailed', { name: row.handle }), { description: error instanceof Error ? error.message : undefined }),
+    });
+    // "Recent" is measured at the newest answer, not at each render: the lists re-derive when data arrives.
+    const now = Math.max(childList.dataUpdatedAt, teammatesAt, runsAt);
+    const runs = useMemo(() => stripRuns(runData ?? [], now), [runData, now]);
+    const groups = useMemo(() => stripGroups({
+        leadSessionId: sid,
+        children,
+        teammates: teammates ?? [],
+        exclude: runSessionIds(runs),
+        now,
+    }), [sid, children, teammates, runs, now]);
+    const leadsTeam = teams && ((teammates?.length ?? 0) > 0 || (tasks?.length ?? 0) > 0);
+    return {
+        ready,
+        agents: groups.agents,
+        team: groups.team,
+        runs,
+        tasks: leadsTeam ? (tasks ?? []) : null,
+        stopping,
+        stop: (row) => {
+            setStopping((previous) => new Set(previous).add(row.sessionId));
+            stopMutation.mutate(row);
+        },
+    };
+}
+/**
+ * The agents line of one session, for the composer's under-row
+ * (`SessionChatInputProps.underbarSlot`). Nothing renders while the session
+ * started no agent and no workflow run.
+ */
+export function AgentsLine({ projectId, sessionId, compact = false, }) {
+    const line = useAgentsLine(projectId, sessionId);
+    const [open, setOpen] = useState(null);
+    if (!line.ready)
+        return null;
+    return (_jsxs(_Fragment, { children: [_jsx(AgentsLineView, { projectId: projectId, sessionId: sessionId, agents: line.agents, team: line.team, runs: line.runs, tasks: line.tasks, onOpen: setOpen, onStop: line.stop, stopping: line.stopping, compact: compact }), open && (_jsx(SubagentDialog, { open: true, onOpenChange: (next) => {
+                    if (!next)
+                        setOpen(null);
+                }, projectId: projectId, sessionId: open.sessionId, title: open.title }))] }));
+}

package/dist/session/agents/held-messages.d.ts

@@ -0,0 +1,33 @@
+import type { PeerMessage } from '@kortix/sdk';
+import { usePeerMessages } from '@kortix/sdk/react';
+/**
+ * Messages from other sessions that wait for the person (`inbound: hold`, or a
+ * session the person asked to approve first). Claude Code opens an approval
+ * dialog with the sender and a preview; Kortix shows one card per message above
+ * the agent strip. "Approve message" delivers it, "Deny" drops it. A message
+ * nobody decides expires after 5 minutes on the server.
+ */
+/** The preview line: the sender's summary, else the message's first line. */
+export declare function heldPreview(message: Pick<PeerMessage, 'summary' | 'message'>): string;
+export interface HeldMessageCardProps {
+    message: PeerMessage;
+    pending: 'approve' | 'deny' | null;
+    onApprove: () => void;
+    onDeny: () => void;
+}
+export declare function HeldMessageCard({ message, pending, onApprove, onDeny }: HeldMessageCardProps): import("react").JSX.Element;
+type PeerMessagesQuery = ReturnType<typeof usePeerMessages>;
+/** The held messages of `usePeerMessages(…, 'in')`, one card each; nothing when none waits. */
+export declare function HeldMessageList({ messages, approve, deny, }: {
+    messages: readonly PeerMessage[] | undefined;
+    approve: PeerMessagesQuery['approve'];
+    deny: PeerMessagesQuery['deny'];
+}): import("react").JSX.Element | null;
+/** The messages that wait for the person, oldest first (the order they arrived). */
+export declare function heldMessages(messages: readonly PeerMessage[] | undefined): PeerMessage[];
+/** A session's held messages, read on their own (for a host without the agent strip). */
+export declare function HeldMessages({ projectId, sessionId }: {
+    projectId: string | undefined;
+    sessionId: string | undefined;
+}): import("react").JSX.Element;
+export {};

package/dist/session/agents/held-messages.js

@@ -0,0 +1,50 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button } from '../../primitives/button.js';
+import { SessionDotMatrix } from '../../primitives/dot-matrix/session-dot-matrix.js';
+import { errorToast } from '../../primitives/toast.js';
+import { useTranslations } from '../../i18n/index.js';
+import { ChatCircleDotsIcon } from '@phosphor-icons/react';
+import { peerHandleLabel } from '../../_vendor/kortix-shared.js';
+import { usePeerMessages } from '@kortix/sdk/react';
+/**
+ * Messages from other sessions that wait for the person (`inbound: hold`, or a
+ * session the person asked to approve first). Claude Code opens an approval
+ * dialog with the sender and a preview; Kortix shows one card per message above
+ * the agent strip. "Approve message" delivers it, "Deny" drops it. A message
+ * nobody decides expires after 5 minutes on the server.
+ */
+/** The preview line: the sender's summary, else the message's first line. */
+export function heldPreview(message) {
+    const summary = message.summary?.trim();
+    if (summary)
+        return summary;
+    const first = message.message.trim().split('\n')[0] ?? '';
+    return first.length > 200 ? `${first.slice(0, 200)}…` : first;
+}
+export function HeldMessageCard({ message, pending, onApprove, onDeny }) {
+    const t = useTranslations('multiAgent.held');
+    const kind = message.type === 'shutdown_request' ? 'titleShutdown' : 'title';
+    return (_jsxs("div", { "data-held-message": message.id, className: "bg-popover flex items-start gap-2.5 rounded-md border px-3 py-2.5 text-xs", children: [_jsx(ChatCircleDotsIcon, { "aria-hidden": true, className: "text-muted-foreground mt-0.5 size-4 shrink-0" }), _jsxs("div", { className: "min-w-0 flex-1 space-y-0.5", children: [_jsx("p", { className: "text-foreground text-sm font-medium", children: t(kind, { from: peerHandleLabel(message.from_handle) }) }), _jsx("p", { className: "text-foreground line-clamp-2 wrap-break-word", children: heldPreview(message) }), _jsx("p", { className: "text-muted-foreground", children: t('waiting') })] }), _jsxs("div", { className: "flex shrink-0 items-center gap-1.5", children: [_jsxs(Button, { type: "button", size: "xs", variant: "outline-ghost", disabled: pending !== null, onClick: onDeny, children: [pending === 'deny' ? _jsx(SessionDotMatrix, { size: 14, className: "shrink-0" }) : null, t('deny')] }), _jsxs(Button, { type: "button", size: "xs", disabled: pending !== null, onClick: onApprove, children: [pending === 'approve' ? _jsx(SessionDotMatrix, { size: 14, className: "shrink-0" }) : null, t('approve')] })] })] }));
+}
+/** The held messages of `usePeerMessages(…, 'in')`, one card each; nothing when none waits. */
+export function HeldMessageList({ messages, approve, deny, }) {
+    const t = useTranslations('multiAgent.held');
+    const held = heldMessages(messages);
+    if (held.length === 0)
+        return null;
+    const pendingFor = (id) => approve.isPending && approve.variables === id ? 'approve' : deny.isPending && deny.variables === id ? 'deny' : null;
+    const fail = (key) => (error) => errorToast(t(key), { description: error instanceof Error ? error.message : undefined });
+    return (_jsx("div", { "aria-label": t('label'), role: "group", className: "space-y-1.5", children: held.map((message) => (_jsx(HeldMessageCard, { message: message, pending: pendingFor(message.id), onApprove: () => approve.mutate(message.id, { onError: fail('approveFailed') }), onDeny: () => deny.mutate(message.id, { onError: fail('denyFailed') }) }, message.id))) }));
+}
+/** The messages that wait for the person, oldest first (the order they arrived). */
+export function heldMessages(messages) {
+    return (messages ?? [])
+        .filter((message) => message.status === 'held')
+        .sort((a, b) => Date.parse(a.created_at) - Date.parse(b.created_at));
+}
+/** A session's held messages, read on their own (for a host without the agent strip). */
+export function HeldMessages({ projectId, sessionId }) {
+    const { data, approve, deny } = usePeerMessages(projectId, sessionId, 'in');
+    return _jsx(HeldMessageList, { messages: data, approve: approve, deny: deny });
+}

package/dist/session/agents/legacy-subagent-chat.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The body of a sub-agent that is not a Kortix session of its own: an
+ * in-process child (`session: "same"`) or an old OpenCode subagent, whose
+ * transcript lives in its lead's computer and saved history. It mounts the
+ * read-only `SessionChat` of that child under the lead's saved-history scope,
+ * so it paints while the computer is off. Every child that is its own project
+ * session reads `SessionPeek` instead (`subagent-dialog-content.tsx`).
+ */
+export declare function LegacySubagentChat({ sessionId }: {
+    sessionId: string;
+}): import("react").JSX.Element;

package/dist/session/agents/legacy-subagent-chat.js

@@ -0,0 +1,19 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { SessionChat } from '../thread/session-chat.js';
+import { useSessionIds } from '../../providers/session-ids.js';
+/**
+ * The body of a sub-agent that is not a Kortix session of its own: an
+ * in-process child (`session: "same"`) or an old OpenCode subagent, whose
+ * transcript lives in its lead's computer and saved history. It mounts the
+ * read-only `SessionChat` of that child under the lead's saved-history scope,
+ * so it paints while the computer is off. Every child that is its own project
+ * session reads `SessionPeek` instead (`subagent-dialog-content.tsx`).
+ */
+export function LegacySubagentChat({ sessionId }) {
+    // The session page this sub-agent runs under. Its saved history holds the
+    // sub-agent's transcript too.
+    const ids = useSessionIds();
+    const savedHistoryScope = ids.projectId && ids.sessionId ? `${ids.projectId}/${ids.sessionId}` : undefined;
+    return _jsx(SessionChat, { sessionId: sessionId, hideHeader: true, readOnly: true, initialScrollTop: true, savedHistoryScope: savedHistoryScope });
+}

package/dist/session/agents/session-peek.d.ts

@@ -0,0 +1,20 @@
+import '../tool/tools/register.js';
+/**
+ * The transcript of another session, read-only, from the API alone
+ * (`useSessionView`): its log and its stream. It never starts the session and
+ * never points the app's runtime at the session's box, so it can sit beside
+ * the session page that owns the runtime: a sub-agent's dialog over its lead's
+ * chat, the board's preview. Never blank: a skeleton while the log loads, an
+ * error with "Try again", "Nothing yet" for a session with no message.
+ */
+export declare function SessionPeek({ projectId, sessionId, working, onActivity, density, className, }: {
+    projectId: string;
+    sessionId: string;
+    /** The session works now: its last turn shows the agent's busy row. */
+    working?: boolean;
+    /** Called when a message arrives or changes count: the host re-reads the session's state. */
+    onActivity?: () => void;
+    /** `compact`: the narrow gutters of a side sheet, as `SessionThread`'s density. */
+    density?: 'default' | 'compact';
+    className?: string;
+}): import("react").JSX.Element;

package/dist/session/agents/session-peek.js

@@ -0,0 +1,67 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { sessionLogTurns } from '@kortix/sdk';
+import { useSessionView } from '@kortix/sdk/react';
+import { ChatsCircleIcon } from '@phosphor-icons/react';
+import { useEffect, useLayoutEffect, useMemo, useRef } from 'react';
+import { useTranslations } from '../../i18n/index.js';
+import { ProjectScope } from '../../internal/project-scope.js';
+import { cn } from '../../lib/utils.js';
+import { Button } from '../../primitives/button.js';
+import { EmptyState } from '../../primitives/empty-state.js';
+import { ErrorState } from '../../primitives/error-state.js';
+import Loading from '../../primitives/loading.js';
+import { Skeleton } from '../../primitives/skeleton.js';
+import { SessionTurn } from '../thread/transcript.js';
+import { SESSION_TRANSCRIPT_CLASS } from '../thread/session-transcript-class.js';
+import '../tool/tools/register.js';
+/** The live thread is read at most once per this window while a turn streams. */
+const PEEK_THROTTLE_MS = 100;
+const NO_REQUESTS = [];
+const noop = () => { };
+const noopAsync = async () => { };
+/** A view rewinds nothing: every turn's history control stays off. */
+const TURN_OUTCOME = {};
+/**
+ * The transcript of another session, read-only, from the API alone
+ * (`useSessionView`): its log and its stream. It never starts the session and
+ * never points the app's runtime at the session's box, so it can sit beside
+ * the session page that owns the runtime: a sub-agent's dialog over its lead's
+ * chat, the board's preview. Never blank: a skeleton while the log loads, an
+ * error with "Try again", "Nothing yet" for a session with no message.
+ */
+export function SessionPeek({ projectId, sessionId, working = false, onActivity, density = 'default', className, }) {
+    const t = useTranslations('multiAgent.subagent');
+    const view = useSessionView(projectId, sessionId, { throttleMs: PEEK_THROTTLE_MS });
+    const turns = useMemo(() => (view.thread ? sessionLogTurns(view.thread, { foldCompactions: true, busy: working }) : []), [view.thread, working]);
+    const scrollRef = useRef(null);
+    const pinned = useRef(true);
+    // Open at the newest message, and follow new ones while the reader sits at the bottom.
+    useLayoutEffect(() => {
+        const node = scrollRef.current;
+        if (node && pinned.current)
+            node.scrollTop = node.scrollHeight;
+    }, [turns]);
+    useEffect(() => {
+        pinned.current = true;
+    }, [sessionId]);
+    const count = view.thread?.messages.length ?? 0;
+    const activity = useRef(onActivity);
+    useEffect(() => {
+        activity.current = onActivity;
+    });
+    useEffect(() => {
+        if (count > 0)
+            activity.current?.();
+    }, [count]);
+    return (_jsx("div", { "data-testid": "session-peek", "data-status": view.status, "data-density": density, className: cn('group/thread flex min-h-0 flex-1 flex-col', className), children: view.status === 'loading' ? (_jsxs("div", { className: cn(SESSION_TRANSCRIPT_CLASS, 'space-y-4'), "aria-busy": "true", children: [_jsx(Skeleton, { className: "ml-auto h-9 w-2/5 rounded-xl" }), _jsx(Skeleton, { className: "h-4 w-4/5" }), _jsx(Skeleton, { className: "h-4 w-3/5" }), _jsx(Skeleton, { className: "h-4 w-2/3" })] })) : view.status === 'error' ? (_jsx("div", { className: "flex flex-1 items-center justify-center p-6", children: _jsx(ErrorState, { size: "sm", title: t('loadFailed'), action: _jsx(Button, { variant: "outline", size: "sm", onClick: view.retry, children: t('retry') }) }) })) : view.status === 'empty' ? (_jsx("div", { className: "flex flex-1 items-center justify-center p-6", children: _jsx(EmptyState, { size: "sm", icon: ChatsCircleIcon, title: t('emptyTitle'), description: t('emptyDescription') }) })) : (_jsx(ProjectScope, { projectId: projectId, sessionId: sessionId, children: _jsx("div", { ref: scrollRef, onScroll: (event) => {
+                    const node = event.currentTarget;
+                    pinned.current = node.scrollHeight - node.scrollTop - node.clientHeight < 48;
+                }, className: "min-h-0 flex-1 overflow-y-auto", children: _jsxs("div", { className: cn(SESSION_TRANSCRIPT_CLASS, 'pb-6'), children: [view.hasOlder && (_jsx("div", { className: "mb-4 flex justify-center", children: _jsxs(Button, { variant: "ghost", size: "xs", disabled: view.isLoadingOlder, onClick: () => {
+                                    pinned.current = false;
+                                    void view.loadOlder();
+                                }, className: "text-muted-foreground", children: [view.isLoadingOlder && _jsx(Loading, { className: "size-3 shrink-0" }), t('loadOlder')] }) })), _jsx("div", { className: "space-y-6", children: turns.map((turn, index) => {
+                                const last = index === turns.length - 1;
+                                return (_jsx(SessionTurn, { turn: turn, turnOutcome: TURN_OUTCOME, sessionId: view.thread?.thread_id ?? sessionId, sessionStatus: undefined, isLast: last, ownsPlan: false, permissions: NO_REQUESTS, questions: NO_REQUESTS, isFirstTurn: index === 0, sessionWorking: working, isWorkingTurn: last && working, suppressBusyIndicator: false, awaitingUser: false, pending: false, disableToolNavigation: true, onPermissionReply: noopAsync, onRewind: noop, rewindDisabled: true }, turn.id));
+                            }) })] }) }) })) }));
+}

package/dist/session/agents/session-prompt.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Send a prompt into the open session from a control that is not the composer
+ * ("Save as workflow"). The session chat provides its own send path, so the
+ * prompt goes out exactly as a typed one: a running turn is steered, an idle
+ * session starts a turn, and the composer's draft is left alone.
+ */
+export type SessionPromptSend = (text: string) => unknown;
+export declare const SessionPromptContext: import("react").Context<SessionPromptSend | null>;
+/**
+ * The session's own send, or, outside a session chat, the composer prefill: the
+ * text lands in the composer of `sessionId` for the person to send.
+ */
+export declare function useSessionPromptSend(sessionId: string | undefined): SessionPromptSend | null;

package/dist/session/agents/session-prompt.js

@@ -0,0 +1,18 @@
+'use client';
+import { createContext, useCallback, useContext } from 'react';
+import { useSessionComposerPrefillStore } from '../composer/stores/session-composer-prefill-store.js';
+export const SessionPromptContext = createContext(null);
+/**
+ * The session's own send, or, outside a session chat, the composer prefill: the
+ * text lands in the composer of `sessionId` for the person to send.
+ */
+export function useSessionPromptSend(sessionId) {
+    const send = useContext(SessionPromptContext);
+    const prefill = useCallback((text) => {
+        if (sessionId)
+            useSessionComposerPrefillStore.getState().setPrefill(sessionId, text);
+    }, [sessionId]);
+    if (send)
+        return send;
+    return sessionId ? prefill : null;
+}

package/dist/session/agents/steer-session.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Send a message to another session through the API's prompt route, as a steer:
+ * a running turn reads it at its next step, an idle session starts a turn. It
+ * needs no runtime of its own, so a host can message a sub-agent or a board row
+ * from beside the session that owns the app's runtime.
+ */
+export declare function useSteerSession(projectId: string | undefined, options?: {
+    onSent?: () => void;
+    onError?: (error: unknown) => void;
+}): import("@tanstack/react-query").UseMutationResult<import("@kortix/sdk").CreateSessionPromptResult, Error, {
+    sessionId: string;
+    text: string;
+}, unknown>;

package/dist/session/agents/steer-session.js

@@ -0,0 +1,29 @@
+'use client';
+import { createSessionPrompt, mintWireMessageId } from '@kortix/sdk';
+import { useMutation } from '@tanstack/react-query';
+/**
+ * Send a message to another session through the API's prompt route, as a steer:
+ * a running turn reads it at its next step, an idle session starts a turn. It
+ * needs no runtime of its own, so a host can message a sub-agent or a board row
+ * from beside the session that owns the app's runtime.
+ */
+export function useSteerSession(projectId, options = {}) {
+    return useMutation({
+        mutationFn: async ({ sessionId, text }) => {
+            if (!projectId)
+                throw new Error('No project');
+            // Minted with no transcript to place it against: the server places it at delivery.
+            const messageId = mintWireMessageId();
+            return createSessionPrompt(projectId, sessionId, {
+                clientMessageId: messageId,
+                messageId,
+                remintOnDelivery: true,
+                delivery: 'steer',
+                parts: [{ type: 'text', text }],
+                clientSentAtMs: Date.now(),
+            });
+        },
+        onSuccess: () => options.onSent?.(),
+        onError: (error) => options.onError?.(error),
+    });
+}

package/dist/session/agents/subagent-dialog-content.d.ts

@@ -0,0 +1,11 @@
+export interface SubagentDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** The child session: a Kortix project session, or an in-process child's runtime id. */
+    sessionId: string;
+    /** What the opener calls it; the session's own handle wins once its row loads. */
+    title?: string;
+    /** The project; default: the project of the session page the dialog opens over. */
+    projectId?: string;
+}
+export declare function SubagentDialogContent({ open, onOpenChange, sessionId, title, projectId: projectIdProp }: SubagentDialogProps): import("react").JSX.Element;