@kortix/ui 0.14.3 → 0.14.4

package/dist/session/tool/tool-part-renderer.js

@@ -0,0 +1,150 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button } from '../../primitives/button.js';
+import { STATUS_TEXT } from '../../primitives/status.js';
+import { QuestionPrompt } from '../prompts/question-prompt.js';
+import { GenericTool } from './generic-tool.js';
+import { BasicTool, BoundActivateContext, partOutcome, StalePendingContext, ToolActivateContext, ToolDurationContext, ToolNavigationContext, ToolOutcomeContext, ToolRunningContext, ToolSurfaceContext, TurnLiveContext, } from './shared/infrastructure.js';
+import { ToolRegistry } from './shared/registry.js';
+import { ToolError } from './tool-error.js';
+import { replyToInlinePermission } from './inline-permission-reply.js';
+import { errorToast } from '../../primitives/toast.js';
+import { cn } from '../../lib/utils.js';
+import { partError, partStreamingInput } from './shared/infrastructure-parts.js';
+import { PERMISSION_LABELS, getChildSessionId, shouldShowToolPart, } from '../../internal/session-types/index.js';
+import { sessionLogCallStatus, sessionLogOpenCall, toolKind } from '@kortix/sdk';
+import { useTranslations } from '../../i18n/index.js';
+import { memo, useCallback, useContext, useEffect, useMemo, useState } from 'react';
+function PermissionPromptInline({ permission, onReply }) {
+    const tHardcodedUi = useTranslations('hardcodedUi');
+    const [visible, setVisible] = useState(false);
+    const [replying, setReplying] = useState(false);
+    useEffect(() => {
+        const timer = setTimeout(() => setVisible(true), 50);
+        return () => clearTimeout(timer);
+    }, []);
+    const label = PERMISSION_LABELS[permission.permission] || permission.permission;
+    const handleReply = useCallback(async (reply) => {
+        if (replying)
+            return;
+        setReplying(true);
+        // The card disappears once the runtime accepts; a refusal re-enables it.
+        const accepted = await replyToInlinePermission(onReply, permission.id, reply, (error) => errorToast(error instanceof Error ? error.message : String(error)));
+        if (!accepted)
+            setReplying(false);
+    }, [replying, permission.id, onReply]);
+    if (!visible)
+        return null;
+    return (_jsxs("div", { className: cn('flex items-center gap-2 px-2.5 py-2', STATUS_TEXT.warning), children: [_jsxs("span", { className: "text-foreground flex-1 text-xs", children: [tHardcodedUi.raw('i18nComplete.text5427e0ef4eba'), ' ', _jsx("span", { className: "font-medium", children: label })] }), _jsxs("div", { className: "flex items-center gap-1.5", children: [_jsx(Button, { disabled: replying, onClick: () => void handleReply('reject'), variant: "muted", size: "xs", className: "hover:text-destructive hover:bg-destructive/10", children: tHardcodedUi.raw('i18nComplete.text05a2d7332eb9') }), _jsx(Button, { disabled: replying, onClick: () => void handleReply('always'), variant: "outline", size: "xs", children: tHardcodedUi.raw('componentsSessionToolRenderers.line8026JsxTextAllowAlways') }), _jsx(Button, { disabled: replying, onClick: () => void handleReply('once'), variant: "default", size: "xs", children: tHardcodedUi.raw('componentsSessionToolRenderers.line8034JsxTextAllowOnce') })] })] }));
+}
+function ToolPartRendererImpl({ call: given, sessionId, permission, question, onPermissionReply, onQuestionReply, onQuestionReject, defaultOpen, disableNavigation = false, }) {
+    const tI18nComplete = useTranslations('hardcodedUi.i18nComplete');
+    // One open block per call object (`sessionLogOpenCall` caches it), so the memos
+    // below and the renderers' own memos hold while the call is unchanged.
+    const call = sessionLogOpenCall(given);
+    const toolDurationMs = useMemo(() => {
+        const s = call.started_at ? Date.parse(call.started_at) : undefined;
+        const e = call.ended_at ? Date.parse(call.ended_at) : undefined;
+        if (typeof s === 'number' && typeof e === 'number' && e > s)
+            return e - s;
+        return undefined;
+    }, [call]);
+    const onActivate = useContext(ToolActivateContext);
+    const boundActivate = useMemo(() => (onActivate ? () => onActivate(call.call_id) : null), [onActivate, call.call_id]);
+    const surface = useContext(ToolSurfaceContext);
+    // Read with the other hooks, ABOVE the hidden-tool and thrown-error early
+    // returns — a `useContext` down beside its use site is a conditional hook,
+    // and the order would break on the first errored tool part in a turn.
+    const turnLive = useContext(TurnLiveContext);
+    const fillsPanel = surface === 'panel' && (call.name === 'show' || call.name === 'show-user');
+    // One verdict per part, computed once here and read by every BasicTool below
+    // it. See `partOutcome` — a tool that RETURNS its error looks identical to a
+    // tool that threw as far as the reader is concerned, so it must look
+    // identical on the row too.
+    const outcome = useMemo(() => partOutcome(call), [call]);
+    // The SDK's verdict on tools that never render (a todo read, context bookkeeping).
+    if (!shouldShowToolPart(call))
+        return null;
+    // A failed `task` dispatch is still a dispatch. OpenCode keeps the child
+    // session alive through the failure (its id rides the part's
+    // `state.metadata.sessionId`, or the `task_id:` sentence in the error), so
+    // the row must stay a dispatch row — TaskTool's "Open full view" affordance
+    // and the child's transcript. Collapsing it into the generic error card
+    // below left the child thread unopenable from the session UI, which is
+    // exactly what a failed subagent looked like to a reader (KRTX-1746).
+    // TaskTool draws `state.error` itself, so the failure reason stays on the
+    // row too. Only the task tool takes this route: the other errored tools have
+    // no child thread to lose, and the generic card is the only renderer that
+    // shows the error text of a tool that does not draw it itself.
+    const errorStr = partError(call);
+    const childBearingTaskError = errorStr !== undefined && toolKind(call.name) === 'task' && Boolean(getChildSessionId(call));
+    // A failed codemode script keeps its partial output and the calls it made before
+    // the failure: its own row draws them, with the error.
+    const drawsOwnError = childBearingTaskError || call.name === 'codemode';
+    if (errorStr !== undefined && !drawsOwnError) {
+        const { display, server } = (() => {
+            const slashIdx = call.name.lastIndexOf('/');
+            const s = slashIdx > 0 ? call.name.slice(0, slashIdx) : null;
+            const n = slashIdx > 0 ? call.name.slice(slashIdx + 1) : call.name;
+            const d = n.replace(/[-_]/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase());
+            return { display: d, server: s };
+        })();
+        // No `icon` prop: the outcome context supplies the same warning triangle a
+        // tool that returned its error gets. A thrown call and a returned error are
+        // the same event to the reader, so they must not be two different marks.
+        //
+        // `defaultOpen`/`forceOpen` are threaded for the same reason every other
+        // branch threads them: the panel surface is a disclosure now, and the one
+        // thing nobody wants behind a closed row is the error that explains the
+        // failure. This branch used to drop both, so an errored call painted shut
+        // on the very surface (Advanced, a single-call detail) whose whole job is
+        // showing it.
+        return (_jsx(BoundActivateContext.Provider, { value: boundActivate, children: _jsx(ToolOutcomeContext.Provider, { value: outcome, children: _jsx(ToolDurationContext.Provider, { value: toolDurationMs, children: _jsx(BasicTool, { trigger: {
+                            title: display,
+                            subtitle: tI18nComplete.raw('text5d28a90f4498'),
+                            args: server ? [server] : undefined,
+                        }, badge: "error", defaultOpen: defaultOpen, forceOpen: !!permission || !!question, locked: !!permission || !!question, children: _jsx(ToolError, { error: errorStr, toolName: call.name }) }) }) }) }));
+    }
+    const RegisteredComponent = ToolRegistry.get(call.name, call.kind);
+    const forceOpen = !!permission || !!question;
+    const isLocked = !!permission || !!question;
+    // A call whose arguments have not arrived: `pending`, no `input`, no streamed
+    // `raw`. That shape is produced twice — once by a leftover part from a run
+    // that died, and once by every live call, for the frames between "the call
+    // exists" and "its first argument chunk landed".
+    //
+    // `turnLive` is what separates them, and nothing on the part can (see
+    // {@link TurnLiveContext}). Without it this test matched the live case too,
+    // so a `write` that had just started rendered its "the run is over" body —
+    // the frozen-looking row under a status line that was still saying
+    // "Making changes...".
+    const isStalePending = sessionLogCallStatus(call, turnLive) === 'interrupted' &&
+        call.status === 'pending' &&
+        Object.keys(partStreamingInput(call)).length === 0;
+    const isRunning = !isStalePending && (call.status === 'running' || call.status === 'pending');
+    const toolElement = RegisteredComponent ? (_jsx(RegisteredComponent, { call: call, sessionId: sessionId, defaultOpen: defaultOpen, forceOpen: forceOpen, locked: isLocked, hasActiveQuestion: !!question, onPermissionReply: onPermissionReply })) : (
+    // Same four props the registered branch above gets. `GenericTool` is the
+    // fallback for every unregistered/MCP tool, and dropping them left that
+    // whole class of call permanently closed and unopenable on the panel — the
+    // one surface where a single call IS the view.
+    _jsx(GenericTool, { call: call, defaultOpen: defaultOpen, forceOpen: forceOpen, locked: isLocked }));
+    return (_jsx(ToolNavigationContext.Provider, { value: !disableNavigation, children: _jsx(ToolRunningContext.Provider, { value: isRunning, children: _jsx(ToolOutcomeContext.Provider, { value: outcome, children: _jsx(ToolDurationContext.Provider, { value: toolDurationMs, children: _jsx(StalePendingContext.Provider, { value: isStalePending, children: _jsx(BoundActivateContext.Provider, { value: boundActivate, children: _jsxs("div", { className: cn('relative', fillsPanel && 'h-full'), children: [toolElement, permission && onPermissionReply && (_jsx("div", { className: "mt-1.5", children: _jsx(PermissionPromptInline, { permission: permission, onReply: onPermissionReply }) })), question && onQuestionReply && onQuestionReject && (_jsx("div", { className: "mt-1.5", children: _jsx(QuestionPrompt, { request: question, onReply: onQuestionReply, onReject: onQuestionReject }) }))] }) }) }) }) }) }) }));
+}
+/**
+ * The boundary that stops a settled tool row re-rendering with the stream.
+ *
+ * Everything expensive on a collapsed row lives BELOW this line: `partOutput`'s
+ * regex passes, `getToolDiagnostics`, `parseReadOutput`. The disclosure gate
+ * protects the child's render, but it protects nothing in the parent that
+ * computed the props — so without a boundary here, a fifty-turn transcript
+ * re-parses every tool's output on every SSE frame.
+ *
+ * The default shallow compare is right: `call` objects are replaced, not
+ * mutated, when they change; `onPermissionReply` and `onQuestionReply` are
+ * `useCallback`s; `permission` is either `undefined` or a store object.
+ *
+ * `memo` does not block context propagation, so `ToolSurfaceContext`,
+ * `ToolActivateContext` and `ToolOutcomeContext` still reach the tool.
+ */
+export const ToolPartRenderer = memo(ToolPartRendererImpl);
+ToolPartRenderer.displayName = 'ToolPartRenderer';

package/dist/session/tool/tool-renderers.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Session tool renderers — public barrel.
+ */
+export { BasicTool, ToolActivateContext, ToolSurfaceContext, TurnLiveContext, shouldShowToolPartInActionsPanel, type ToolSurface, } from './shared/infrastructure.js';
+export { GenericTool } from './generic-tool.js';
+export { ToolRegistry } from './shared/registry.js';
+export { ToolError } from './tool-error.js';
+export { ToolPartRenderer } from './tool-part-renderer.js';

package/dist/session/tool/tool-renderers.js

@@ -0,0 +1,8 @@
+/**
+ * Session tool renderers — public barrel.
+ */
+export { BasicTool, ToolActivateContext, ToolSurfaceContext, TurnLiveContext, shouldShowToolPartInActionsPanel, } from './shared/infrastructure.js';
+export { GenericTool } from './generic-tool.js';
+export { ToolRegistry } from './shared/registry.js';
+export { ToolError } from './tool-error.js';
+export { ToolPartRenderer } from './tool-part-renderer.js';

package/dist/session/tool/tools/agent-message-tool.d.ts

@@ -0,0 +1,2 @@
+import type { ToolProps } from '../shared/types.js';
+export declare function AgentMessageTool({ call, defaultOpen, forceOpen }: ToolProps): import("react").JSX.Element;

package/dist/session/tool/tools/agent-message-tool.js

@@ -0,0 +1,29 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { SubSessionModal } from '../../thread/sub-session-modal.js';
+import { BasicTool, isErrorOutput, partInput, partOutput, partStatus, ToolOutputFallback, } from '../shared/infrastructure.js';
+import { ToolRegistry } from '../shared/registry.js';
+import { useTranslations } from '../../../i18n/index.js';
+import { getChildSessionId } from '../../../internal/session-types/index.js';
+import { ChatCircleIcon as MessageCircle } from '@phosphor-icons/react';
+import { useMemo, useState } from 'react';
+export function AgentMessageTool({ call, defaultOpen, forceOpen }) {
+    const tI18nComplete = useTranslations('hardcodedUi.i18nComplete');
+    const input = partInput(call);
+    const status = partStatus(call);
+    const output = partOutput(call);
+    const rawMessage = input.message || '';
+    const taskId = input.id || input.agent_id || '';
+    // `isErrorOutput` trims a copy of the whole output and runs `JSON.parse` over
+    // it. Called from the render body it did that on every frame of the stream.
+    const isError = useMemo(() => status === 'error' || (status === 'completed' && isErrorOutput(output)), [status, output]);
+    const [modalOpen, setModalOpen] = useState(false);
+    const childSessionId = useMemo(() => getChildSessionId(call), [call]);
+    const hasSession = !!childSessionId;
+    return (_jsxs(_Fragment, { children: [_jsx(BasicTool, { icon: _jsx(MessageCircle, { className: "size-3.5 shrink-0" }), trigger: {
+                    title: tI18nComplete.raw('text8833ce4e6595'),
+                    subtitle: taskId ? taskId.slice(-12) : undefined,
+                    args: isError ? ['failed'] : undefined,
+                }, onSubtitleClick: hasSession ? () => setModalOpen(true) : undefined, defaultOpen: defaultOpen, forceOpen: forceOpen, children: isError ? (_jsx(ToolOutputFallback, { output: output, toolName: "agent_message" })) : rawMessage ? (_jsx("div", { className: "text-muted-foreground px-3 py-2 text-xs leading-relaxed whitespace-pre-wrap", children: rawMessage })) : null }), hasSession && (_jsx(SubSessionModal, { open: modalOpen, onOpenChange: setModalOpen, sessionId: childSessionId, title: tI18nComplete('text8116da8fa64c', { value0: taskId || 'worker' }) }))] }));
+}
+ToolRegistry.register('agent-message', AgentMessageTool);

package/dist/session/tool/tools/agent-spawn-tool.d.ts

@@ -0,0 +1,2 @@
+import type { ToolProps } from '../shared/types.js';
+export declare function AgentSpawnTool({ call, defaultOpen, forceOpen }: ToolProps): import("react").JSX.Element;

package/dist/session/tool/tools/agent-spawn-tool.js

@@ -0,0 +1,69 @@
+'use client';
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { SubSessionModal } from '../../thread/sub-session-modal.js';
+import { BasicTool, firstMeaningfulLine, getAgentCardLabel, parseJsonFailure, partInput, partOutput, partStatus, ToolOutputFallback, ToolSurfaceContext, } from '../shared/infrastructure.js';
+import { OutputBlock } from '../shared/output-block.js';
+import { ToolRegistry } from '../shared/registry.js';
+import { ToolResultCard } from '../shared/result-card.js';
+import { SubAgentActivity, SubAgentStatusBanner, useSubAgentThread, } from '../shared/sub-agent.js';
+import { getChildSessionId, getToolInfo } from '../../../internal/session-types/index.js';
+import { CheckIcon as Check, CpuIcon as Cpu } from '@phosphor-icons/react';
+import { useTranslations } from '../../../i18n/index.js';
+import { useContext, useMemo, useState } from 'react';
+import { cleanWorkerOutput } from '@kortix/sdk';
+import { subAgentCalls } from '@kortix/sdk';
+export function AgentSpawnTool({ call, defaultOpen, forceOpen }) {
+    const tI18nComplete = useTranslations('hardcodedUi.i18nComplete');
+    const surface = useContext(ToolSurfaceContext);
+    const input = partInput(call);
+    const status = partStatus(call);
+    const output = partOutput(call);
+    // Both walk the input's prose: `getAgentCardLabel` tries up to five fields and
+    // `firstMeaningfulLine` splits each one on every newline before taking the
+    // first non-blank. A spawn carries a whole prompt, so that is a full scan plus
+    // a line array per render — and this row re-renders on every frame of the
+    // child session's stream, because `useSubAgentThread` below subscribes to it.
+    const description = useMemo(() => getAgentCardLabel(input), [input]);
+    const verification = useMemo(() => firstMeaningfulLine(input.verification_condition, 120), [input]);
+    const isRunning = status === 'running' || status === 'pending';
+    const isCompleted = status === 'completed';
+    const childSessionId = useMemo(() => getChildSessionId(call), [call]);
+    const childThread = useSubAgentThread(childSessionId);
+    const childCalls = useMemo(() => subAgentCalls(childThread), [childThread]);
+    const [modalOpen, setModalOpen] = useState(false);
+    const lastActivity = useMemo(() => {
+        if (childCalls.length === 0)
+            return null;
+        const last = childCalls[childCalls.length - 1];
+        const info = getToolInfo(last.name, partInput(last));
+        return info.title + (info.subtitle ? ` · ${info.subtitle}` : '');
+    }, [childCalls]);
+    const cleanedOutput = useMemo(() => cleanWorkerOutput(output), [output]);
+    const spawnFailure = useMemo(() => (isCompleted ? parseJsonFailure(output) : null), [isCompleted, output]);
+    const hasSession = !!childSessionId;
+    return (_jsxs(_Fragment, { children: [_jsxs(BasicTool, { icon: _jsx(Cpu, { className: "size-3.5 shrink-0" }), trigger: {
+                    title: tI18nComplete.raw('text9577487fd26d'),
+                    subtitle: isRunning
+                        ? (lastActivity ?? description)
+                        : spawnFailure
+                            ? 'failed'
+                            : description || undefined,
+                }, onSubtitleClick: hasSession ? () => setModalOpen(true) : undefined, badge: isCompleted && childCalls.length > 0 ? `${childCalls.length} steps` : undefined, defaultOpen: defaultOpen, forceOpen: forceOpen, children: [isCompleted && spawnFailure ? (_jsxs(_Fragment, { children: [verification && (_jsx(ToolResultCard, { children: _jsxs("div", { className: "text-muted-foreground/60 px-2 py-1.5 text-xs leading-relaxed", children: ["\u2713 ", verification] }) })), _jsx(ToolOutputFallback, { output: output, toolName: "agent_spawn" })] })) : verification || (isCompleted && (cleanedOutput || childCalls.length > 0)) ? (_jsx(ToolResultCard, { children: _jsxs("div", { className: "space-y-2 px-2 py-1.5", children: [verification && (_jsxs("div", { className: "text-muted-foreground/60 text-xs leading-relaxed", children: ["\u2713 ", verification] })), isCompleted && cleanedOutput ? (_jsx(OutputBlock, { text: cleanedOutput, markdown: true })) : isCompleted && childCalls.length > 0 ? (_jsxs("div", { className: "space-y-0.5", children: [childCalls.slice(-3).map((step) => {
+                                            const info = getToolInfo(step.name, partInput(step));
+                                            return (_jsxs("div", { className: "text-muted-foreground flex items-center gap-1.5 truncate text-xs", children: [_jsx(Check, { className: "text-muted-foreground/50 size-2.5 shrink-0" }), info.title, info.subtitle ? ` · ${info.subtitle}` : ''] }, step.id));
+                                        }), childCalls.length > 3 && (_jsxs("div", { className: "text-muted-foreground/50 pl-4 text-xs", children: ["+", childCalls.length - 3, " ", tI18nComplete.raw('text187897ce0afc')] }))] })) : null] }) })) : null, surface === 'panel' && childCalls.length > 0 && (
+                    // Full-bleed seam, not a nested box. The panel row body already
+                    // supplies the 12px gutter this sits in, so a `p-3` here inset the
+                    // activity list a second time (24px of gutter around a 420px pane)
+                    // and pulled the hairline in from both edges — a second frame drawn
+                    // inside the row card's. `-mx-3` cancels the body's horizontal inset
+                    // so the `border-t` spans the card edge to edge, `px-3` puts the
+                    // content back where it was, and only the top inset survives.
+                    _jsx("div", { className: "border-border/30 -mx-3 border-t px-3 pt-3", children: _jsx(SubAgentActivity, { childSessionId: childSessionId, calls: childCalls }) })), _jsx(SubAgentStatusBanner, { childSessionId: childSessionId, childThread: childThread })] }), hasSession && (_jsx(SubSessionModal, { open: modalOpen, onOpenChange: setModalOpen, sessionId: childSessionId, title: description }))] }));
+}
+ToolRegistry.register('agent-spawn', AgentSpawnTool);
+ToolRegistry.register('agent-task', AgentSpawnTool);
+ToolRegistry.register('agent-task-create', AgentSpawnTool);
+ToolRegistry.register('agent-task-start', AgentSpawnTool);
+ToolRegistry.register('task-create', AgentSpawnTool);
+ToolRegistry.register('task-start', AgentSpawnTool);

package/dist/session/tool/tools/agent-status-tool.d.ts

@@ -0,0 +1,2 @@
+import type { ToolProps } from '../shared/types.js';
+export declare function AgentStatusTool({ call, defaultOpen, forceOpen }: ToolProps): import("react").JSX.Element;

package/dist/session/tool/tools/agent-status-tool.js

@@ -0,0 +1,47 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Badge } from '../../../primitives/badge.js';
+import Loading from '../../../primitives/loading.js';
+import { STATUS_TEXT } from '../../../primitives/status.js';
+import { SubSessionModal } from '../../thread/sub-session-modal.js';
+import { BasicTool, isErrorOutput, partOutput, partStatus, ToolOutputFallback, } from '../shared/infrastructure.js';
+import { ToolRegistry } from '../shared/registry.js';
+import { cn } from '../../../lib/utils.js';
+import { CheckIcon as Check, CaretRightIcon as ChevronRight, CircleIcon as Circle, ClockIcon as Clock, StackIcon as Layers, XIcon as X, } from '@phosphor-icons/react';
+import { useTranslations } from '../../../i18n/index.js';
+import { useMemo, useState } from 'react';
+import { cleanWorkerOutput, parseTaskRows } from '@kortix/sdk';
+import { OutputBlock } from '../shared/output-block.js';
+export function AgentStatusTool({ call, defaultOpen, forceOpen }) {
+    const tI18nComplete = useTranslations('hardcodedUi.i18nComplete');
+    const status = partStatus(call);
+    const output = partOutput(call);
+    const isRunning = status === 'running' || status === 'pending';
+    const [modalSessionId, setModalSessionId] = useState(null);
+    const [modalTitle, setModalTitle] = useState('');
+    const taskRows = useMemo(() => parseTaskRows(output), [output]);
+    const cleanedOutput = useMemo(() => cleanWorkerOutput(output), [output]);
+    // `isErrorOutput` trims a copy of the whole output and runs `JSON.parse` over
+    // it, and the two branches below asked it twice per render.
+    const isError = useMemo(() => isErrorOutput(output), [output]);
+    return (_jsxs(_Fragment, { children: [_jsxs(BasicTool, { icon: _jsx(Layers, { className: "size-3.5 shrink-0" }), trigger: { title: tI18nComplete.raw('textca9c05caf0c3') }, badge: !isRunning && taskRows.length > 0 ? (_jsxs(Badge, { variant: "muted", size: "sm", children: [taskRows.length, " ", tI18nComplete.raw('text0ebb429fa86d'), taskRows.length !== 1 ? 's' : ''] })) : undefined, defaultOpen: defaultOpen, forceOpen: forceOpen, children: [!isRunning && taskRows.length > 0 && (_jsx("div", { children: taskRows.map((row, i) => {
+                            const hasSession = !!row.sessionId;
+                            const isActive = row.status === 'in_progress';
+                            return (_jsxs("div", { role: hasSession ? 'button' : undefined, tabIndex: hasSession ? 0 : undefined, onClick: () => {
+                                    if (hasSession) {
+                                        setModalSessionId(row.sessionId);
+                                        setModalTitle(row.title);
+                                    }
+                                }, onKeyDown: (e) => {
+                                    if (e.key === 'Enter' && hasSession) {
+                                        setModalSessionId(row.sessionId);
+                                        setModalTitle(row.title);
+                                    }
+                                }, className: cn('border-border/20 flex items-center gap-2.5 px-3 py-2', i > 0 && 'border-t', hasSession && 'hover:bg-accent/50 cursor-pointer transition-colors'), children: [isActive ? (_jsx(Loading, { className: "text-muted-foreground size-3 shrink-0" })) : row.status === 'completed' ? (_jsx(Check, { className: cn('size-3 shrink-0', STATUS_TEXT.success) })) : row.status === 'input_needed' ? (_jsx(Clock, { className: cn('size-3 shrink-0', STATUS_TEXT.warning) })) : row.status === 'cancelled' ? (_jsx(X, { className: "text-muted-foreground/40 size-3 shrink-0" })) : (_jsx(Circle, { className: "text-muted-foreground/40 size-3 shrink-0" })), _jsx("span", { className: "text-foreground/80 flex-1 truncate text-xs", children: row.title }), _jsx("span", { className: "text-muted-foreground/50 shrink-0 font-mono text-xs", children: row.id.slice(-8) }), hasSession && (_jsx(ChevronRight, { className: "text-muted-foreground/20 size-3 shrink-0" }))] }, row.id));
+                        }) })), !isRunning && isError && _jsx(ToolOutputFallback, { output: output, toolName: "agent_status" }), !isRunning && !isError && taskRows.length === 0 && cleanedOutput && (_jsx(OutputBlock, { text: cleanedOutput }))] }), modalSessionId && (_jsx(SubSessionModal, { open: !!modalSessionId, onOpenChange: (open) => {
+                    if (!open)
+                        setModalSessionId(null);
+                }, sessionId: modalSessionId, title: modalTitle }))] }));
+}
+ToolRegistry.register('agent-status', AgentStatusTool);
+ToolRegistry.register('agent-task-list', AgentStatusTool);

package/dist/session/tool/tools/agent-stop-tool.d.ts

@@ -0,0 +1,2 @@
+import type { ToolProps } from '../shared/types.js';
+export declare function AgentStopTool({ call, forceOpen }: ToolProps): import("react").JSX.Element;

package/dist/session/tool/tools/agent-stop-tool.js

@@ -0,0 +1,17 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { BasicTool, partInput } from '../shared/infrastructure.js';
+import { ToolRegistry } from '../shared/registry.js';
+import { StopCircleIcon as StopCircle } from '@phosphor-icons/react';
+import { useTranslations } from '../../../i18n/index.js';
+export function AgentStopTool({ call, forceOpen }) {
+    const tI18nComplete = useTranslations('hardcodedUi.i18nComplete');
+    const input = partInput(call);
+    const agentId = input.agent_id || '';
+    return (_jsx(BasicTool, { icon: _jsx(StopCircle, { className: "size-3.5 shrink-0" }), trigger: {
+            title: tI18nComplete.raw('texta8b750b1f323'),
+            subtitle: agentId ? agentId.slice(-12) : undefined,
+            args: ['stopped'],
+        }, forceOpen: forceOpen }));
+}
+ToolRegistry.register('agent-stop', AgentStopTool);

package/dist/session/tool/tools/agent-task-update-tool.d.ts

@@ -0,0 +1,2 @@
+import type { ToolProps } from '../shared/types.js';
+export declare function AgentTaskUpdateTool({ call, defaultOpen, forceOpen }: ToolProps): import("react").JSX.Element;

package/dist/session/tool/tools/agent-task-update-tool.js

@@ -0,0 +1,43 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { STATUS_TEXT } from '../../../primitives/status.js';
+import { BasicTool, partInput } from '../shared/infrastructure.js';
+import { ToolRegistry } from '../shared/registry.js';
+import { cn } from '../../../lib/utils.js';
+import { CheckIcon as Check } from '@phosphor-icons/react';
+import { useTranslations } from '../../../i18n/index.js';
+import { AgentMessageTool } from './agent-message-tool.js';
+import { AgentSpawnTool } from './agent-spawn-tool.js';
+import { AgentStopTool } from './agent-stop-tool.js';
+import { TaskDoneTool } from './task-done-tool.js';
+export function AgentTaskUpdateTool({ call, defaultOpen, forceOpen }) {
+    const tI18nComplete = useTranslations('hardcodedUi.i18nComplete');
+    const input = partInput(call);
+    const action = input.action || '';
+    switch (action) {
+        case 'start':
+            return _jsx(AgentSpawnTool, { call: call, defaultOpen: defaultOpen, forceOpen: forceOpen });
+        case 'message':
+            return _jsx(AgentMessageTool, { call: call, defaultOpen: defaultOpen, forceOpen: forceOpen });
+        case 'cancel':
+            return _jsx(AgentStopTool, { call: call, forceOpen: forceOpen });
+        case 'approve': {
+            const taskId = input.id || '';
+            return (_jsx(BasicTool, { icon: _jsx(Check, { className: cn('size-3.5 shrink-0', STATUS_TEXT.success) }), trigger: {
+                    title: tI18nComplete.raw('text4b8fa0516b54'),
+                    subtitle: taskId ? taskId.slice(-12) : undefined,
+                    args: ['approved'],
+                }, forceOpen: forceOpen }));
+        }
+        default:
+            return _jsx(AgentMessageTool, { call: call, defaultOpen: defaultOpen, forceOpen: forceOpen });
+    }
+}
+ToolRegistry.register('agent-task-update', AgentTaskUpdateTool);
+ToolRegistry.register('task-update', AgentTaskUpdateTool);
+ToolRegistry.register('agent-task-message', AgentMessageTool);
+ToolRegistry.register('task-message', AgentMessageTool);
+ToolRegistry.register('agent-task-approve', TaskDoneTool);
+ToolRegistry.register('agent-task-cancel', AgentStopTool);
+ToolRegistry.register('task-approve', TaskDoneTool);
+ToolRegistry.register('task-cancel', AgentStopTool);

package/dist/session/tool/tools/apply-patch-tool.d.ts

@@ -0,0 +1,2 @@
+import type { ToolProps } from '../shared/types.js';
+export declare function ApplyPatchTool({ call, defaultOpen, forceOpen, locked }: ToolProps): import("react").JSX.Element;

package/dist/session/tool/tools/apply-patch-tool.js

@@ -0,0 +1,122 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Badge } from '../../../primitives/badge.js';
+import { DiffStat } from '../../../primitives/status.js';
+import { TextShimmer } from '../../../primitives/text-shimmer.js';
+import { BasicTool, InlineDiffView, isErrorOutput, partMetadata, partOutput, partStatus, ToolOutputFallback, ToolRunningContext, } from '../shared/infrastructure.js';
+import { ToolRegistry } from '../shared/registry.js';
+import { ToolResultCard } from '../shared/result-card.js';
+import { cn } from '../../../lib/utils.js';
+import { useFilePreviewStore } from '../../../internal/stores/file-preview-store.js';
+import { getDirectory, getFilename } from '../../../internal/session-types/index.js';
+import { CaretRightIcon as ChevronRight, FileMinusIcon, FilePlusIcon, PencilSimpleIcon, } from '@phosphor-icons/react';
+import { useTranslations } from '../../../i18n/index.js';
+import { useLocalizedUiCatalog } from '../../../i18n/ui-catalog/use-localized-ui-catalog.js';
+import { useContext, useMemo, useState } from 'react';
+import { PATCH_TYPE_STYLE, patchFilesFromText, RawPatchDiffView, } from '../shared/patch-helpers.js';
+import { patchVerb } from '@kortix/sdk';
+const PATCH_ICON = {
+    create: FilePlusIcon,
+    delete: FileMinusIcon,
+    edit: PencilSimpleIcon,
+};
+export function ApplyPatchTool({ call, defaultOpen, forceOpen, locked }) {
+    const tI18nComplete = useTranslations('hardcodedUi.i18nComplete');
+    const patchTypeStyle = useLocalizedUiCatalog(PATCH_TYPE_STYLE);
+    const metadata = partMetadata(call);
+    const status = partStatus(call);
+    const output = partOutput(call);
+    // `isErrorOutput` trims a copy of the whole output and runs `JSON.parse` over
+    // it. Called from the render body it did that on every frame of the stream.
+    const isError = useMemo(() => status === 'completed' && isErrorOutput(output), [status, output]);
+    const running = useContext(ToolRunningContext);
+    // Selector, not the bare store: destructuring the hook subscribes this row to
+    // EVERY field, so opening one file preview re-rendered every patch row on
+    // screen. `openPreview` is a stable action, so this row now never re-renders
+    // for the preview state at all.
+    const openPreview = useFilePreviewStore((s) => s.openPreview);
+    const files = useMemo(() => {
+        const raw = metadata.files;
+        if (Array.isArray(raw))
+            return raw;
+        // No `files` metadata (a Codex `apply_patch`): read the settled call's patch text — the
+        // whole input of a freeform call, else OpenCode's `patchText` or a wrapped `input`.
+        if (call.status !== 'complete')
+            return [];
+        const input = call.input;
+        const text = typeof input === 'string' ? input : (input?.patchText ?? input?.input);
+        return typeof text === 'string' ? patchFilesFromText(text) : [];
+    }, [metadata.files, call.status, call.input]);
+    const [expanded, setExpanded] = useState(files.length === 1 ? 0 : null);
+    const isStreaming = (status === 'pending' || status === 'running') && running;
+    /**
+     * "Apply Patch" named the mechanism; this names the outcome.
+     *
+     * The verb comes from what the patch holds, so four new files read
+     * `Created 4 files` rather than `Apply Patch 4 files`. See `patch-summary.ts`.
+     */
+    const verb = useMemo(() => patchVerb(files.map((f) => f.type)), [files]);
+    // A failed patch must not wear the wording of a patch that landed. The row
+    // already flipped its ICON to a warning via `ToolOutcomeContext`, but kept
+    // saying `Created 4 files` underneath it — the glyph and the words disagreeing
+    // about the same call, which is the exact lie `group-steps.ts` forbids (W7).
+    const triggerTitle = isError ? verb.failed : isStreaming ? verb.running : verb.verb;
+    const Icon = PATCH_ICON[verb.icon];
+    const triggerSubtitle = useMemo(() => {
+        // No file list — either the call is still streaming (in which case the row
+        // is the shimmer below, not this) or it settled without one. Either way the
+        // verb carries the row alone: a subtitle here would be a count of files we
+        // have not been told about.
+        if (files.length === 0)
+            return undefined;
+        // One file names itself, the same grammar the chain's file rows use.
+        if (files.length === 1) {
+            const f = files[0];
+            return getFilename(f.relativePath || f.filePath || '') || undefined;
+        }
+        return `${files.length} files`;
+    }, [files]);
+    /**
+     * The call is live and not one file has arrived — so there is nothing to
+     * name, nothing to count and nothing to open.
+     *
+     * This state used to be an expanded BODY holding one shimmering line. Three
+     * separate defects came with it, all of which this branch removes rather
+     * than tunes:
+     *
+     *  1. It made a payload-less row a disclosure. `CollapsibleToolRow` already
+     *     states the rule — a row with no children is not a door — and the row
+     *     carried a caret onto a body that could only say "still working".
+     *  2. Its `px-3` put the line 12px in, while every other body under a tool
+     *     row takes its offset from `--tool-indent` (28px inside a chain). The
+     *     `ChainOfThought` rail runs at `left-2`, so the shimmer sat 4px off the
+     *     hairline — the exact "content at the margin, rail through the text"
+     *     failure `chain-of-thought.tsx` documents — and then jumped 16px right
+     *     the moment the file list replaced it.
+     *  3. It said the same thing the burst summary above it and the session
+     *     status line below it were both already saying.
+     *
+     * So the liveness moves INTO the row, which is where `show-tool` and `bash`
+     * both already put it: one shimmering line, on the trigger, at the row's own
+     * scale. `bash` renders the identical shape for its stale-pending state.
+     */
+    const isPreparing = isStreaming && files.length === 0;
+    return (_jsx(BasicTool, { icon: _jsx(Icon, { className: "size-3.5 shrink-0" }), trigger: isPreparing ? (_jsx("div", { className: "flex min-w-0 flex-1 items-center", children: _jsx(TextShimmer, { duration: 1, spread: 2, className: "min-w-0 truncate text-sm", children: tI18nComplete.raw('text778ed69bedf7') }) })) : ({
+            title: triggerTitle,
+            subtitle: triggerSubtitle,
+        }), defaultOpen: defaultOpen, forceOpen: forceOpen, locked: locked, children: isError ? (_jsx(ToolOutputFallback, { output: output, toolName: "apply_patch" })) : files.length > 0 ? (_jsx(ToolResultCard, { bodyClassName: "max-h-[480px]", children: files.map((file, i) => {
+                const relPath = file.relativePath || file.filePath || '';
+                const name = getFilename(relPath) || relPath;
+                const dir = getDirectory(relPath);
+                const typeKey = (file.type || 'update');
+                const typeMeta = patchTypeStyle[typeKey] ?? patchTypeStyle.update;
+                const isOpen = expanded === i;
+                const hasDiff = file.before != null || file.after != null || !!file.patch || !!file.diff;
+                return (_jsxs("div", { children: [_jsxs("button", { type: "button", className: "hover:bg-muted flex w-full min-w-0 items-center gap-2.5 rounded-sm px-2 py-2 text-left transition-colors duration-150", onClick: () => (hasDiff ? setExpanded(isOpen ? null : i) : undefined), children: [hasDiff ? (_jsx(ChevronRight, { className: cn('text-muted-foreground/60 size-3.5 shrink-0 transition-transform', isOpen && 'rotate-90') })) : (_jsx("span", { className: "w-3.5 shrink-0" })), _jsx(Badge, { variant: typeMeta.tone, size: "sm", className: "shrink-0 normal-case", children: typeMeta.label }), _jsx("span", { className: "text-foreground hover:text-primary min-w-0 flex-1 cursor-pointer truncate font-mono text-sm", title: relPath, onClick: (e) => {
+                                        e.stopPropagation();
+                                        if (relPath)
+                                            openPreview(relPath);
+                                    }, children: name }), dir && (_jsx("span", { className: "text-muted-foreground max-w-[35%] shrink-0 truncate font-mono text-sm", title: dir, children: dir })), _jsx(DiffStat, { additions: file.additions, deletions: file.deletions, className: "shrink-0 text-sm tabular-nums" })] }), isOpen && hasDiff && (_jsx("div", { className: "border-border/60 bg-muted/20 mt-1 mb-1 overflow-hidden rounded-sm border", children: file.before != null && file.after != null ? (_jsx(InlineDiffView, { oldValue: file.before, newValue: file.after, filename: name })) : file.patch || file.diff ? (_jsx(RawPatchDiffView, { patch: (file.patch || file.diff), filename: name })) : null }))] }, `${typeKey}:${relPath}`));
+            }) })) : null }));
+}
+ToolRegistry.register('apply-patch', ApplyPatchTool);

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

@@ -0,0 +1,54 @@
+import type { ToolProps } from '../shared/types.js';
+/**
+ * The words a settled row leads with.
+ *
+ * The bash tool's input carries a `description` — the one-line summary the
+ * model writes for its own call ("Install the workspace dependencies"). The
+ * SDK already reads it as this tool's subtitle (`core/turns/parts.ts`, case
+ * `'bash'`), so the row promotes a source it had been dropping rather than
+ * inventing one. A reader scanning a turn wants to know what a command was
+ * FOR, and `pnpm -w install --frozen-lockfile` answers that only if they read
+ * shell.
+ *
+ * Three rules, in order:
+ * - A failure keeps its verdict. "Command failed" is the one thing a friendly
+ *   summary must never soften, so it outranks any description.
+ * - No description → exactly today's "Ran command". Nothing is ever derived
+ *   from the command text: a classifier answering "Installed dependencies" to
+ *   `npm i` would put a claim in the model's mouth that it never made.
+ * - Sentence case only lifts a lower-case opener. Lowering the rest would turn
+ *   "Run CI on the release branch" into "Run ci on the release branch".
+ */
+export declare function bashRowTitle(description: unknown, failed: boolean): string;
+/**
+ * The command as the reader should see it: leading indent stripped, blank
+ * edges dropped.
+ *
+ * Commands arrive with incidental leading whitespace — a model quoting a
+ * command out of indented YAML/JSON sends `  agent-browser open …`. The
+ * trigger row hides it (a `truncate` span collapses spaces under normal
+ * white-space), but the card's `whitespace-pre-wrap` pane renders it verbatim,
+ * so the first line sits two characters deeper than its own wrapped
+ * continuation and the output below — an inverse hanging indent that reads as
+ * broken padding.
+ *
+ * Two rules, because a one-line command and a script are different documents:
+ *
+ * - **One line has no structure to protect**, so every leading blank is noise
+ *   and all of it goes. This is the case a common-indent rule cannot be
+ *   trusted with alone: it only strips what it can MEASURE, and the measure
+ *   used to be `[ \t]` — so a command indented with a non-breaking space (or
+ *   any other Unicode space; agents paste these out of rendered docs and
+ *   spreadsheets) kept its indent and drew exactly the misalignment above.
+ * - **A script keeps its shape**: the COMMON indent goes, never a per-line
+ *   trim, so nesting survives. Heredocs survive by construction — a non-`<<-`
+ *   heredoc needs its terminator at column 0, which pins the common indent to
+ *   0 and makes this a no-op exactly where indentation is load-bearing.
+ *
+ * `[^\S\r\n]` is "whitespace that is not a line break", so both rules count
+ * every horizontal space character the Unicode table has, not just the two on
+ * a US keyboard. The trailing trim also stops a final `\n` from counting as a
+ * phantom `+1` line in the trigger.
+ */
+export declare function dedentCommand(raw: string): string;
+export declare function BashTool({ call, defaultOpen, forceOpen, locked }: ToolProps): import("react").JSX.Element;