@kortix/ui 0.0.0-stage → 0.14.4

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

@@ -0,0 +1,92 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { filePhase, fileVerb } from '@kortix/sdk';
+import { BasicTool, DiagnosticsDisplay, getToolDiagnostics, isErrorOutput, partInput, partOutput, partStatus, partStreamingInput, ToolCodeCard, ToolOutputFallback, ToolRunningContext, } from '../shared/infrastructure.js';
+import { ToolRegistry } from '../shared/registry.js';
+import { ToolResultCard } from '../shared/result-card.js';
+import { inputPath } from '@kortix/sdk';
+import { useTranslations } from '../../../i18n/index.js';
+import { useFilePreviewStore } from '../../../internal/stores/file-preview-store.js';
+import { getFilename } from '../../../internal/session-types/index.js';
+import { PencilSimpleIcon } from '@phosphor-icons/react';
+import { useCallback, useContext, useMemo } from 'react';
+/**
+ * The stat the row reports beside the filename — a green `+42`, in the same
+ * DiffStat the edit row draws, so every file row counts its change the one
+ * way.
+ *
+ * Additions only, and honestly so: a write replaces whatever was there, and
+ * nothing client-side knows the old content (the runtime supplies no
+ * `filediff` for writes), so a deletions number would be an invention.
+ * DiffStat drops the `−0` on its own.
+ *
+ * It counts the STREAMING content, so the number climbs while the file is
+ * being written and settles on the final size — the closed row answers "how
+ * much did this write?" without being opened. Counted with `indexOf` rather
+ * than `split('\n')`: this runs on every streamed chunk of a file that can be
+ * tens of kilobytes, and splitting allocates an array of every line just to
+ * read its length.
+ */
+export function writeStat(content) {
+    if (!content)
+        return undefined;
+    let lines = 1;
+    for (let i = content.indexOf('\n'); i !== -1; i = content.indexOf('\n', i + 1))
+        lines++;
+    return { additions: lines, deletions: 0 };
+}
+export function WriteTool({ call, defaultOpen, forceOpen, locked }) {
+    const tI18nComplete = useTranslations('hardcodedUi.i18nComplete');
+    const input = partInput(call);
+    const streamingInput = partStreamingInput(call);
+    const status = partStatus(call);
+    const running = useContext(ToolRunningContext);
+    const filePath = inputPath(input) || inputPath(streamingInput);
+    // Two `split()` calls — one on the path, one on the basename — allocating two
+    // throwaway arrays per render, for a value that only changes when the part does.
+    const filename = useMemo(() => getFilename(filePath) || '', [filePath]);
+    const content = input.content || streamingInput.content || '';
+    const ext = useMemo(() => filename.split('.').pop() || '', [filename]);
+    const output = partOutput(call);
+    // `isErrorOutput` trims the whole output and attempts a `JSON.parse` over it.
+    // A written file's output is not small, and this ran on every render of the row.
+    const isError = useMemo(() => status === 'completed' && isErrorOutput(output), [status, output]);
+    const stat = useMemo(() => writeStat(content), [content]);
+    // Unmemoised this ran on every frame of a COLLAPSED row: `partOutput` plus two
+    // full-string `includes`, and — when the output carries `<file_diagnostics>` —
+    // a global regex, a full split and a per-line regex on top.
+    const diagnostics = useMemo(() => getToolDiagnostics(call, filePath), [call, filePath]);
+    const isStalePending = !running && !filename && (status === 'pending' || status === 'running');
+    /**
+     * `Write` was the registry key, not a word anyone says. Every other surface in
+     * this feature already reports this call as `Writing app.py` / `Wrote app.py`
+     * — `step-label.ts`, `activity-file-chips.tsx`, the panel's `narration.ts` —
+     * and the trigger was the last one still printing the machine name, frozen in
+     * a tense that matched neither a running call nor a finished one.
+     *
+     * Past tense once the turn is over is the load-bearing half: a restored
+     * transcript is entirely settled calls, and a row reading `Write` there says
+     * nothing about whether it ever did.
+     */
+    const title = fileVerb('write', filePhase(running, isError));
+    // Field selector, not the whole store: destructuring the store subscribes this
+    // row to every field in it, so opening one file preview re-rendered every write
+    // row on screen.
+    const openPreview = useFilePreviewStore((s) => s.openPreview);
+    const handleSubtitleClick = useCallback(() => {
+        if (filePath)
+            openPreview(filePath);
+    }, [filePath, openPreview]);
+    return (_jsxs(BasicTool, { icon: _jsx(PencilSimpleIcon, { className: "size-3.5 shrink-0" }), trigger: {
+            title,
+            subtitle: filename || undefined,
+            // No stat on a failed call: the numbers would describe a file that
+            // did not land.
+            stat: isError ? undefined : stat,
+        }, onSubtitleClick: filePath ? handleSubtitleClick : undefined, defaultOpen: defaultOpen, forceOpen: forceOpen, locked: locked, className: "overflow-hidden p-0", children: [isError ? (_jsx(ToolOutputFallback, { output: output, toolName: "write" })) : content ? (_jsx(ToolCodeCard, { code: content, language: ext })) : isStalePending ? (
+            // A stale part is DONE waiting — the run it belonged to is over. The
+            // shimmer this used to draw promised content that could never arrive,
+            // on every restored session, forever.
+            _jsx(ToolResultCard, { bodyClassName: "px-2 py-1.5", children: _jsx("span", { className: "text-muted-foreground/60 text-xs", children: tI18nComplete.raw('text93168435f3ae') }) })) : null, _jsx(DiagnosticsDisplay, { diagnostics: diagnostics, filePath: filePath })] }));
+}
+ToolRegistry.register('write', WriteTool);

package/dist/session/turn/activity-burst.d.ts

@@ -0,0 +1,65 @@
+import type { ConversationDensity } from '../../internal/stores/user-preferences-store.js';
+import { type SessionLogBlock } from '@kortix/sdk';
+export { ActivityGroupStep, sameActivityGroupStepProps } from './activity-group-step.js';
+/**
+ * A burst of ONE call has nothing to summarise, so it drops the summary line
+ * and IS its row.
+ *
+ * "Completed 1 step" is a door in front of a door: the reader clicks a line
+ * that names no tool, no file and no command, to reveal the one row that names
+ * all three — and that row already opens on its own. Two clicks and a
+ * content-free label to reach what a single row was always going to say.
+ *
+ * `summary.total === 1` is what makes this safe, not `steps.length === 1`
+ * alone: a group row is ONE row over N calls, and "Completed 3 steps" is
+ * information the bare row does not carry.
+ *
+ * A lone thought qualifies too, now that `ThoughtChainStep` gives reasoning a
+ * label and a caret of its own. It did not while the thought was unlabelled
+ * prose: unwrapping THAT would have pinned the model's reasoning open with
+ * nothing left to close it.
+ *
+ * `bare` drops the summary line, and with it the row's leading glyph. It
+ * does not, on its own, decide that a row has no thread — a lone sub-agent is
+ * one row here and a whole nested list of steps one level down, so
+ * `ActivityStep` keeps a delegate row's icon even when bare, and keeps a
+ * failed row's outcome mark. See the `hideIcon` note there.
+ *
+ * No rows, no burst. `mergeBurstSteps` drops plumbing outright (memory writes,
+ * context compaction) and skips blank reasoning fragments, so a run made only
+ * of those merges to nothing — and the burst used to draw a summary line
+ * ("Housekeeping", or "Worked" with no plumbing) over an empty chain. A
+ * disclosure the reader can open onto nothing is worse than silence: it
+ * advertises work it cannot show, and the caret promises a body that is not
+ * there.
+ *
+ * The test is `steps`, not `blocks`: `blocks.length > 0` is exactly the case
+ * that produced the empty row, because every one of those blocks was filtered
+ * out downstream. `steps` IS the list the chain below maps over, so this
+ * cannot drift from what renders.
+ */
+declare function ActivityBurstImpl({ blocks, sessionId, working, isTrailing, disableNavigation, density, }: {
+    /** The burst segment's blocks (`sessionLogTurnSegments`). The rows are
+     *  `sessionLogBurstSteps`; whether the burst is still in progress is
+     *  `sessionLogBurstRunning` (the trailing burst stays open for the whole
+     *  working turn, so a gap between two calls does not blink it shut). */
+    blocks: SessionLogBlock[];
+    sessionId: string;
+    working: boolean;
+    /** Last segment in the turn — stay open across SSE gaps between tool calls. */
+    isTrailing?: boolean;
+    disableNavigation?: boolean;
+    /**
+     * User preference (`conversationDensity` in the user-preferences store),
+     * passed in by the chat surface rather than read here so this component
+     * stays pure and testable under `renderToStaticMarkup`.
+     *
+     * 'normal' — the burst opens itself while it runs: steps and streaming
+     * thinking appear live. 'minimal' — the live view is the one-line summary
+     * ("Working · N steps"); nothing auto-expands, including the thought rows
+     * a bare burst pins open. A finished turn renders identically in both
+     * modes (both auto-collapse to one row), and a click always wins.
+     */
+    density?: ConversationDensity;
+}): import("react").JSX.Element | null;
+export declare const ActivityBurst: import("react").MemoExoticComponent<typeof ActivityBurstImpl>;

package/dist/session/turn/activity-burst.js

@@ -0,0 +1,117 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * One burst — a maximal run of non-text blocks.
+ *
+ * Renders as a chain of thought: a muted summary line ("Completed 7 steps")
+ * that expands into a connected vertical chain. The chain has two levels — a
+ * run of consecutive same-family calls is ONE step that opens to its members,
+ * so the expansion groups the work the same way the summary line counts it.
+ *
+ * A burst holding exactly ONE call has no summary line at all. It renders as
+ * that call and nothing else: no title, no chain rail, no closing step, and no
+ * leading glyph on the row (see `bare` below). "Completed 1 step" over a single
+ * row is a door in front of a door.
+ *
+ * The trailing burst stays open for the whole working turn (so SSE gaps between
+ * tool calls do not blink it shut); earlier bursts auto-collapse once later
+ * text/standalone closes them. Manual after the user's first click. Collapsed
+ * height is always one row.
+ */
+import { ChainOfThought, ChainOfThoughtStep } from '../../primitives/chain-of-thought.js';
+import { Disclosure, DisclosureContent } from '../../primitives/disclosure.js';
+import { ToolActivateContext } from '../tool/shared/infrastructure.js';
+import { sessionLogBurstRunning, sessionLogBurstSteps, sessionLogBurstSummary, sessionLogBurstWorkLabel, } from '@kortix/sdk';
+import { memo, useContext, useEffect, useMemo, useRef, useState } from 'react';
+import { StepBody } from './burst-step-body.js';
+import { burstSummaryLabel } from '@kortix/sdk';
+import { BurstSummaryTrigger } from './burst-summary-trigger.js';
+import { samePartsList } from './same-parts.js';
+import { ThoughtChainStep } from './thought-chain-step.js';
+import { WorkFoldContext } from './turn-work-accordion.js';
+export { ActivityGroupStep, sameActivityGroupStepProps } from './activity-group-step.js';
+/**
+ * A burst of ONE call has nothing to summarise, so it drops the summary line
+ * and IS its row.
+ *
+ * "Completed 1 step" is a door in front of a door: the reader clicks a line
+ * that names no tool, no file and no command, to reveal the one row that names
+ * all three — and that row already opens on its own. Two clicks and a
+ * content-free label to reach what a single row was always going to say.
+ *
+ * `summary.total === 1` is what makes this safe, not `steps.length === 1`
+ * alone: a group row is ONE row over N calls, and "Completed 3 steps" is
+ * information the bare row does not carry.
+ *
+ * A lone thought qualifies too, now that `ThoughtChainStep` gives reasoning a
+ * label and a caret of its own. It did not while the thought was unlabelled
+ * prose: unwrapping THAT would have pinned the model's reasoning open with
+ * nothing left to close it.
+ *
+ * `bare` drops the summary line, and with it the row's leading glyph. It
+ * does not, on its own, decide that a row has no thread — a lone sub-agent is
+ * one row here and a whole nested list of steps one level down, so
+ * `ActivityStep` keeps a delegate row's icon even when bare, and keeps a
+ * failed row's outcome mark. See the `hideIcon` note there.
+ *
+ * No rows, no burst. `mergeBurstSteps` drops plumbing outright (memory writes,
+ * context compaction) and skips blank reasoning fragments, so a run made only
+ * of those merges to nothing — and the burst used to draw a summary line
+ * ("Housekeeping", or "Worked" with no plumbing) over an empty chain. A
+ * disclosure the reader can open onto nothing is worse than silence: it
+ * advertises work it cannot show, and the caret promises a body that is not
+ * there.
+ *
+ * The test is `steps`, not `blocks`: `blocks.length > 0` is exactly the case
+ * that produced the empty row, because every one of those blocks was filtered
+ * out downstream. `steps` IS the list the chain below maps over, so this
+ * cannot drift from what renders.
+ */
+function ActivityBurstImpl({ blocks, sessionId, working, isTrailing = false, disableNavigation, density = 'normal', }) {
+    const running = sessionLogBurstRunning(blocks, { working, trailing: isTrailing });
+    const autoExpand = density !== 'minimal';
+    const [open, setOpen] = useState(autoExpand && running);
+    const userToggled = useRef(false);
+    // Auto-collapse the moment the burst settles — unless the user has taken
+    // control, in which case their choice wins permanently. Under minimal
+    // density the burst never opens itself in the first place.
+    useEffect(() => {
+        if (userToggled.current)
+            return;
+        setOpen(autoExpand && running);
+    }, [running, autoExpand]);
+    const steps = useMemo(() => sessionLogBurstSteps(blocks), [blocks]);
+    const summary = useMemo(() => sessionLogBurstSummary(blocks), [blocks]);
+    // Under an opened "Worked for" row the burst sits between two sentences of
+    // the agent's narration, so its closed line names the work ("Ran 9 commands,
+    // updated 2 files · 1 failed") instead of counting steps. Thoughts and the
+    // per-call rows stay one click down. Elsewhere the summary goes through
+    // unchanged: `burstSummaryLabel` already ignores failures while running.
+    const inFold = useContext(WorkFoldContext);
+    const title = useMemo(() => (inFold ? sessionLogBurstWorkLabel(blocks) : burstSummaryLabel(summary, running)), [inFold, blocks, summary, running]);
+    const bare = steps.length === 1 && summary.total === 1;
+    if (steps.length === 0)
+        return null;
+    return (_jsxs(Disclosure
+    // Bare is permanently open — there is no trigger to close it with.
+    , { 
+        // Bare is permanently open — there is no trigger to close it with.
+        open: bare || open, onOpenChange: (next) => {
+            userToggled.current = true;
+            setOpen(next);
+        }, className: "group/burst flex-row", children: [_jsx(BurstSummaryTrigger, { bare: bare, running: running, title: title }), _jsx(DisclosureContent, { children: _jsx(ToolActivateContext.Provider, { value: null, children: _jsx("div", { className: bare ? undefined : 'mt-3', children: _jsx(ChainOfThought, { children: steps.map((step) => step.kind === 'thought' ? (
+                            /* `step.running`, not the burst's — a trailing burst reports
+                               running for the whole turn by design, so passing that flag
+                               down made every thought the turn ever emitted shimmer and
+                               force its paragraph open. Still gated on the burst: once
+                               the turn stops working, nothing in it is live, whatever a
+                               part's timestamps say. */
+                            _jsx(ThoughtChainStep, { texts: step.texts, running: running && step.running, durationMs: step.durationMs, bare: bare, autoOpen: autoExpand }, step.key)) : (_jsx(ChainOfThoughtStep, { children: _jsx(StepBody, { step: step, bareRow: bare, running: running, sessionId: sessionId, disableNavigation: disableNavigation }) }, step.key))) }) }) }) })] }));
+}
+export const ActivityBurst = memo(ActivityBurstImpl, (a, b) => a.sessionId === b.sessionId &&
+    a.working === b.working &&
+    a.isTrailing === b.isTrailing &&
+    a.disableNavigation === b.disableNavigation &&
+    a.density === b.density &&
+    samePartsList(a.blocks, b.blocks));
+ActivityBurst.displayName = 'ActivityBurst';

package/dist/session/turn/activity-file-chips.d.ts

@@ -0,0 +1,44 @@
+import type { ToolCallBlock } from '@kortix/sdk';
+/**
+ * True when this call is a whole-file read or write, i.e. eligible for a chip.
+ *
+ * `normalizeActivityToolName` is the same door `activity-step.tsx` and
+ * `step-label.ts` go through, so an MCP id, an `oc-` alias and the bare name all
+ * resolve to the one family here too.
+ */
+export declare function isFileChipCall(call: ToolCallBlock): boolean;
+/**
+ * A run of file calls: one summary row that opens to the files themselves.
+ *
+ * `mergeBurstSteps` unwraps a run of one into a flat `part` row, which is right
+ * for a shell command and wrong here — the point of this row is that a read is a
+ * FILE, and one file is still a file. So the decision to draw chips is made at
+ * render time in `ActivityBurst` rather than in the merge, and this component
+ * accepts one part as happily as nine. `mergeBurstSteps` stays pure.
+ *
+ * The trigger is a copy of `ActivityGroupStep`'s, not a shared component: the
+ * two rows are four lines of JSX apart and they differ in exactly one place —
+ * the body. Extracting the 90% that matches would hide the 10% that is the whole
+ * reason this file exists.
+ *
+ * The count in the label is the count of things below it. Not the number of
+ * parts: a file read twice is one chip, so a label counting parts would promise
+ * two files and open to one. `burstSummary` and `mergeBurstSteps` share this
+ * discipline — every reader of a burst agrees on what is in it, or a reader goes
+ * hunting for a row that was never rendered.
+ *
+ * Failed calls are not chips. A file that could not be read has nothing to
+ * preview, and a chip that opens an empty panel is worse than no chip. They fall
+ * through to ordinary `ActivityStep` rows under the chips, so the error card is
+ * still one click away.
+ */
+declare function ActivityFileChipStepImpl({ calls, sessionId, disableNavigation, bare, }: {
+    calls: ReadonlyArray<ToolCallBlock>;
+    sessionId: string;
+    disableNavigation?: boolean;
+    /** This row is the WHOLE burst — see `ActivityBurst`. */
+    bare?: boolean;
+}): import("react").JSX.Element | null;
+/** `calls` is a fresh array per merge while a turn streams — see `same-parts.ts`. */
+export declare const ActivityFileChipStep: import("react").MemoExoticComponent<typeof ActivityFileChipStepImpl>;
+export {};

package/dist/session/turn/activity-file-chips.js

@@ -0,0 +1,238 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useTranslations } from '../../i18n/index.js';
+/**
+ * A run of reads or writes rendered as FILES rather than as tool cards.
+ *
+ * A `read` row today is a `BasicTool` disclosure that opens a code viewer inside
+ * the chat column — a tool reporting on itself. But the user already has a
+ * first-class file surface on this very screen: the attachment tile on their own
+ * message, which opens the file in the right-hand detail panel. A file the agent
+ * opened and a file the user attached are the same object, so they get the same
+ * shape and the same click. That is the whole idea of this module.
+ *
+ * `edit` / `apply_patch` are deliberately NOT here. Their renderer shows a diff,
+ * which is the right output for a change; this is a rule about whole files the
+ * agent opened or produced, not about edits.
+ */
+import { WarningIcon } from '@phosphor-icons/react';
+import { DisclosureContent } from '../../primitives/disclosure.js';
+import { STATUS_TEXT } from '../../primitives/status.js';
+import { TextShimmer } from '../../primitives/text-shimmer.js';
+import { partOutcome, partOutput, partStreamingInput, } from '../tool/shared/infrastructure.js';
+import { parseReadOutput } from '@kortix/sdk';
+import { useOcFileOpen } from '../../internal/files/use-oc-file-open.js';
+import { cn } from '../../lib/utils.js';
+import { fileIconFor, getFilename, getFileType, getTypeLabel } from '../../internal/lib/utils/file-utils.js';
+import { useFilePreviewStore } from '../../internal/stores/file-preview-store.js';
+import { memo } from 'react';
+import { normalizeActivityToolName } from '@kortix/sdk';
+import { ChainStepTrigger } from './chain-step-trigger.js';
+import { ActivityStep, iconFor } from './activity-step.js';
+import { samePartsList } from './same-parts.js';
+const FILE_CHIP_TOOLS = new Map([
+    ['read', { verb: 'Read', running: 'Reading' }],
+    ['write', { verb: 'Wrote', running: 'Writing' }],
+]);
+/** Input keys a file tool may carry its path under, in resolution order. */
+const PATH_KEYS = ['filePath', 'path', 'file'];
+/**
+ * True when this call is a whole-file read or write, i.e. eligible for a chip.
+ *
+ * `normalizeActivityToolName` is the same door `activity-step.tsx` and
+ * `step-label.ts` go through, so an MCP id, an `oc-` alias and the bare name all
+ * resolve to the one family here too.
+ */
+export function isFileChipCall(call) {
+    return FILE_CHIP_TOOLS.has(normalizeActivityToolName(call.name));
+}
+/**
+ * The path this call touched, or undefined while the input is still arriving.
+ *
+ * Reads through `partStreamingInput` for the same reason `read-tool.tsx` does: a
+ * call mid-stream has its arguments in `state.raw` and nothing in `state.input`,
+ * so reading `input` alone leaves a chip pathless for the whole time it is most
+ * interesting.
+ */
+function chipPath(call) {
+    const input = partStreamingInput(call);
+    for (const key of PATH_KEYS) {
+        const value = input[key];
+        if (typeof value === 'string' && value.trim())
+            return value.trim();
+    }
+    return undefined;
+}
+/**
+ * True when this call resolved to a DIRECTORY rather than to a whole file.
+ *
+ * `read` legitimately lists a directory: `parseReadOutput` returns
+ * `type: 'directory'` and `read-tool.tsx` renders the entry list. A chip would
+ * divert that listing into a file preview aimed at a folder — and, with a
+ * trailing slash, `getFilename` degrades to the literal string "file", so the
+ * chip would be labelled `file` / `File`. A directory falls through to its own
+ * renderer instead. The slash clause carries the same call while its output is
+ * still arriving, when `partOutput` is empty by construction.
+ */
+function isDirectoryTarget(call, path) {
+    if (path.endsWith('/'))
+        return true;
+    return parseReadOutput(partOutput(call))?.type === 'directory';
+}
+function isInFlight(call) {
+    return call.status === 'pending' || call.status === 'running';
+}
+/**
+ * One file: icon plate, name, type.
+ *
+ * Horizontal rather than the user-message square tile because these sit in a
+ * text column under a label, not in a right-aligned block — a row of squares
+ * would read as a second gallery hanging off the chain. The name gets the whole
+ * first line at `text-sm font-medium`, which is the point: filenames are what
+ * distinguishes one of these from the next, and the square tile has to clamp
+ * them to two cramped lines to fit.
+ *
+ * Hover / press / transition are `ATTACHMENT_INTERACTIVE`'s three parts, matched
+ * value for value (`user-message.tsx`) so the agent's files answer the pointer
+ * exactly like the user's do — including the 0.97 press, because two press
+ * depths on one screen is what that shared constant exists to prevent.
+ *
+ * The icon plate carries no border and no `rounded-md`. The chip is already a
+ * rounded, bordered box and the plate sits 8px inside it, so a second hairline
+ * at the same radius is the nested rounding the design system bans outright,
+ * and it reads as a one-off card rather than as an attachment. Tint alone draws
+ * it, at the design system's `rounded-sm` plate / `size-9` box / `size-5` glyph
+ * proportions. The tint is `bg-muted` at full strength and not `bg-muted/50`
+ * because the chip's own hover IS `bg-muted/50` — a plate at that value would
+ * disappear under the pointer.
+ */
+function FileChipImpl({ path, onOpen }) {
+    const tI18nComplete = useTranslations('hardcodedUi.i18nComplete');
+    const filename = getFilename(path);
+    const type = getFileType(filename);
+    // The glyph for THIS file, not for its category — a .ts, a .png and a .zip
+    // used to share one anonymous mark.
+    const Icon = fileIconFor(filename);
+    // `getFileType` enumerates twelve groups, so `.yml`, `.sh`, `.go`, `.rs`,
+    // `.toml` and most of a real repo collapse to the literal word "File" — a
+    // second line that costs 16px and says nothing. The extension itself is the
+    // information; "File" survives only for a name that genuinely has none.
+    const ext = filename.includes('.') ? filename.split('.').pop() : undefined;
+    const typeLabel = getTypeLabel(type, ext, tI18nComplete);
+    return (_jsx("li", { children: _jsxs("button", { type: "button", title: path, "aria-label": `Open ${filename}`, onClick: () => onOpen(path), className: cn(
+            // No shadow: this chip sits in the transcript flow, and in-flow
+            // surfaces in this system are flat with a border.
+            'border-border bg-background hover:bg-muted/50 focus-visible:ring-ring/50 flex max-w-full cursor-pointer items-center gap-3 rounded-md border p-1.5 py-1 pr-3 transition-[color,background-color,border-color,scale] focus-visible:ring-2 focus-visible:outline-none active:scale-[0.97]'), children: [_jsx("span", { className: "bg-muted flex size-9 flex-none items-center justify-center rounded-sm", children: _jsx(Icon, { className: "text-muted-foreground size-5" }) }), _jsxs("span", { className: "flex min-w-0 flex-col text-left", children: [_jsx("span", { className: "text-foreground truncate text-sm font-medium", children: filename }), _jsx("span", { className: "text-muted-foreground truncate text-xs", children: typeLabel === 'File' && ext ? ext.toUpperCase() : typeLabel })] })] }) }));
+}
+/**
+ * A run of file calls: one summary row that opens to the files themselves.
+ *
+ * `mergeBurstSteps` unwraps a run of one into a flat `part` row, which is right
+ * for a shell command and wrong here — the point of this row is that a read is a
+ * FILE, and one file is still a file. So the decision to draw chips is made at
+ * render time in `ActivityBurst` rather than in the merge, and this component
+ * accepts one part as happily as nine. `mergeBurstSteps` stays pure.
+ *
+ * The trigger is a copy of `ActivityGroupStep`'s, not a shared component: the
+ * two rows are four lines of JSX apart and they differ in exactly one place —
+ * the body. Extracting the 90% that matches would hide the 10% that is the whole
+ * reason this file exists.
+ *
+ * The count in the label is the count of things below it. Not the number of
+ * parts: a file read twice is one chip, so a label counting parts would promise
+ * two files and open to one. `burstSummary` and `mergeBurstSteps` share this
+ * discipline — every reader of a burst agrees on what is in it, or a reader goes
+ * hunting for a row that was never rendered.
+ *
+ * Failed calls are not chips. A file that could not be read has nothing to
+ * preview, and a chip that opens an empty panel is worse than no chip. They fall
+ * through to ordinary `ActivityStep` rows under the chips, so the error card is
+ * still one click away.
+ */
+function ActivityFileChipStepImpl({ calls, sessionId, disableNavigation, bare, }) {
+    const tI18nComplete = useTranslations('hardcodedUi.i18nComplete');
+    const openPreview = useFilePreviewStore((s) => s.openPreview);
+    // Called before every early return below — hook order is not negotiable.
+    // This is the same door `read-tool.tsx` uses, and it reads the SHARED query
+    // cache rather than issuing its own request; a chip row also replaces the N
+    // read rows that each paid for this hook individually.
+    const { toDisplayPath } = useOcFileOpen();
+    const first = calls[0];
+    const family = first ? FILE_CHIP_TOOLS.get(normalizeActivityToolName(first.name)) : undefined;
+    const paths = [];
+    const seenPaths = new Set();
+    const fallbacks = [];
+    let failedCount = 0;
+    let inFlight = false;
+    for (const call of calls) {
+        if (isInFlight(call))
+            inFlight = true;
+        // Read the verdict with the same predicate `burstFailureCount` uses, so a
+        // call that RETURNED its error ("Error: ENOENT", the `{success:false}`
+        // contract) is a failure here too — `state.status === 'error'` alone would
+        // hand a chip to a read that never opened anything.
+        if (partOutcome(call) !== 'ok') {
+            failedCount += 1;
+            fallbacks.push(call);
+            continue;
+        }
+        const path = chipPath(call);
+        if (!path || isDirectoryTarget(call, path)) {
+            fallbacks.push(call);
+            continue;
+        }
+        if (!seenPaths.has(path)) {
+            seenPaths.add(path);
+            paths.push(path);
+        }
+    }
+    if (!family)
+        return null;
+    /**
+     * A bare row with no chips is a door onto nothing.
+     *
+     * The single call failed, or read a directory, or has no path yet — so it
+     * produced no chip, and "Read 1 file" would open to the one tool row already
+     * sitting behind it. Two clicks, two labels, one call. Drop the row and let
+     * the tool render itself, which is exactly what a bare single `bash` does.
+     */
+    if (bare && paths.length === 0) {
+        return (_jsx(_Fragment, { children: fallbacks.map((call) => (_jsx(ActivityStep, { call: call, sessionId: sessionId, disableNavigation: disableNavigation }, call.id))) }));
+    }
+    // Running wins over error, the same precedence `groupSteps.statusOf` applies:
+    // a run with one dead call and one still in flight has not finished failing.
+    const status = inFlight ? 'running' : failedCount > 0 ? 'error' : 'done';
+    const count = paths.length + fallbacks.length;
+    // The verdict goes in the WORDS as well as the glyph. `Wrote 2 files` over a
+    // run where one write died is the row claiming both landed — the exact lie
+    // `group-steps.ts` forbids by routing a failed group through
+    // `narrateFailedStep`. The clause is the collapsed title's, character for
+    // character (`burst-summary.ts`): lower-case, factual, no adjective, so one
+    // burst speaks with one vocabulary. Suppressed while running for the same
+    // reason the title suppresses it — a count mid-flight is a snapshot the next
+    // frame contradicts.
+    // ONE file names itself. "Read 1 file" spends a whole row saying "one" when
+    // the row could say WHICH — and the reader then has to open it to find out.
+    // Only when the run is a clean single chip: a fallback in the run means the
+    // path on the label would not be the path that failed.
+    const object = count === 1 && paths.length === 1
+        ? toDisplayPath(paths[0])
+        : `${count} ${count === 1 ? 'file' : 'files'}`;
+    const label = `${status === 'running' ? family.running : family.verb} ${object}` +
+        (status === 'error' ? ` · ${failedCount} failed` : '');
+    const Icon = iconFor(calls[0]);
+    return (_jsxs(_Fragment, { children: [_jsx(ChainStepTrigger, { status: status, icon: status === 'error' ? (_jsxs(_Fragment, { children: [_jsx(WarningIcon, { weight: "fill", "aria-label": tI18nComplete.raw('textf0103f528539'), className: cn('size-4 flex-none group-data-[state=open]/step:hidden', STATUS_TEXT.destructive) }), _jsx(Icon, { className: "text-muted-foreground hidden size-4 flex-none group-data-[state=open]/step:block" })] })) : (_jsx(Icon, { className: "text-muted-foreground size-4 flex-none" })), label: status === 'running' ? (_jsx(TextShimmer, { className: "min-w-0 truncate leading-[1.5] font-medium", children: label })) : (_jsx("span", { className: "min-w-0 truncate font-medium", children: label })) }), _jsx(DisclosureContent, { children: _jsxs("div", { className: "mt-3 space-y-3 pl-7", children: [paths.length > 0 && (_jsx("ul", { className: "flex flex-wrap gap-2", children: paths.map((path) => (_jsx(FileChip, { path: path, onOpen: openPreview }, path))) })), fallbacks.length > 0 && (_jsx("div", { className: "space-y-3", children: fallbacks.map((call) => (_jsx(ActivityStep, { call: call, sessionId: sessionId, disableNavigation: disableNavigation }, call.id))) }))] }) })] }));
+}
+/**
+ * A chip is a path and a click. Both are stable — `openPreview` is a zustand
+ * action, which zustand guarantees is the same function for the store's life —
+ * so a settled chip never re-renders, however often the burst above it does.
+ */
+const FileChip = memo(FileChipImpl);
+FileChip.displayName = 'FileChip';
+/** `calls` is a fresh array per merge while a turn streams — see `same-parts.ts`. */
+export const ActivityFileChipStep = memo(ActivityFileChipStepImpl, (a, b) => a.sessionId === b.sessionId &&
+    a.bare === b.bare &&
+    a.disableNavigation === b.disableNavigation &&
+    samePartsList(a.calls, b.calls));
+ActivityFileChipStep.displayName = 'ActivityFileChipStep';