@kortix/ui 0.0.0-stage → 0.14.4

package/dist/session/thread/message-parsing.js

@@ -0,0 +1,244 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { isSessionAttachmentRef } from '@kortix/sdk';
+import { fileTagBlocks, referenceHeaders, removeSpans, replaceSpans, selfClosingTags, xmlBlocks, } from '../../_vendor/kortix-shared.js';
+import { Disclosure, DisclosureContent, DisclosureTrigger } from '../../primitives/disclosure.js';
+import { SystemMessage } from '../../primitives/system-message.js';
+import { stripKortixSystemTags } from '../../internal/lib/utils/kortix-system-tags.js';
+// Attributes are read by NAME, not by position, so an optional `attachment` can be
+// appended without the tag becoming unparseable.
+//
+// Every parser in this file finds its tags with a scanner from
+// `@kortix/shared/tag-blocks`, never a regex. The lazy regexes they replaced
+// re-scanned the rest of the message for each tag that never closed: a
+// 240k-character message took 1–22 s per parser, and in a shared session one
+// member's message froze the tab of every member who opened it.
+function replaceFileTags(text, replace) {
+    return replaceSpans(text, fileTagBlocks(text), (block) => replace(text.slice(block.index, block.end), block.attrs));
+}
+export function parseFileReferences(text) {
+    const files = [];
+    const cleanText = replaceFileTags(text, (whole, attrs) => {
+        const pick = (key) => {
+            const m = attrs.match(new RegExp(`\\b${key}="([^"]*?)"`));
+            // Every attribute is unescaped on the way out. `xmlAttr` escapes `&`,
+            // `"`, `<` and `>` on the way in, and this side used to push the RAW
+            // attribute back — so `R&D report.pdf` reached the transcript, and the
+            // model, as the literal `R&amp;D report.pdf`.
+            return m ? unescapeAttr(m[1]) : undefined;
+        };
+        const path = pick('path');
+        const filename = pick('filename');
+        // A tag carrying neither is not a file reference; leave it in the text
+        // rather than silently swallowing it.
+        if (path === undefined && filename === undefined)
+            return whole;
+        const attachment = pick('attachment');
+        files.push({
+            path: path ?? '',
+            mime: pick('mime') ?? '',
+            filename: filename ?? '',
+            ...(attachment && (isSessionAttachmentRef(attachment) || /^[A-Za-z0-9_-]+$/.test(attachment)) ? { attachment } : {}),
+        });
+        return '';
+    }).trim();
+    return { cleanText, files };
+}
+/** The parenthesised text of the `Referenced sessions (…):` header. */
+const SESSION_REFERENCE_HINT = 'use the session_context tool to fetch details when needed';
+export function parseSessionReferences(text) {
+    const sessions = [];
+    let cleaned = text.replace(/<session_ref\s+id="([^"]*?)"\s+title="([^"]*?)"\s*\/>/g, (_, id, title) => {
+        // `buildSessionRef` escapes both attributes; undo it here.
+        sessions.push({ id: unescapeAttr(id), title: unescapeAttr(title) });
+        return '';
+    });
+    // Strip the instruction header text
+    cleaned = removeSpans(cleaned, referenceHeaders(cleaned, 'sessions', SESSION_REFERENCE_HINT)).trim();
+    return { cleanText: cleaned, sessions };
+}
+/**
+ * The exact inverse of `xmlAttr` in `uploaded-file-refs.ts`.
+ *
+ * `&amp;` is undone LAST, so an escaped `&lt;` (written `&amp;lt;`) comes back
+ * as the literal `&lt;` rather than being unescaped twice into `<`.
+ */
+function unescapeAttr(v) {
+    return v
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&amp;/g, '&');
+}
+export function parseProjectReferences(text) {
+    // Historical messages may contain <project_ref/> blocks. Projects are no
+    // longer a user-facing/runtime concept, so strip the metadata without
+    // rendering project chips or passing project refs forward.
+    let cleaned = removeSpans(text, selfClosingTags(text, 'project_ref'));
+    // Strip the instruction header. Its description ends at the first `)`, which
+    // is safe because the header never contains a literal `)` before its closing one.
+    cleaned = removeSpans(cleaned, referenceHeaders(cleaned, 'projects')).trim();
+    return { cleanText: cleaned, projects: [] };
+}
+export function parseFileMentionReferences(text) {
+    const files = [];
+    let cleaned = replaceSpans(text, selfClosingTags(text, 'file_ref'), ({ attrs }) => {
+        const pick = (key) => {
+            const m = attrs.match(new RegExp(`${key}="([^"]*?)"`));
+            return m ? unescapeAttr(m[1]) : undefined;
+        };
+        const path = pick('path');
+        const name = pick('name') ?? path;
+        if (path)
+            files.push({ path, name: name || path });
+        return '';
+    });
+    cleaned = removeSpans(cleaned, referenceHeaders(cleaned, 'files')).trim();
+    return { cleanText: cleaned, files };
+}
+export function parseAgentMentionReferences(text) {
+    const agents = [];
+    let cleaned = replaceSpans(text, selfClosingTags(text, 'agent_ref'), ({ attrs }) => {
+        const pick = (key) => {
+            const m = attrs.match(new RegExp(`${key}="([^"]*?)"`));
+            return m ? unescapeAttr(m[1]) : undefined;
+        };
+        const name = pick('name');
+        if (name)
+            agents.push({ name });
+        return '';
+    });
+    cleaned = removeSpans(cleaned, referenceHeaders(cleaned, 'agents')).trim();
+    return { cleanText: cleaned, agents };
+}
+// ============================================================================
+// Parse <reply_context> XML from select-and-reply feature
+// ============================================================================
+// The functions live in `reply-context.ts` (React-free, so the composer
+// editor can import them directly); re-exported here for existing importers.
+export { parseReplyContexts, QUOTE_MARKER_RE, quoteMarker, serializeReplyContext, splitAtQuoteMarkers, stripReplyContexts, } from './reply-context.js';
+// ============================================================================
+// Parse <trigger_event> JSON from the prompt of a trigger-started session
+// ============================================================================
+// One copy for web and mobile: `@kortix/shared/trigger-event`.
+export { parseTriggerEvent } from '../../_vendor/kortix-shared.js';
+// The reminder fire header, also shared with the API that writes it.
+export { parseReminderPrompt } from '../../_vendor/kortix-shared.js';
+export { parseRoomDigest, parseRoomPrompt } from '../../_vendor/kortix-shared.js';
+/** Parse all remaining XML blocks from text as system notifications. */
+export function parseSystemNotifications(text) {
+    const notifications = [];
+    // A `<pasted_content>` block is the user's own paste, never a notification.
+    // One the tile parser did not claim (`splitPastedContent`) stays text.
+    const blocks = xmlBlocks(text).filter((block) => block.tag.toLowerCase() !== 'pasted_content');
+    const cleanText = replaceSpans(text, blocks, ({ tag, body: rawBody }) => {
+        const fields = [];
+        const bodyLines = [];
+        let pastHeader = false;
+        for (const line of rawBody.trim().split('\n')) {
+            if (pastHeader) {
+                bodyLines.push(line);
+                continue;
+            }
+            if (line.trim() === '') {
+                pastHeader = true;
+                continue;
+            }
+            const field = headerField(line);
+            if (field) {
+                fields.push(field);
+            }
+            else {
+                pastHeader = true;
+                bodyLines.push(line);
+            }
+        }
+        notifications.push({
+            tag: tag.toLowerCase(),
+            label: tag.replace(/[-_]/g, ' ').replace(/^\w/, (c) => c.toUpperCase()),
+            fields,
+            body: bodyLines.join('\n').trim(),
+        });
+        return '';
+    })
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+    return { cleanText, notifications };
+}
+/** The characters `.` does not match in a regex without the `s` flag. */
+const LINE_TERMINATORS = ['\n', '\r', '\u2028', '\u2029'];
+/**
+ * A `Key: value` header line as `[key, value]`, both trimmed — what
+ * `/^([A-Za-z][\w\s]*?):\s*(.+)$/` read from it, or null where it did not match.
+ * That regex was quadratic: once a `\r` stopped `(.+)` short of the end, `\s*`
+ * and `(.+)` tried every split of the whitespace before it.
+ */
+function headerField(line) {
+    const colon = line.indexOf(':');
+    if (colon < 1 || !/^[A-Za-z][\w\s]*$/.test(line.slice(0, colon)))
+        return null;
+    const rest = line.slice(colon + 1);
+    // `(.+)$` cannot cross a line terminator, so `\s*` must cover everything up to the last one.
+    const lastBreak = Math.max(...LINE_TERMINATORS.map((terminator) => rest.lastIndexOf(terminator)));
+    if (lastBreak !== -1 && rest.slice(0, lastBreak + 1).trim() !== '')
+        return null;
+    const value = rest.slice(lastBreak + 1);
+    if (value === '')
+        return null;
+    return [line.slice(0, colon).trim(), value.trim()];
+}
+export function stripSystemPtyText(text) {
+    if (!text)
+        return '';
+    // Only strip kortix_system tags (backend-internal metadata).
+    // Notification XML is stripped later by parseSystemNotifications()
+    // which runs last in the parsing pipeline.
+    return stripKortixSystemTags(text)
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+}
+/**
+ * The session could not continue, or something was lost. Red is spent here and
+ * nowhere else — a recovered retry is not an error, and if routine failures go
+ * red then red stops meaning anything by the time it matters.
+ */
+const CRITICAL = /\b(aborted|corrupted?|crashed|denied|error|errored|exceeded|exhausted|expired|failed|failure|fatal|forbidden|lost|missing|rejected|revoked|timed out|timeout|unauthorized|unavailable|unreachable)\b/;
+/** Still running but degraded, or stopped and waiting on the person reading it. */
+const NEEDS_ATTENTION = /\b(blocked|blocker|degraded|deprecated|limit|limited|needs|partial|paused|requires|retried|retry|retrying|skipped|stopped|throttled|waiting)\b/;
+/**
+ * Which tone a notification tag earns.
+ *
+ * The parser accepts any XML block the other subsystems did not claim, so there
+ * is no fixed vocabulary to map — the tag is the only signal the emitter gives
+ * us. Keywords match on word boundaries against the spaced-out tag
+ * ("quota_exceeded" -> "quota exceeded"), so "exceeded" hits and "proceeded"
+ * does not. Anything unrecognised stays neutral on purpose: a tag nobody
+ * classified should read as quiet, never as alarming.
+ */
+export function systemNotificationSeverity(tag) {
+    const words = tag.replace(/[-_]/g, ' ');
+    if (CRITICAL.test(words))
+        return 'error';
+    if (NEEDS_ATTENTION.test(words))
+        return 'warning';
+    return 'action';
+}
+/**
+ * One quiet line in the chat stream telling the reader what the session just
+ * did. Deliberately not an inspector: no expander, no field table, no stack
+ * trace. Tone carries the severity, the sentence carries the rest.
+ */
+export function SystemNotificationCard({ notification }) {
+    // One detail, and the friendliest one: identifiers and codes ("daytona",
+    // "1.2s", "us-east-1") have no spaces, so the longest value that does is the
+    // closest thing to a sentence the tag gave us. Overflow is a truncated line,
+    // never a second row.
+    let detail;
+    for (const [, value] of notification.fields) {
+        if (value.includes(' ') && (!detail || value.length > detail.length)) {
+            detail = value;
+        }
+    }
+    return (_jsxs(Disclosure, { variant: "outline", className: "bg-secondary", children: [_jsx(DisclosureTrigger, { children: _jsx(SystemMessage, { variant: systemNotificationSeverity(notification.tag), fill: true, children: _jsxs("span", { className: "block truncate", children: [notification.label, detail && _jsx("span", { className: "ml-1.5 opacity-70", children: detail })] }) }) }), _jsx(DisclosureContent, { children: _jsxs("div", { className: "space-y-1 px-3 pb-2 text-xs", children: [notification.fields.length > 0 && (_jsx("div", { className: "space-y-0.5", children: notification.fields.map(([key, value]) => (_jsxs("div", { className: "flex min-w-0 gap-2", children: [_jsxs("span", { className: "text-muted-foreground shrink-0", children: [key, ":"] }), _jsx("span", { className: "text-foreground font-mono text-xs break-all", children: value })] }, `${key}:${value}`))) })), notification.body && (_jsx("div", { className: "text-muted-foreground/50 max-h-48 overflow-y-auto font-mono text-xs break-all whitespace-pre-wrap", children: notification.body.slice(0, 2000) }))] }) })] }));
+}

package/dist/session/thread/optimistic-turn.d.ts

@@ -0,0 +1,89 @@
+import { type ReactNode } from 'react';
+import type { SentAttachment } from '../composer/sent-attachment-previews.js';
+import { type AttachmentUploadStatus } from '../turn/user-message.js';
+/**
+ * The optimistic turn — the user's message plus the assistant's waiting row,
+ * rendered the instant a message is sent and before any server turn exists.
+ *
+ * ONE component, deliberately: this exact turn is painted twice in a fresh
+ * session's life — first by {@link InstantSessionShell} while the computer boots,
+ * then again by {@link SessionChat} once the runtime is healthy — and the two
+ * crossfade into each other. Both surfaces used to hand-roll their own copy held
+ * together by a comment asking future authors to keep them identical. They had
+ * already drifted (different vertical padding, raw prompt text vs. parsed, a
+ * logomark on one side only), and every drift showed up as the thread twitching
+ * mid-handover. Sharing the render makes the contract structural instead of
+ * aspirational: there is nothing left to keep in sync.
+ *
+ * The waiting row is {@link SessionBusyIndicator} — the SAME component a live
+ * turn shows while working. So the whole arc (boot → runtime ready → first real
+ * turn) is one row that never unmounts its shape: only its label changes, and
+ * that change is already blur-bridged. No logomark that appears and then
+ * vanishes when the real turn lands, no boot checklist, no rotating filler
+ * copy — just "Thinking" until the agent has something truer to say.
+ */
+export declare function OptimisticTurn({ 
+/** The prompt text, already carrying any upload refs
+ *  (see `buildOptimisticPromptTextWithUploads`). */
+text, 
+/** Known agent names, so `@agent` mentions render as agent chips. */
+agentNames, 
+/** Opens a file mention. Omitted before a runtime exists — mentions then
+ *  render as static chips rather than dead buttons. */
+onFileClick, 
+/** Prevent runtime previews while there is no sandbox yet (instant shell). */
+deferPreview, 
+/**
+ * Files this prompt is sending, by NAME and TYPE only.
+ *
+ * A reload throws away the composer's optimistic state, so the durable
+ * queued row is all that is left — and it knows the names, never the bytes
+ * (the runtime has not received the files yet, and the row is polled).
+ * Without them a refreshed tab drew a bare sentence for a send of seven
+ * attachments, and the user could not tell a send with files from one
+ * without. Rendered without an open action until a runtime path exists.
+ */
+attachments: staged, 
+/**
+ * A failed accepted send remains visible until retry — see
+ * {@link AttachmentUploadStatus}.
+ */
+uploadStatus, 
+/** Keys the busy indicator's dot-matrix glyph — see `SessionDotMatrix`. */
+sessionId, 
+/**
+ * Draw the waiting row under the bubble. Default true — the whole point of
+ * this component is that the bubble and its "Thinking" row arrive together.
+ *
+ * `SessionChat` turns it off in one case: the transcript has already produced
+ * a turn (with its own busy row) whose user message carries no text yet, so
+ * this stands in for the missing bubble ABOVE it. Two waiting rows would be a
+ * lie about how much is running.
+ */
+busy, deliveryStatus, className, }: {
+    text: string;
+    agentNames?: string[];
+    onFileClick?: (path: string) => void;
+    deferPreview?: boolean;
+    attachments?: ReadonlyArray<SentAttachment>;
+    uploadStatus?: AttachmentUploadStatus;
+    sessionId?: string;
+    busy?: boolean;
+    deliveryStatus?: ReactNode;
+    className?: string;
+}): import("react").JSX.Element;
+/**
+ * Highlight @mentions in plain text (for optimistic & user messages).
+ *
+ * Draws the SAME chip the composer draws (`../mention-chip`) over the SAME
+ * segmentation the sent message uses (`../mention-segments`). Both used to be
+ * local to this file — an underlined-text treatment and its own copy of the
+ * range walk — so a mention visibly changed shape twice on its way through the
+ * app: chip in the composer, underline in the optimistic bubble, underline
+ * again in the server turn.
+ */
+export declare function HighlightMentions({ text, agentNames, onFileClick, }: {
+    text: string;
+    agentNames?: string[];
+    onFileClick?: (path: string) => void;
+}): import("react").JSX.Element;

package/dist/session/thread/optimistic-turn.js

@@ -0,0 +1,207 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useTranslations } from '../../i18n/index.js';
+import { expandPastedContent, splitPastedContent } from '../../_vendor/kortix-shared.js';
+import { useMemo } from 'react';
+import { MentionChip } from './mention-chip.js';
+import { buildMentionSegments } from './mention-segments.js';
+import { parseAgentMentionReferences, parseFileMentionReferences, parseFileReferences, parseProjectReferences, parseReplyContexts, parseSessionReferences, splitAtQuoteMarkers, } from './message-parsing.js';
+import { SessionBusyIndicator } from '../status/session-busy-indicator.js';
+import { BUBBLE_SURFACE, BUBBLE_TEXT, MessageAttachments, QuotedMessageBody, UserMessageActions, pastedAttachment, } from '../turn/user-message.js';
+import { useProjectSessionHref } from '../../internal/lib/navigation/session-href.js';
+import { cn } from '../../lib/utils.js';
+import { getFilename } from '../../internal/lib/utils/file-utils.js';
+import { openTabAndNavigate } from '../../internal/stores/tab-store.js';
+import { useUiShallowNavigate } from '../../providers/ui-provider.js';
+// `BUBBLE_SURFACE` / `BUBBLE_TEXT` are imported from `turn/user-message.tsx`,
+// not redeclared here. A local copy drifted twice already — first the dark
+// fill (`dark:bg-sidebar-accent-foreground/9` vs `dark:bg-muted`, fixed), then
+// the padding/radius (`px-3 py-2.5 rounded-lg` vs `px-4.5 py-3.5 rounded-xl`)
+// — each drift a visible bubble jump the instant the optimistic turn handed
+// over to the real server turn. One constant, imported, cannot drift.
+/**
+ * The optimistic turn — the user's message plus the assistant's waiting row,
+ * rendered the instant a message is sent and before any server turn exists.
+ *
+ * ONE component, deliberately: this exact turn is painted twice in a fresh
+ * session's life — first by {@link InstantSessionShell} while the computer boots,
+ * then again by {@link SessionChat} once the runtime is healthy — and the two
+ * crossfade into each other. Both surfaces used to hand-roll their own copy held
+ * together by a comment asking future authors to keep them identical. They had
+ * already drifted (different vertical padding, raw prompt text vs. parsed, a
+ * logomark on one side only), and every drift showed up as the thread twitching
+ * mid-handover. Sharing the render makes the contract structural instead of
+ * aspirational: there is nothing left to keep in sync.
+ *
+ * The waiting row is {@link SessionBusyIndicator} — the SAME component a live
+ * turn shows while working. So the whole arc (boot → runtime ready → first real
+ * turn) is one row that never unmounts its shape: only its label changes, and
+ * that change is already blur-bridged. No logomark that appears and then
+ * vanishes when the real turn lands, no boot checklist, no rotating filler
+ * copy — just "Thinking" until the agent has something truer to say.
+ */
+export function OptimisticTurn({ 
+/** The prompt text, already carrying any upload refs
+ *  (see `buildOptimisticPromptTextWithUploads`). */
+text, 
+/** Known agent names, so `@agent` mentions render as agent chips. */
+agentNames, 
+/** Opens a file mention. Omitted before a runtime exists — mentions then
+ *  render as static chips rather than dead buttons. */
+onFileClick, 
+/** Prevent runtime previews while there is no sandbox yet (instant shell). */
+deferPreview, 
+/**
+ * Files this prompt is sending, by NAME and TYPE only.
+ *
+ * A reload throws away the composer's optimistic state, so the durable
+ * queued row is all that is left — and it knows the names, never the bytes
+ * (the runtime has not received the files yet, and the row is polled).
+ * Without them a refreshed tab drew a bare sentence for a send of seven
+ * attachments, and the user could not tell a send with files from one
+ * without. Rendered without an open action until a runtime path exists.
+ */
+attachments: staged, 
+/**
+ * A failed accepted send remains visible until retry — see
+ * {@link AttachmentUploadStatus}.
+ */
+uploadStatus, 
+/** Keys the busy indicator's dot-matrix glyph — see `SessionDotMatrix`. */
+sessionId, 
+/**
+ * Draw the waiting row under the bubble. Default true — the whole point of
+ * this component is that the bubble and its "Thinking" row arrive together.
+ *
+ * `SessionChat` turns it off in one case: the transcript has already produced
+ * a turn (with its own busy row) whose user message carries no text yet, so
+ * this stands in for the missing bubble ABOVE it. Two waiting rows would be a
+ * lie about how much is running.
+ */
+busy = true, deliveryStatus, className, }) {
+    return (_jsxs("div", { "data-turn-id": "optimistic", className: cn('group/turn mt-12 first:mt-0', className), children: [_jsx("div", { className: "flex justify-end", children: _jsx(OptimisticUserBubble, { text: text, agentNames: agentNames, onFileClick: onFileClick, deferPreview: deferPreview, staged: staged, uploadStatus: uploadStatus, deliveryStatus: deliveryStatus }) }), busy && _jsx(SessionBusyIndicator, { sessionId: sessionId, className: "mt-6" })] }));
+}
+function OptimisticUserBubble({ text, agentNames, onFileClick, deferPreview, staged, uploadStatus, deliveryStatus, }) {
+    // Strip every ref block the composer folded into the prompt, in the order it
+    // folded them in, so the bubble shows the sentence the user typed and the
+    // attachments as tiles — never raw XML.
+    const { quotes, files, cleanText, pastes } = useMemo(() => {
+        // Pastes first, as on the sent turn: a ref inside a paste is paste text.
+        const { text: afterPastes, pastes } = splitPastedContent(text);
+        const { cleanText: afterReply, quotes } = parseReplyContexts(afterPastes);
+        const { cleanText: afterFiles, files } = parseFileReferences(afterReply);
+        const { cleanText: afterProjects } = parseProjectReferences(afterFiles);
+        const { cleanText: afterFileMentions } = parseFileMentionReferences(afterProjects);
+        const { cleanText: afterAgentMentions } = parseAgentMentionReferences(afterFileMentions);
+        const { cleanText } = parseSessionReferences(afterAgentMentions);
+        return { quotes, files, cleanText, pastes };
+    }, [text]);
+    // Quotes are drawn where they were written, by the same component the sent
+    // message uses — see `QuotedMessageBody`.
+    const quotedPieces = useMemo(() => (quotes.length > 0 ? splitAtQuoteMarkers(cleanText, quotes) : null), [cleanText, quotes]);
+    // Same shape MessageAttachments consumes on a real turn — one strip, one tile
+    // language, so the optimistic bubble and the server turn never disagree.
+    const attachments = useMemo(() => {
+        const fromText = files.map((f, i) => ({
+            // The attachment identity keys the tile, so the real turn keeps it. A
+            // ref without one falls back to its position.
+            key: f.attachment ? `attachment:${f.attachment}` : `optimistic:${i}:${f.path}`,
+            ...(f.attachment ? { id: f.attachment } : {}),
+            filename: getFilename(f.filename || f.path),
+            mime: f.mime,
+            // A file the runtime does not hold yet has no sandbox path to resolve.
+            // The sent picture comes from the identity (`sent-attachment-previews`).
+            src: deferPreview ? undefined : f.path || undefined,
+            path: deferPreview ? undefined : f.path || undefined,
+        }));
+        // A file that already landed is BOTH a text ref and (after a reload) a
+        // staged name. Names already drawn win, so the strip never doubles a tile.
+        const drawn = new Set(fromText.map((tile) => tile.filename));
+        const fromStaged = (staged ?? [])
+            .filter((file) => !drawn.has(file.filename))
+            .map((file, i) => ({
+            // A remembered sent identity keys the tile and finds its picture.
+            key: file.id ? `attachment:${file.id}` : `staged:${i}:${file.filename}`,
+            ...(file.id ? { id: file.id } : {}),
+            filename: file.filename,
+            mime: file.mime,
+            // No `src`/`path`: the runtime cannot preview or open this tile yet.
+        }));
+        return [...pastes.map(pastedAttachment), ...fromText, ...fromStaged];
+    }, [pastes, files, deferPreview, staged]);
+    return (_jsxs("div", { className: "ml-auto flex w-full max-w-[80%] flex-col items-end gap-2 self-end", children: [attachments.length > 0 && (_jsx(MessageAttachments, { attachments: attachments, status: uploadStatus })), (cleanText || quotedPieces) && (_jsx("div", { className: cn(BUBBLE_SURFACE, 'w-fit overflow-hidden'), children: quotedPieces ? (_jsx(QuotedMessageBody, { pieces: quotedPieces, renderText: (runText) => (_jsx(HighlightMentions, { text: runText, agentNames: agentNames, onFileClick: onFileClick })) })) : (_jsx("p", { className: BUBBLE_TEXT, children: _jsx(HighlightMentions, { text: cleanText, agentNames: agentNames, onFileClick: onFileClick }) })) })), _jsx(UserMessageActions, { timestamp: null, copyText: expandPastedContent(text), deliveryStatus: deliveryStatus })] }));
+}
+/**
+ * Highlight @mentions in plain text (for optimistic & user messages).
+ *
+ * Draws the SAME chip the composer draws (`../mention-chip`) over the SAME
+ * segmentation the sent message uses (`../mention-segments`). Both used to be
+ * local to this file — an underlined-text treatment and its own copy of the
+ * range walk — so a mention visibly changed shape twice on its way through the
+ * app: chip in the composer, underline in the optimistic bubble, underline
+ * again in the server turn.
+ */
+export function HighlightMentions({ text, agentNames, onFileClick, }) {
+    const tI18nComplete = useTranslations('hardcodedUi.i18nComplete');
+    // Strip every ref block (project/file/agent/session) before processing
+    // inline @ mentions so the visible text never shows raw XML.
+    const { cleanText, sessions } = useMemo(() => {
+        const a = parseProjectReferences(text);
+        const b = parseFileMentionReferences(a.cleanText);
+        const c = parseAgentMentionReferences(b.cleanText);
+        const d = parseSessionReferences(c.cleanText);
+        return {
+            cleanText: d.cleanText,
+            sessions: d.sessions,
+        };
+    }, [text]);
+    const sessionTitles = useMemo(() => sessions.map((s) => s.title), [sessions]);
+    const segments = useMemo(() => {
+        const built = buildMentionSegments({ text: cleanText, sessionTitles, agentNames });
+        // Key each segment by its source offset in the text — content-derived and
+        // unique per segment, even when the same mention appears twice.
+        let offset = 0;
+        return built.map((seg) => {
+            const key = `${offset}:${seg.type ?? 'text'}`;
+            offset += seg.text.length;
+            return { ...seg, key };
+        });
+    }, [cleanText, sessionTitles, agentNames]);
+    const sessionHref = useProjectSessionHref();
+    const shallowNavigate = useUiShallowNavigate();
+    const openSessionMention = (raw) => {
+        // `/projects/<id>/sessions/<id>`, not `/sessions/<id>`: the latter is not a
+        // route, so the URL it wrote into history 404'd on reload or Back even
+        // though the mounted tab looked fine. See `session-href.ts`.
+        // Direct session ID (ses_...) — navigate without title lookup
+        if (raw.startsWith('ses_')) {
+            const href = sessionHref(raw);
+            if (!href)
+                return;
+            openTabAndNavigate({
+                id: raw,
+                title: tI18nComplete.raw('text6959b4159575'),
+                type: 'session',
+                href,
+            }, undefined, shallowNavigate);
+            return;
+        }
+        const ref = sessions.find((s) => s.title === raw);
+        if (!ref)
+            return;
+        const href = sessionHref(ref.id);
+        if (!href)
+            return;
+        openTabAndNavigate({
+            id: ref.id,
+            title: ref.title || 'Session',
+            type: 'session',
+            href,
+        }, undefined, shallowNavigate);
+    };
+    return (_jsx(_Fragment, { children: segments.map((seg) => seg.type === 'file' ? (
+        // Static when there is no runtime to open the file in yet (the
+        // instant shell) — a chip that looks pressable and does nothing is
+        // worse than one that plainly does not.
+        _jsx(MentionChip, { kind: "file", label: seg.text.replace(/^@/, ''), onClick: onFileClick ? () => onFileClick(seg.text.replace(/^@/, '')) : undefined }, seg.key)) : seg.type === 'session' ? (_jsx(MentionChip, { kind: "session", label: seg.text.replace(/^@/, ''), onClick: () => openSessionMention(seg.text.replace(/^@/, '')) }, seg.key)) : seg.type === 'agent' ? (_jsx(MentionChip, { kind: "agent", label: seg.text.replace(/^@/, '') }, seg.key)) : (_jsx("span", { children: seg.text }, seg.key))) }));
+}

package/dist/session/thread/persisted-turn-failure.d.ts

@@ -0,0 +1,25 @@
+import type { SessionLogTurn } from '@kortix/sdk';
+type PersistedFailure = {
+    message_id?: string | null;
+    error?: {
+        message?: string | null;
+    } | null;
+};
+/** The sentence a turn-ledger failure shows: the gateway's, not its `429: {…}` body. */
+export declare function persistedFailureText(error: PersistedFailure['error']): string | undefined;
+/**
+ * Is a turn-ledger failure already on screen as a transcript turn? A ledger
+ * row carries no message id for some channel turns, so it repeats a turn that
+ * shows the same error.
+ */
+export declare function failureShownByTurn(failure: PersistedFailure, turns: ReadonlyArray<Pick<SessionLogTurn, 'id' | 'error'>>): boolean;
+/**
+ * Did a later turn replace a ledger failure that is not in the transcript? An
+ * edit rewinds the failed message and sends a new one, and the ledger still
+ * lists the old failure, so the row stayed under the new turn. A failure with
+ * no transcript turn sent after it (an admission rejection) still shows.
+ */
+export declare function failureSupersededByTurn(failure: PersistedFailure & {
+    ended_at?: string | null;
+}, turns: ReadonlyArray<Pick<SessionLogTurn, 'user'>>): boolean;
+export {};

package/dist/session/thread/persisted-turn-failure.js

@@ -0,0 +1,36 @@
+import { extractGatewayErrorDetails } from '../../internal/session-types/index.js';
+/** The sentence a turn-ledger failure shows: the gateway's, not its `429: {…}` body. */
+export function persistedFailureText(error) {
+    const raw = error?.message;
+    if (!raw)
+        return undefined;
+    return extractGatewayErrorDetails(raw)?.message || raw;
+}
+/**
+ * Is a turn-ledger failure already on screen as a transcript turn? A ledger
+ * row carries no message id for some channel turns, so it repeats a turn that
+ * shows the same error.
+ */
+export function failureShownByTurn(failure, turns) {
+    if (turns.some((turn) => turn.id === failure.message_id))
+        return true;
+    if (failure.message_id)
+        return false;
+    const text = persistedFailureText(failure.error);
+    return Boolean(text) && turns.some((turn) => turn.error?.message === text);
+}
+/**
+ * Did a later turn replace a ledger failure that is not in the transcript? An
+ * edit rewinds the failed message and sends a new one, and the ledger still
+ * lists the old failure, so the row stayed under the new turn. A failure with
+ * no transcript turn sent after it (an admission rejection) still shows.
+ */
+export function failureSupersededByTurn(failure, turns) {
+    const endedMs = failure.ended_at ? Date.parse(failure.ended_at) : Number.NaN;
+    if (!Number.isFinite(endedMs))
+        return false;
+    return turns.some((turn) => {
+        const created = turn.user.created_at ? Date.parse(turn.user.created_at) : Number.NaN;
+        return Number.isFinite(created) && created > endedMs;
+    });
+}

package/dist/session/thread/pinned-root-session.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The chat's root-conversation pin latch.
+ *
+ * The live pin (`useSession().runtimeSessionId`) can blip back to null
+ * mid-session (a runtime reconnect re-resolving), and the chat must keep its
+ * identity through that — hence a latch. But the live value can also CORRECT
+ * itself: the SDK's pin precedence only climbs (persisted localStorage mirror
+ * → session-row network read → the `/start` result), so a change from one
+ * non-null id to another is always a higher-authority source landing — e.g. a
+ * stale persisted mirror displaced by the real `/start` pin. A latch that
+ * ignored that kept painting — and delivering prompts into — the conversation
+ * the stale pin named.
+ *
+ * So: latch on first resolve, hold through null, follow any non-null change.
+ */
+export declare function resolvePinnedRootSessionId(pinned: string | null, live: string | null): string | null;

package/dist/session/thread/pinned-root-session.js

@@ -0,0 +1,18 @@
+/**
+ * The chat's root-conversation pin latch.
+ *
+ * The live pin (`useSession().runtimeSessionId`) can blip back to null
+ * mid-session (a runtime reconnect re-resolving), and the chat must keep its
+ * identity through that — hence a latch. But the live value can also CORRECT
+ * itself: the SDK's pin precedence only climbs (persisted localStorage mirror
+ * → session-row network read → the `/start` result), so a change from one
+ * non-null id to another is always a higher-authority source landing — e.g. a
+ * stale persisted mirror displaced by the real `/start` pin. A latch that
+ * ignored that kept painting — and delivering prompts into — the conversation
+ * the stale pin named.
+ *
+ * So: latch on first resolve, hold through null, follow any non-null change.
+ */
+export function resolvePinnedRootSessionId(pinned, live) {
+    return live ?? pinned;
+}

package/dist/session/thread/plan-surface.d.ts

@@ -0,0 +1,9 @@
+/**
+ * True when the TRANSCRIPT owns the plan, false when the Easy panel does.
+ *
+ * Subscribes to viewport width and nothing else. It deliberately does NOT read
+ * `isActionPanelOpen` / `isSidePanelOpen` / `panelMode`: those made the plan
+ * hop surfaces on every panel toggle, and they also re-rendered the whole
+ * transcript each time one of them changed.
+ */
+export declare function usePlanInChat(): boolean;