@kortix/ui 0.14.3 → 0.14.5

package/dist/session/thread/first-prompt-handover.d.ts

@@ -0,0 +1,54 @@
+import type { SessionLogTurn } from '@kortix/sdk';
+export declare function transcriptCarriesFirstPrompt(turns: readonly Pick<SessionLogTurn, 'user' | 'assistant'>[], expectedAttachments: number): boolean;
+/**
+ * The whole first-prompt handover, as one decision.
+ *
+ * The stand-in steps aside the frame the transcript shows the prompt's text —
+ * and then it STAYS aside. It used to be a live boolean, and the transcript's
+ * first message briefly has no parts while the store swaps the optimistic copy
+ * for the runtime's echo (measured 2026-09-06: ~176 ms as the file parts
+ * landed). For those frames the text was gone, the stand-in re-mounted at full
+ * opacity over the dimmed real turn, and the real turn drew nothing: the
+ * message flashed bright, then blank. A release is a latch.
+ *
+ * After release the REAL turn owns the prompt, and is handed everything the
+ * stand-in knew — text and file names — so it keeps drawing the bubble and the
+ * pending tiles through any frame where its own parts are still streaming.
+ */
+export interface FirstPromptHandoverInput {
+    /** The producer's copy exists (the boot preview store has this session). */
+    hasPreview: boolean;
+    /** The transcript's first user message carries its text right now. */
+    transcriptShowsText: boolean;
+    /** …and the attachments the preview promised. */
+    transcriptCarriesFiles: boolean;
+    /** The stand-in already stepped aside on an earlier frame. */
+    releasedBefore: boolean;
+    /**
+     * The transcript has NO turns at all right now.
+     *
+     * The latch below is what a release means, and it is right for the frames it
+     * was written for: the message is on screen and briefly loses its parts, so a
+     * turn still exists and the real turn owns the prompt. It is wrong for the
+     * one frame where the message is not on screen at all — between the server
+     * taking the prompt off the queue (its synthetic bubble goes with the row)
+     * and the runtime echoing it. The transcript is then empty, the latch says
+     * "the real turn has this", and nothing draws anything: the whole thread
+     * blanks with Stop still showing (dev, 2026-09-06, on video).
+     *
+     * Safe against the glitch the latch exists for: a user message with zero
+     * parts is still a turn, so an emptied bubble leaves this false.
+     *
+     * Optional — a caller that does not track it keeps the pure latch.
+     */
+    transcriptEmpty?: boolean;
+}
+export interface FirstPromptHandover {
+    /** Draw the stand-in bubble. */
+    showStandIn: boolean;
+    /** Hand the preview's text + file names to the real first turn. */
+    handOverToRealTurn: boolean;
+    /** The latch value to keep for the next frame. */
+    released: boolean;
+}
+export declare function resolveFirstPromptHandover(input: FirstPromptHandoverInput): FirstPromptHandover;

package/dist/session/thread/first-prompt-handover.js

@@ -0,0 +1,78 @@
+import { splitPastedContent } from '../../_vendor/kortix-shared.js';
+import { parseFileReferences } from './message-parsing.js';
+/**
+ * When the transcript's own copy of the first prompt is complete enough for the
+ * boot preview to step aside.
+ *
+ * "The transcript has it" used to mean a user message WITH TEXT on screen. But
+ * the runtime streams a message's parts, and it streams the text part FIRST:
+ * measured in a real browser on 2026-09-04, the file parts followed ~6 s later.
+ * Releasing on text alone therefore swapped a bubble with three tiles and an
+ * "Uploading 3 files…" line for a bubble with nothing under it — the exact
+ * frame Jay screenshotted as "prompt only, no attachments" — and the tiles
+ * only came back when the last part landed.
+ *
+ * So the preview is released when the transcript carries the text AND at
+ * least as many attachments as the preview promised. Attachments arrive two
+ * ways and both count: a model-native file as an attachment block (or a
+ * harness `file` block, a text/plain or directory mention), a materialized
+ * one as a `<file …>` reference the API folded into a text block.
+ *
+ * Bounded: an ANSWERED turn releases unconditionally. Nothing more is streaming
+ * then, and a file that never showed is never going to — holding on would pin
+ * a stale bubble over a finished turn.
+ */
+/**
+ * The text of a block that was a v1 text part: a text block, or an ignored
+ * text part (a harness `text` block, its data the v1 part).
+ */
+function textOf(block) {
+    if (block.type === 'text')
+        return block;
+    if (block.type === 'harness' && block.kind === 'text')
+        return block.data;
+    return undefined;
+}
+function messageAttachmentCount(blocks) {
+    let count = 0;
+    for (const block of blocks) {
+        if (block.type === 'attachment' || (block.type === 'harness' && block.kind === 'file'))
+            count += 1;
+        // A `<file>` inside a paste is paste text, not an attachment.
+        else {
+            const text = textOf(block)?.text;
+            if (typeof text === 'string' && text)
+                count += parseFileReferences(splitPastedContent(text).text).files.length;
+        }
+    }
+    return count;
+}
+export function transcriptCarriesFirstPrompt(turns, expectedAttachments) {
+    return turns.some((turn) => {
+        const blocks = turn.user.blocks;
+        // Ignored text counts, as it did for the v1 part: only `synthetic` text is not the prompt's.
+        const hasText = blocks.some((block) => {
+            const part = textOf(block);
+            return typeof part?.text === 'string' && !!part.text.trim() && !part.synthetic;
+        });
+        if (!hasText)
+            return false;
+        if (expectedAttachments <= 0)
+            return true;
+        if (turn.assistant.length > 0)
+            return true;
+        return messageAttachmentCount(blocks) >= expectedAttachments;
+    });
+}
+export function resolveFirstPromptHandover(input) {
+    if (!input.hasPreview)
+        return { showStandIn: false, handOverToRealTurn: false, released: true };
+    const released = input.releasedBefore || input.transcriptShowsText;
+    return {
+        // A release is a latch, EXCEPT over an empty transcript: there is no real
+        // turn to have handed the prompt to. See `transcriptEmpty`.
+        showStandIn: !released || !!input.transcriptEmpty,
+        handOverToRealTurn: released && !input.transcriptCarriesFiles,
+        released,
+    };
+}

package/dist/session/thread/mention-chip.d.ts

@@ -0,0 +1,51 @@
+/** `/` for a slash command, `@` for every reference kind. */
+export declare function chipPrefix(kind: string): string;
+/** The one place a chip's visible text is built. */
+export declare function chipText(kind: string, label: string): string;
+/** The one place a chip's accessible name is built. */
+export declare function chipAriaLabel(kind: string, label: string): string;
+/**
+ * One visual register for every chip. Mentions and commands share the faint
+ * primary tint — the surface says "this token is structured", and the prefix
+ * (`@` vs `/` from `chipPrefix`) says whether it is a reference or an
+ * instruction. `--primary` is a themed token, so ONE `bg-primary/[0.08]` is
+ * correct in both modes; the class carried a `dark:bg-primary/[0.08]` twin
+ * that resolved to the identical declaration and changed nothing.
+ * `align-baseline` keeps the chip riding the surrounding line instead of
+ * stretching it.
+ *
+ * `text-[0.95em]`, not a fixed size. The size has to be relative because this
+ * chip sits in two type contexts: the composer's editor (`text-base sm:text-sm`)
+ * and the message bubble's `text-[0.9rem]`. A fixed `text-base` is very
+ * slightly smaller than the composer's own body on desktop, which is what the
+ * chip already looked like — but dropped into the 14.4px bubble it would render
+ * LARGER than the sentence around it. An `em` keeps the chip a fixed fraction
+ * of whatever line it lands on, so "the chip looks the same in both places"
+ * holds by construction rather than by two files agreeing on a pixel value.
+ *
+ * The `kind` parameter is kept even though every kind currently resolves to
+ * the same class: callers pass it, and a future kind-specific surface changes
+ * this one function rather than every call site.
+ */
+export declare function chipClass(_kind: string): string;
+export interface MentionChipProps {
+    /** `file` | `agent` | `session` | `command`. */
+    kind: string;
+    /** The chip's text WITHOUT its prefix — `chipText` adds `@` or `/`. */
+    label: string;
+    /**
+     * Makes the chip a button. Omitted — an agent or command chip, or a file
+     * chip in a session with no runtime yet — renders a static `span` instead of
+     * a dead control.
+     */
+    onClick?: () => void;
+    className?: string;
+}
+/**
+ * A mention or command, drawn exactly as the composer draws it.
+ *
+ * `stopPropagation` is not optional here: the user bubble is itself a click
+ * target (it expands a clamped message), so a chip that let its click bubble
+ * would open a file AND toggle the bubble in one press.
+ */
+export declare function MentionChip({ kind, label, onClick, className }: MentionChipProps): import("react").JSX.Element;

package/dist/session/thread/mention-chip.js

@@ -0,0 +1,86 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * The one mention/command chip — shared so the composer's draft and the sent
+ * message can never drift apart.
+ *
+ * Same reasoning as `attachment-tile.tsx`, and the same failure it was
+ * extracted to end: `composer/editor/mention-node.ts` drew `@README.md` as a
+ * bordered chip while `turn/user-message.tsx` and `optimistic-turn.tsx` each
+ * drew the identical mention as underlined text, and a `/command` chip in the
+ * composer became a bordered card with a terminal icon the moment it was sent.
+ * Typing a message and sending it visibly changed what the message WAS.
+ *
+ * Consumed by `composer/editor/mention-node.ts` (the TipTap atom's `toDOM`,
+ * which needs the raw class + text strings, not the component),
+ * `turn/user-message.tsx` and `optimistic-turn.tsx` (the sent + optimistic
+ * bubbles, which use the component).
+ */
+import { cn } from '../../lib/utils.js';
+/** `/` for a slash command, `@` for every reference kind. */
+export function chipPrefix(kind) {
+    return kind === 'command' ? '/' : '@';
+}
+/** The one place a chip's visible text is built. */
+export function chipText(kind, label) {
+    return `${chipPrefix(kind)}${label}`;
+}
+/** The one place a chip's accessible name is built. */
+export function chipAriaLabel(kind, label) {
+    return kind === 'command' ? `command: /${label}` : `${kind} mention: ${label}`;
+}
+/**
+ * One visual register for every chip. Mentions and commands share the faint
+ * primary tint — the surface says "this token is structured", and the prefix
+ * (`@` vs `/` from `chipPrefix`) says whether it is a reference or an
+ * instruction. `--primary` is a themed token, so ONE `bg-primary/[0.08]` is
+ * correct in both modes; the class carried a `dark:bg-primary/[0.08]` twin
+ * that resolved to the identical declaration and changed nothing.
+ * `align-baseline` keeps the chip riding the surrounding line instead of
+ * stretching it.
+ *
+ * `text-[0.95em]`, not a fixed size. The size has to be relative because this
+ * chip sits in two type contexts: the composer's editor (`text-base sm:text-sm`)
+ * and the message bubble's `text-[0.9rem]`. A fixed `text-base` is very
+ * slightly smaller than the composer's own body on desktop, which is what the
+ * chip already looked like — but dropped into the 14.4px bubble it would render
+ * LARGER than the sentence around it. An `em` keeps the chip a fixed fraction
+ * of whatever line it lands on, so "the chip looks the same in both places"
+ * holds by construction rather than by two files agreeing on a pixel value.
+ *
+ * The `kind` parameter is kept even though every kind currently resolves to
+ * the same class: callers pass it, and a future kind-specific surface changes
+ * this one function rather than every call site.
+ */
+export function chipClass(_kind) {
+    return 'rounded-sm border-[0.5px] px-1.5 py-[0.08rem] [overflow-wrap:anywhere] font-medium whitespace-nowrap align-baseline text-[0.95em] bg-primary/[0.08] text-foreground';
+}
+/**
+ * The press/hover feel a NAVIGABLE chip adds on top of the shared surface —
+ * a file chip that opens the file, a session chip that opens the session.
+ *
+ * Only in the sent message: inside the composer a chip is document content,
+ * not a control, so it must not invite a click it cannot answer. `scale(0.97)`
+ * on press is the same feedback `TILE_INTERACTIVE` gives an attachment tile,
+ * for the same reason — a chip that opens something has to feel like it heard
+ * the click.
+ */
+const CHIP_INTERACTIVE = cn('cursor-pointer transition-colors duration-150', 'hover:bg-foreground/10 dark:hover:bg-foreground/10', 'active:scale-[0.97] active:transition-transform', 'focus-visible:ring-ring focus-visible:ring-2 focus-visible:outline-none');
+/**
+ * A mention or command, drawn exactly as the composer draws it.
+ *
+ * `stopPropagation` is not optional here: the user bubble is itself a click
+ * target (it expands a clamped message), so a chip that let its click bubble
+ * would open a file AND toggle the bubble in one press.
+ */
+export function MentionChip({ kind, label, onClick, className }) {
+    const text = chipText(kind, label);
+    const ariaLabel = chipAriaLabel(kind, label);
+    if (!onClick) {
+        return (_jsx("span", { "aria-label": ariaLabel, className: cn(chipClass(kind), className), children: text }));
+    }
+    return (_jsx("button", { type: "button", "aria-label": ariaLabel, onClick: (e) => {
+            e.stopPropagation();
+            onClick();
+        }, className: cn(chipClass(kind), CHIP_INTERACTIVE, className), children: text }));
+}

package/dist/session/thread/mention-segments.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Split a message's visible text into plain runs and mention runs.
+ *
+ * One implementation, because there were two: `turn/user-message.tsx` and
+ * `optimistic-turn.tsx`'s `HighlightMentions` each carried a near-identical
+ * copy of this walk, and they had already disagreed. The sent-message copy
+ * took an early return the moment it had ANY ref — so a message carrying a
+ * `<session_ref>` never ran the `@` regex, and every other mention in that
+ * message silently rendered as plain text. The optimistic copy ran both and
+ * got it right. This is the superset: server refs, then session titles, then
+ * a regex fill over whatever range is still uncovered.
+ *
+ * React-free on purpose — `mention-chip.tsx` owns how a segment LOOKS, this
+ * owns where segments ARE, and only the latter is worth testing without a DOM.
+ */
+export type MentionSegmentType = 'file' | 'agent' | 'session';
+export interface MentionSegment {
+    text: string;
+    /** Absent for a plain run of prose. */
+    type?: MentionSegmentType;
+}
+/**
+ * A mention the SERVER located for us, as a half-open `[start, end)` range
+ * into the same text passed to `buildMentionSegments`. More accurate than the
+ * regex when present — it knows a file part's exact source span.
+ */
+export interface MentionSourceRef {
+    start: number;
+    end: number;
+    type: MentionSegmentType;
+}
+/**
+ * Classify a bare `@token`. `ses_`-prefixed ids are session links the composer
+ * emitted without a resolvable title; a name we know belongs to an agent is an
+ * agent; everything else is addressed as a workspace file, which is what the
+ * click handler will try to open.
+ */
+export declare function classifyMentionToken(token: string, agentNames: ReadonlySet<string>): MentionSegmentType;
+export declare function buildMentionSegments({ text, sourceRefs, sessionTitles, agentNames, }: {
+    text: string;
+    /** Server-located spans — takes precedence over everything below. */
+    sourceRefs?: readonly MentionSourceRef[];
+    /** `<session_ref>` titles, matched as `@<title>` (titles contain spaces). */
+    sessionTitles?: readonly string[];
+    /** Known agent names, so `@build` chips as an agent rather than a file. */
+    agentNames?: readonly string[];
+}): MentionSegment[];

package/dist/session/thread/mention-segments.js

@@ -0,0 +1,117 @@
+/**
+ * Split a message's visible text into plain runs and mention runs.
+ *
+ * One implementation, because there were two: `turn/user-message.tsx` and
+ * `optimistic-turn.tsx`'s `HighlightMentions` each carried a near-identical
+ * copy of this walk, and they had already disagreed. The sent-message copy
+ * took an early return the moment it had ANY ref — so a message carrying a
+ * `<session_ref>` never ran the `@` regex, and every other mention in that
+ * message silently rendered as plain text. The optimistic copy ran both and
+ * got it right. This is the superset: server refs, then session titles, then
+ * a regex fill over whatever range is still uncovered.
+ *
+ * React-free on purpose — `mention-chip.tsx` owns how a segment LOOKS, this
+ * owns where segments ARE, and only the latter is worth testing without a DOM.
+ */
+/**
+ * `@` must open a token, not sit inside one.
+ *
+ * Group 1 is the leading boundary (start-of-string or whitespace) and exists
+ * only to be measured — its length is added back to get the `@`'s real offset.
+ * Written this way rather than as a lookbehind because the offset arithmetic
+ * is explicit and the pattern stays readable.
+ *
+ * This is what keeps `ship it, mail me at jay@kortix.com` from rendering
+ * `@kortix.com` as a file chip. The old inline regex was a bare `/@(\S+)/g`,
+ * which matched mid-token and turned every email address in a message into a
+ * mention.
+ */
+const MENTION_REGEX = /(^|\s)@(\S+)/g;
+/** Trailing punctuation is sentence, not name: `@README.md,` ends at `md`. A
+ *  loop, not `/[…]+$/`: that regex backtracks quadratically on a long
+ *  punctuation run (CodeQL js/polynomial-redos). */
+function trimTrailingPunctuation(token) {
+    let end = token.length;
+    while (end > 0 && '.,;:!?)]}\'"'.includes(token[end - 1]))
+        end -= 1;
+    return token.slice(0, end);
+}
+function overlaps(ranges, start, end) {
+    return ranges.some((r) => start < r.end && end > r.start);
+}
+/**
+ * Classify a bare `@token`. `ses_`-prefixed ids are session links the composer
+ * emitted without a resolvable title; a name we know belongs to an agent is an
+ * agent; everything else is addressed as a workspace file, which is what the
+ * click handler will try to open.
+ */
+export function classifyMentionToken(token, agentNames) {
+    if (token.startsWith('ses_'))
+        return 'session';
+    if (agentNames.has(token))
+        return 'agent';
+    return 'file';
+}
+export function buildMentionSegments({ text, sourceRefs = [], sessionTitles = [], agentNames = [], }) {
+    if (!text)
+        return [];
+    const ranges = [];
+    // Session titles first. A title can contain spaces, so no regex can find it
+    // — and the server, which cannot either, reports `@Fix the parser` as a file
+    // mention of the first word only. Claiming the range here is what stops that
+    // wrong, narrower ref from winning.
+    for (const title of sessionTitles) {
+        if (!title)
+            continue;
+        const needle = `@${title}`;
+        const idx = text.indexOf(needle);
+        if (idx === -1)
+            continue;
+        if (overlaps(ranges, idx, idx + needle.length))
+            continue;
+        ranges.push({ start: idx, end: idx + needle.length, type: 'session' });
+    }
+    for (const ref of sourceRefs) {
+        if (ref.start >= ref.end)
+            continue;
+        if (ref.start < 0 || ref.end > text.length)
+            continue;
+        if (overlaps(ranges, ref.start, ref.end))
+            continue;
+        ranges.push({ start: ref.start, end: ref.end, type: ref.type });
+    }
+    // Regex fill — every `@token` the two structured sources did not already
+    // claim. This runs unconditionally, which is the bug fix: the sent-message
+    // copy used to skip it entirely whenever a single structured ref existed.
+    const agentSet = new Set(agentNames);
+    MENTION_REGEX.lastIndex = 0;
+    let match;
+    while ((match = MENTION_REGEX.exec(text)) !== null) {
+        const start = match.index + match[1].length;
+        const token = trimTrailingPunctuation(match[2]);
+        if (!token)
+            continue;
+        const end = start + 1 + token.length;
+        if (overlaps(ranges, start, end))
+            continue;
+        ranges.push({ start, end, type: classifyMentionToken(token, agentSet) });
+    }
+    if (ranges.length === 0)
+        return [{ text }];
+    // Longest-first on a tie so a broad session range beats the narrow file ref
+    // the server reported for its first word.
+    ranges.sort((a, b) => a.start - b.start || b.end - a.end);
+    const segments = [];
+    let cursor = 0;
+    for (const range of ranges) {
+        if (range.start < cursor)
+            continue;
+        if (range.start > cursor)
+            segments.push({ text: text.slice(cursor, range.start) });
+        segments.push({ text: text.slice(range.start, range.end), type: range.type });
+        cursor = range.end;
+    }
+    if (cursor < text.length)
+        segments.push({ text: text.slice(cursor) });
+    return segments;
+}

package/dist/session/thread/message-parsing.d.ts

@@ -0,0 +1,80 @@
+interface ParsedFileRef {
+    path: string;
+    mime: string;
+    filename: string;
+    /** Present only on a sent ref drawn before delivery: the attachment identity.
+     *  See `sent-attachment-previews.ts`. */
+    attachment?: string;
+}
+export declare function parseFileReferences(text: string): {
+    cleanText: string;
+    files: ParsedFileRef[];
+};
+interface ParsedSessionRef {
+    id: string;
+    title: string;
+}
+export declare function parseSessionReferences(text: string): {
+    cleanText: string;
+    sessions: ParsedSessionRef[];
+};
+export interface ParsedProjectRef {
+    id?: string;
+    name: string;
+    path?: string;
+    description?: string;
+}
+export declare function parseProjectReferences(text: string): {
+    cleanText: string;
+    projects: ParsedProjectRef[];
+};
+export interface ParsedFileMentionRef {
+    path: string;
+    name: string;
+}
+export interface ParsedAgentMentionRef {
+    name: string;
+}
+export declare function parseFileMentionReferences(text: string): {
+    cleanText: string;
+    files: ParsedFileMentionRef[];
+};
+export declare function parseAgentMentionReferences(text: string): {
+    cleanText: string;
+    agents: ParsedAgentMentionRef[];
+};
+export { parseReplyContexts, QUOTE_MARKER_RE, quoteMarker, serializeReplyContext, splitAtQuoteMarkers, stripReplyContexts, } from './reply-context.js';
+export { parseTriggerEvent, type TriggerEventInfo } from '../../_vendor/shared/index.js';
+export { parseReminderPrompt, type ReminderPromptInfo } from '../../_vendor/shared/index.js';
+export { parseRoomDigest, parseRoomPrompt, type RoomDigestInfo, type RoomPromptInfo } from '../../_vendor/shared/index.js';
+interface SystemNotification {
+    tag: string;
+    label: string;
+    fields: [string, string][];
+    body: string;
+}
+/** Parse all remaining XML blocks from text as system notifications. */
+export declare function parseSystemNotifications(text: string): {
+    cleanText: string;
+    notifications: SystemNotification[];
+};
+export declare function stripSystemPtyText(text: string): string;
+/**
+ * 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 declare function systemNotificationSeverity(tag: string): 'error' | 'warning' | '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 declare function SystemNotificationCard({ notification }: {
+    notification: SystemNotification;
+}): import("react").JSX.Element;