@hachej/boring-ui-kit 0.4.25 → 0.4.26

package/dist/chat-text.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Optional chat text rules: the grammar of what a person types and what a message shows. Pure string functions; no React, files, agent
+ * or controller runtime. Registry items (pi-chat, pi-chat-slash, pi-chat-markdown, pi-chat-voice, shared-chat, ...) call these and keep
+ * no copy, so a composer, a bubble and the shared chat agree on one `@mention` syntax.
+ */
+/** Where a `/` menu entry comes from. Skills and host commands are grouped separately in the menu. */
+export type SlashSource = 'local' | 'extension' | 'prompt' | 'skill';
+/** The unified `/` menu entry. */
+export interface SlashItem {
+    readonly name: string;
+    readonly description: string;
+    readonly source: SlashSource;
+    readonly sourcePlugin?: string;
+}
+/** The commands and skills a `/` menu lists (the item's `SlashConfig` is assignable to it). */
+export interface SlashEntries {
+    readonly commands?: readonly {
+        readonly name: string;
+        readonly description?: string | undefined;
+        readonly sourcePlugin?: string | undefined;
+    }[] | undefined;
+    readonly skills?: readonly {
+        readonly name: string;
+        readonly description: string;
+        readonly sourcePlugin?: string | undefined;
+    }[] | undefined;
+}
+/** The `/` menu entries: host commands first, then skills. */
+export declare function slashItems(config: SlashEntries): SlashItem[];
+/** The group an item lives under in the filter chips: skills, its plugin, or `built-in`. */
+export declare function slashGroup(item: Pick<SlashItem, 'source' | 'sourcePlugin'>): string;
+/** `/` opens the menu only when the text before the caret is one `/token`, as in v2. */
+export declare function slashQuery(text: string, caret: number): string | null;
+export interface MentionTrigger {
+    readonly query: string;
+    readonly start: number;
+    readonly end: number;
+}
+/** An `@` at the start or after whitespace, up to the caret. */
+export declare function mentionTrigger(text: string, caret: number): MentionTrigger | null;
+/**
+ * The text of a mention of `path` (a workspace path or a shared-chat member id). A value with whitespace, a quote or a backslash is
+ * written in double quotes, `@"docs/Meeting notes.md"`, with `\` and `"` escaped, because a bare mention ends at a space and a bare `\`
+ * is not an escape. Any other value stays bare (`@docs/plan.md`).
+ */
+export declare function mentionToken(path: string): string;
+/**
+ * The `@` tokens of a message, bare or quoted: group 1 is the character before the `@` (or the start), group 2 the quoted body (escapes
+ * still in it), group 3 the bare path. `mentionedPaths` of `@hachej/boring-agent/mentions` parses the same syntax (a contract test keeps
+ * them equal).
+ */
+export declare const MENTION_TOKEN: RegExp;
+/** The distinct values a message mentions, in order. The same result as the agent's `mentionedPaths`. */
+export declare function mentionedPaths(text: string): string[];
+/** Whether the draft already holds a mention of `path`. */
+export declare function hasMention(text: string, path: string): boolean;
+/** The draft without its mention of `path` (and the space after it). */
+export declare function removeMention(text: string, path: string): string;
+/** A registered prefix wins only for that kind; ordinary file paths keep their existing presentation. */
+export declare function mentionKind<Kind>(value: string, config: {
+    readonly kinds?: Readonly<Record<string, Kind>> | undefined;
+} | undefined): {
+    readonly kind: Kind;
+    readonly path: string;
+} | undefined;
+/** The composer's editable text and hidden app tokens, derived only from the full draft. File tokens remain editable text. */
+export declare function kindMentionDraft<Kind>(text: string, config: {
+    readonly kinds?: Readonly<Record<string, Kind>> | undefined;
+} | undefined): {
+    readonly text: string;
+    readonly tokens: readonly string[];
+};
+/** Keep an explicit leading skill first, then complete hidden tokens before any unfinished quoted input. */
+export declare function writeKindMentionDraft(text: string, tokens: readonly string[], skills?: readonly string[]): string;
+/** Consume every draft token for voice sends, including repeated references to the same path. */
+export declare function withoutMentions(text: string): string;
+/** Refused messages restore the words, never the app card chips. File mentions retain their existing recovery behaviour. */
+export declare function withoutKindMentions<Kind>(text: string, config: {
+    readonly kinds?: Readonly<Record<string, Kind>> | undefined;
+} | undefined): string;
+/**
+ * The draft with `text` added at its end: a space between them unless the draft is empty or already ends in whitespace. Dictation,
+ * voice transcripts, picked mentions and app targets all append this way.
+ */
+export declare function appendToDraft(draft: string, text: string): string;
+/** The draft with `text` put back before it on its own line (a refused or withdrawn message); whitespace-only parts are dropped. */
+export declare function prependToDraft(draft: string, text: string): string;
+export type Piece = {
+    readonly text: string;
+    readonly kind?: 'mention' | 'skill';
+    readonly value?: string;
+};
+/** Upload paths are `uploads/<name>`: the attachments of a message, shown as cards rather than as text. */
+export declare const isUploadPath: (path: string) => boolean;
+export type FileKind = 'document' | 'image' | 'pdf' | 'sheet' | 'slides' | 'audio' | 'file';
+/** The card's kind, from the extension alone. */
+export declare function fileKind(path: string): FileKind;
+/** Recorded voice uses a reserved upload filename prefix; other audio remains a plain file card. */
+export declare const isVoicePath: (path: string) => boolean;
+/** The name a card shows: the upload's file name without the random suffix `uploadPath` adds (`report-1a2b3c4d.pdf` is `report.pdf`). */
+export declare function displayName(path: string): string;
+/**
+ * The pieces a message shows once `hidden` ones are taken out: a space that a removed piece leaves at a join is dropped, and the ends are
+ * trimmed where it was. The message's own text is not changed, only what the bubble draws.
+ */
+export declare function visibleParts(parts: readonly Piece[], hidden: (part: Piece) => boolean): Piece[];
+/** Paste-to-file thresholds: a paste with more characters or more lines than these becomes a file. Defaults 2000 and 40. */
+export interface PasteToFile {
+    readonly minChars?: number | undefined;
+    readonly minLines?: number | undefined;
+}
+/** Whether pasted text is long enough to become a file. `more` than the limits: the characters, or the lines, of the text. */
+export declare function isLongPaste(text: string, limits?: PasteToFile): boolean;
+/** Markdown in pasted text: a heading, a list or quote item, a fence, a table row, emphasis or a link. Anything else is plain text. */
+export declare function looksLikeMarkdown(text: string): boolean;
+/** Split a sent message into plain text, `@path` mentions and a leading `/skill` token. */
+export declare function pieces(text: string, options: {
+    readonly mentions: boolean;
+    readonly skills: readonly string[];
+    readonly uploads?: boolean;
+}): Piece[];
+//# sourceMappingURL=chat-text.d.ts.map

package/dist/chat-text.js

@@ -0,0 +1,216 @@
+/**
+ * Optional chat text rules: the grammar of what a person types and what a message shows. Pure string functions; no React, files, agent
+ * or controller runtime. Registry items (pi-chat, pi-chat-slash, pi-chat-markdown, pi-chat-voice, shared-chat, ...) call these and keep
+ * no copy, so a composer, a bubble and the shared chat agree on one `@mention` syntax.
+ */
+/** The `/` menu entries: host commands first, then skills. */
+export function slashItems(config) {
+    return [
+        ...(config.commands ?? []).map((command) => ({ name: command.name, description: command.description ?? '', source: 'local', ...(command.sourcePlugin ? { sourcePlugin: command.sourcePlugin } : {}) })),
+        ...(config.skills ?? []).map((skill) => ({ name: skill.name, description: skill.description, source: 'skill', ...(skill.sourcePlugin ? { sourcePlugin: skill.sourcePlugin } : {}) })),
+    ];
+}
+/** The group an item lives under in the filter chips: skills, its plugin, or `built-in`. */
+export function slashGroup(item) {
+    if (item.source === 'skill')
+        return 'skills';
+    return item.sourcePlugin || 'built-in';
+}
+/** `/` opens the menu only when the text before the caret is one `/token`, as in v2. */
+export function slashQuery(text, caret) {
+    const match = /^\/(\S*)$/.exec(text.slice(0, caret));
+    return match ? match[1] : null;
+}
+/** An `@` at the start or after whitespace, up to the caret. */
+export function mentionTrigger(text, caret) {
+    const before = text.slice(0, caret);
+    const match = /(^|\s)@(\S*)$/.exec(before);
+    // A typed opening quote (`@"Meeting`) is not part of the search; the token starts at the `@` either way.
+    return match ? { query: match[2].replace(/^"/, ''), start: before.length - match[2].length - 1, end: caret } : null;
+}
+/**
+ * The text of a mention of `path` (a workspace path or a shared-chat member id). A value with whitespace, a quote or a backslash is
+ * written in double quotes, `@"docs/Meeting notes.md"`, with `\` and `"` escaped, because a bare mention ends at a space and a bare `\`
+ * is not an escape. Any other value stays bare (`@docs/plan.md`).
+ */
+export function mentionToken(path) {
+    return /[\s"\\]/.test(path) ? `@"${path.replace(/[\\"]/g, '\\$&')}"` : `@${path}`;
+}
+/**
+ * The `@` tokens of a message, bare or quoted: group 1 is the character before the `@` (or the start), group 2 the quoted body (escapes
+ * still in it), group 3 the bare path. `mentionedPaths` of `@hachej/boring-agent/mentions` parses the same syntax (a contract test keeps
+ * them equal).
+ */
+export const MENTION_TOKEN = /(^|\s)@(?:"((?:[^"\\]|\\.)*)"|([^\s]+))/g;
+/** The value of one `MENTION_TOKEN` match: a quoted body unescaped, a bare one without trailing sentence punctuation. */
+const mentionValue = (match) => match[2] !== undefined ? match[2].replace(/\\(.)/g, '$1') : match[3].replace(/[.,;:!?)\]}'"]+$/, '');
+/** The distinct values a message mentions, in order. The same result as the agent's `mentionedPaths`. */
+export function mentionedPaths(text) {
+    const found = new Set();
+    for (const match of text.matchAll(MENTION_TOKEN)) {
+        const value = mentionValue(match);
+        if (value)
+            found.add(value);
+    }
+    return [...found];
+}
+const escape = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+/** Whether the draft already holds a mention of `path`. */
+export function hasMention(text, path) {
+    return pieces(text, { mentions: true, skills: [] }).some(piece => piece.kind === 'mention' && piece.value === path);
+}
+/** The draft without its mention of `path` (and the space after it). */
+export function removeMention(text, path) {
+    let removed = false, gap = false;
+    return pieces(text, { mentions: true, skills: [] }).map(piece => {
+        if (!removed && piece.kind === 'mention' && piece.value === path) {
+            removed = true;
+            gap = true;
+            return '';
+        }
+        if (gap) {
+            gap = false;
+            return piece.text.replace(/^ /, '');
+        }
+        return piece.text;
+    }).join('').replace(/^[ ]+/, '');
+}
+/** A registered prefix wins only for that kind; ordinary file paths keep their existing presentation. */
+export function mentionKind(value, config) {
+    const match = /^([a-z][a-z0-9-]*):(.+)$/s.exec(value);
+    const kind = match && config?.kinds && Object.hasOwn(config.kinds, match[1]) ? config.kinds[match[1]] : undefined;
+    return kind ? { kind, path: match[2] } : undefined;
+}
+/** The composer's editable text and hidden app tokens, derived only from the full draft. File tokens remain editable text. */
+export function kindMentionDraft(text, config) {
+    const hidden = new Set(), tokens = [];
+    let offset = 0;
+    for (const piece of pieces(text, { mentions: true, skills: [] })) {
+        const end = offset + piece.text.length;
+        if (piece.kind === 'mention' && mentionKind(piece.value, config)) {
+            tokens.push(piece.text);
+            for (let at = offset; at < end; at++)
+                hidden.add(at);
+            if (offset > 0 && text[offset - 1] === ' ' && !hidden.has(offset - 1))
+                hidden.add(offset - 1);
+            else if (text[end] === ' ')
+                hidden.add(end);
+        }
+        offset = end;
+    }
+    return { text: text.split('').filter((_, at) => !hidden.has(at)).join(''), tokens };
+}
+/** Keep an explicit leading skill first, then complete hidden tokens before any unfinished quoted input. */
+export function writeKindMentionDraft(text, tokens, skills = []) {
+    if (!tokens.length)
+        return text;
+    const leading = pieces(text, { mentions: false, skills })[0];
+    if (leading?.kind === 'skill')
+        return `${leading.text} ${tokens.join(' ')}${text.slice(leading.text.length)}`;
+    return `${tokens.join(' ')}${text ? ` ${text}` : ''}`;
+}
+/** Consume every draft token for voice sends, including repeated references to the same path. */
+export function withoutMentions(text) {
+    const words = visibleParts(pieces(text, { mentions: true, skills: [] }), piece => piece.kind === 'mention').map(piece => piece.text).join('').replace(/^[ ]+/, '');
+    return words.trim() ? words : '';
+}
+/** Refused messages restore the words, never the app card chips. File mentions retain their existing recovery behaviour. */
+export function withoutKindMentions(text, config) {
+    return visibleParts(pieces(text, { mentions: true, skills: [] }), piece => piece.kind === 'mention' && Boolean(mentionKind(piece.value, config))).map(piece => piece.text).join('').replace(/^[ ]+/, '');
+}
+/**
+ * The draft with `text` added at its end: a space between them unless the draft is empty or already ends in whitespace. Dictation,
+ * voice transcripts, picked mentions and app targets all append this way.
+ */
+export function appendToDraft(draft, text) {
+    return `${draft}${draft === '' || /\s$/.test(draft) ? '' : ' '}${text}`;
+}
+/** The draft with `text` put back before it on its own line (a refused or withdrawn message); whitespace-only parts are dropped. */
+export function prependToDraft(draft, text) {
+    return [text, draft].filter(value => value.trim()).join('\n');
+}
+/** Upload paths are `uploads/<name>`: the attachments of a message, shown as cards rather than as text. */
+export const isUploadPath = (path) => path.startsWith('uploads/');
+const KIND_BY_EXTENSION = {
+    png: 'image', jpg: 'image', jpeg: 'image', gif: 'image', webp: 'image', svg: 'image', bmp: 'image', avif: 'image',
+    pdf: 'pdf',
+    webm: 'audio', ogg: 'audio', m4a: 'audio', mp4: 'audio', mp3: 'audio', wav: 'audio',
+    csv: 'sheet', tsv: 'sheet', xls: 'sheet', xlsx: 'sheet', xlsm: 'sheet', ods: 'sheet', numbers: 'sheet',
+    ppt: 'slides', pptx: 'slides', odp: 'slides', key: 'slides',
+    md: 'document', markdown: 'document', txt: 'document', doc: 'document', docx: 'document', odt: 'document', rtf: 'document',
+};
+/** The card's kind, from the extension alone. */
+export function fileKind(path) {
+    const extension = /\.([^./]+)$/.exec(path)?.[1]?.toLowerCase() ?? '';
+    return KIND_BY_EXTENSION[extension] ?? 'file';
+}
+/** Recorded voice uses a reserved upload filename prefix; other audio remains a plain file card. */
+export const isVoicePath = (path) => /^uploads\/voice-[^/]+$/.test(path) && fileKind(path) === 'audio';
+/** The name a card shows: the upload's file name without the random suffix `uploadPath` adds (`report-1a2b3c4d.pdf` is `report.pdf`). */
+export function displayName(path) {
+    const name = path.slice(path.lastIndexOf('/') + 1);
+    return name.replace(/-[0-9a-f]{8}(?=\.[^.]*$|$)/i, '');
+}
+/**
+ * The pieces a message shows once `hidden` ones are taken out: a space that a removed piece leaves at a join is dropped, and the ends are
+ * trimmed where it was. The message's own text is not changed, only what the bubble draws.
+ */
+export function visibleParts(parts, hidden) {
+    const out = [];
+    let gap = false;
+    for (const part of parts) {
+        if (hidden(part)) {
+            gap = true;
+            continue;
+        }
+        const prev = out[out.length - 1];
+        const joins = gap && part.kind === undefined && (prev === undefined || (prev.kind === undefined && /\s$/.test(prev.text)));
+        out.push(joins ? { text: part.text.replace(/^\s+/, '') } : part);
+        gap = false;
+    }
+    const last = out[out.length - 1];
+    if (gap && last && last.kind === undefined)
+        out[out.length - 1] = { text: last.text.replace(/\s+$/, '') };
+    return out.filter(part => part.kind !== undefined || part.text !== '');
+}
+/** Whether pasted text is long enough to become a file. `more` than the limits: the characters, or the lines, of the text. */
+export function isLongPaste(text, limits = {}) {
+    const { minChars = 2000, minLines = 40 } = limits;
+    return text.length > minChars || text.split('\n').length > minLines;
+}
+/** Markdown in pasted text: a heading, a list or quote item, a fence, a table row, emphasis or a link. Anything else is plain text. */
+export function looksLikeMarkdown(text) {
+    return /^\s{0,3}(#{1,6}\s|[-*+]\s|\d+[.)]\s|>\s|```|~~~)/m.test(text) || /\*\*[^*\n]+\*\*|\]\([^)\n]+\)|^\|.*\|\s*$/m.test(text);
+}
+/** Split a sent message into plain text, `@path` mentions and a leading `/skill` token. */
+export function pieces(text, options) {
+    const found = [];
+    const skill = options.skills.length ? new RegExp(`^/(${options.skills.map(escape).join('|')})(?=\\s|$)`).exec(text) : null;
+    if (skill)
+        found.push({ start: 0, end: skill[0].length, kind: 'skill', value: skill[1] });
+    if (options.mentions || options.uploads) {
+        for (const match of text.matchAll(MENTION_TOKEN)) {
+            // A quoted path keeps its punctuation (the closing quote ends it); a bare one drops trailing punctuation, as a sentence would.
+            const quoted = match[2] !== undefined;
+            const path = mentionValue(match);
+            if (!path || (!options.mentions && !isUploadPath(path)))
+                continue;
+            const start = match.index + match[1].length;
+            const end = quoted ? match.index + match[0].length : start + 1 + path.length;
+            found.push({ start, end, kind: 'mention', value: path });
+        }
+    }
+    const out = [];
+    let cursor = 0;
+    for (const item of found.sort((a, b) => a.start - b.start)) {
+        if (item.start < cursor)
+            continue;
+        if (item.start > cursor)
+            out.push({ text: text.slice(cursor, item.start) });
+        out.push({ text: text.slice(item.start, item.end), kind: item.kind, value: item.value });
+        cursor = item.end;
+    }
+    if (cursor < text.length)
+        out.push({ text: text.slice(cursor) });
+    return out;
+}

package/dist/chat-view.d.ts

@@ -34,23 +34,7 @@ export interface ToolEntry<Content = unknown> {
     readonly status: ToolStatus;
     readonly custom?: Content;
 }
-/**
- * An artifact a tool call made (or a running `present` call is making), as the chat places it. `descriptor` is the artifacts item's own
- * value: the chat hands it back to the host's `open` and `isOpen` and never reads it.
- */
-export interface ChatArtifact {
-    readonly state: 'presenting' | 'ready';
-    /** One card per id in a reply: the last version, at the place of its last step. */
-    readonly id: string | undefined;
-    readonly title: string | undefined;
-    /** The workspace path, for the conversation's file list. */
-    readonly path: string | undefined;
-    /** The tool's own result carries it, so its card replaces the step; a host-detected one is shown in addition to the step. */
-    readonly own: boolean;
-    readonly descriptor: unknown;
-}
-/** Finds an artifact descriptor a finished call's result does not carry itself (the host's `detect`). */
-export type ArtifactDetect = (call: ToolCall, result: ToolResultMessage) => unknown;
+import type { ArtifactDetect, ChatArtifact } from './chat-artifacts.js';
 /** The artifact a call made, or that a running call (`running`) is making; undefined for any other call. */
 export type ArtifactRecognise = (call: ToolCall, result: ToolResultMessage | undefined, running: boolean, detect: ArtifactDetect | undefined) => ChatArtifact | undefined;
 /**
@@ -275,4 +259,5 @@ export declare function finishNotice(rows: readonly Row<unknown>[], text?: Notic
     readonly kind: 'done' | 'error';
     readonly summary: string;
 } | undefined;
+export * from './chat-artifacts.js';
 //# sourceMappingURL=chat-view.d.ts.map

package/dist/chat-view.js

@@ -391,3 +391,4 @@ export function finishNotice(rows, text = defaultNoticeText) {
         return { kind: 'error', summary: last.errorMessage ?? text.runFailed };
     return { kind: 'done', summary: summaryOf(last?.text ?? '') || text.finished };
 }
+export * from './chat-artifacts.js';

package/dist/run-notifications.d.ts

@@ -0,0 +1,42 @@
+import type { ToolCall } from '@earendil-works/pi-ai';
+import type { ChatController } from './native-chat.js';
+import type { NoticeText } from './chat-view.js';
+/** Transient host presentation, never native execution state. */
+export type NotificationKind = 'done' | 'input' | 'error';
+export interface AgentNotification {
+    readonly id: string;
+    readonly kind: NotificationKind;
+    readonly title: string;
+    readonly summary?: string | undefined;
+    readonly conversationId?: string | undefined;
+    readonly createdAt: number;
+}
+export type NewNotification = Omit<AgentNotification, 'id' | 'createdAt'> & {
+    readonly id?: string | undefined;
+};
+export interface NotificationStore {
+    readonly subscribe: (listener: () => void) => () => void;
+    readonly getSnapshot: () => readonly AgentNotification[];
+    readonly push: (notification: NewNotification) => string;
+    readonly dismiss: (id: string) => void;
+    readonly dismissConversation: (conversationId: string, kind?: NotificationKind) => void;
+    readonly clear: () => void;
+}
+export declare function createNotificationStore(): NotificationStore;
+type Outcome = 'done' | 'error' | null;
+export interface RunNotificationOptions {
+    readonly conversationId: string;
+    readonly title: string | (() => string);
+    /** The source recipe owns the ask_user form grammar. */
+    readonly question: (call: ToolCall) => string;
+    readonly text?: NoticeText | undefined;
+    readonly enabled?: boolean | undefined;
+    /** Suppresses pushes, not observation or dismissals (for an already visible conversation). */
+    readonly suppress?: (() => boolean) | undefined;
+    readonly onOutcome?: ((outcome: Outcome) => void) | undefined;
+}
+export type RunNotificationSource = Pick<ChatController, 'getSnapshot' | 'subscribe'>;
+/** Borrows an existing controller; unsubscribe detaches only this viewer, never stops or disposes a task. */
+export declare function watchConversation(controller: RunNotificationSource, store: NotificationStore, options: RunNotificationOptions | (() => RunNotificationOptions)): () => void;
+export {};
+//# sourceMappingURL=run-notifications.d.ts.map

package/dist/run-notifications.js

@@ -0,0 +1,67 @@
+import { derive, finishNotice, pendingNotice } from './chat-view.js';
+export function createNotificationStore() {
+    let items = [];
+    let sequence = 0;
+    const listeners = new Set();
+    const set = (next) => { items = next; for (const listener of [...listeners])
+        listener(); };
+    return {
+        subscribe: listener => { listeners.add(listener); return () => { listeners.delete(listener); }; },
+        getSnapshot: () => items,
+        push: notification => {
+            const id = notification.id ?? `notification-${++sequence}`;
+            set([...items.filter(item => item.id !== id), { ...notification, id, createdAt: Date.now() }]);
+            return id;
+        },
+        dismiss: id => { if (items.some(item => item.id === id))
+            set(items.filter(item => item.id !== id)); },
+        dismissConversation: (conversationId, kind) => {
+            if (items.some(item => item.conversationId === conversationId && (!kind || item.kind === kind)))
+                set(items.filter(item => item.conversationId !== conversationId || (kind && item.kind !== kind)));
+        },
+        clear: () => { if (items.length)
+            set([]); },
+    };
+}
+/** Both watchers consume connected observations only; a transport gap cannot establish a finish or consume a transition. */
+function transition(before, now, rows, text) {
+    return { state: now, inputChanged: now.question !== before?.question,
+        started: Boolean(before && now.working && !before.working),
+        finished: before?.working && !now.working ? finishNotice(rows, text) : undefined };
+}
+/** Borrows an existing controller; unsubscribe detaches only this viewer, never stops or disposes a task. */
+export function watchConversation(controller, store, options) {
+    let before;
+    const observe = () => {
+        const snapshot = controller.getSnapshot();
+        if (snapshot.connection.kind !== 'connected')
+            return;
+        const config = typeof options === 'function' ? options() : options;
+        const derived = derive(snapshot.view, { mode: 'expert', renderEntry: undefined, renderTool: undefined, groupTool: undefined });
+        const next = transition(before, { working: Boolean(derived.run), question: pendingNotice(derived.rows, config.question, config.text) }, derived.rows, config.text);
+        before = next.state; // Fence reentrant host callbacks before delivering effects.
+        const { conversationId } = config;
+        const push = (kind, summary) => {
+            if (config.enabled === false || config.suppress?.())
+                return;
+            store.push({ id: `${conversationId}:${kind === 'input' ? 'input' : 'done'}`, kind, title: typeof config.title === 'function' ? config.title() : config.title, summary, conversationId });
+        };
+        if (next.started) {
+            store.dismiss(`${conversationId}:done`);
+            config.onOutcome?.(null);
+        }
+        if (next.inputChanged) {
+            if (next.state.question === undefined)
+                store.dismiss(`${conversationId}:input`);
+            else
+                push('input', next.state.question);
+        }
+        if (next.finished) {
+            config.onOutcome?.(next.finished.kind);
+            push(next.finished.kind, next.finished.summary);
+        }
+    };
+    const unsubscribe = controller.subscribe(observe);
+    observe();
+    return unsubscribe;
+}

package/dist/shared-chat/index.d.ts

@@ -45,7 +45,7 @@ export declare function createSharedChat(source: ChannelSource, options: {
     canRemove: (message: ChannelMessage) => boolean;
 };
 export type SharedChatController = ReturnType<typeof createSharedChat>;
-/** The composer uses the existing quoted @ token grammar. Tokens carry stable member ids; picker labels show names. */
+/** A member is mentioned with the chat's one `@` token grammar (`mentionToken` of `chat-text`). Tokens carry stable member ids; picker labels show names. */
 export declare function memberMention(member: Member): string;
 export { createFakeChannelSource } from './fake.js';
 export type { FakeChannelSeed } from './fake.js';

package/dist/shared-chat/index.js

@@ -1,5 +1,6 @@
 import { randomUUID } from '@hachej/boring-files/platform';
 import { createChatOutbox } from '../chat-outbox.js';
+import { mentionedPaths, mentionToken } from '../chat-text.js';
 import { ChannelRequestError } from './error.js';
 export { ChannelRequestError } from './error.js';
 import { cardActions } from './source.js';
@@ -277,13 +278,13 @@ function latestAt(messages) {
     const now = Date.now(), newest = Math.max(0, ...messages.map(message => Date.parse(message.at)).filter(Number.isFinite));
     return new Date(Math.max(now, newest + 1)).toISOString();
 }
-/** The composer uses the existing quoted @ token grammar. Tokens carry stable member ids; picker labels show names. */
+/** A member is mentioned with the chat's one `@` token grammar (`mentionToken` of `chat-text`). Tokens carry stable member ids; picker labels show names. */
 export function memberMention(member) {
-    return /[\s"\\]/.test(member.id) ? `@"${member.id.replace(/[\\"]/g, '\\$&')}"` : `@${member.id}`;
+    return mentionToken(member.id);
 }
+/** Whether the text mentions the member, parsed as the composer and the agent parse mentions (`mentionedPaths` of `chat-text`). */
 function hasMemberMention(text, member) {
-    const token = memberMention(member);
-    return [...text.matchAll(/(^|\s)(@"(?:[^"\\]|\\.)*"|@[^\s]+)/g)].some(match => match[2] === token);
+    return mentionedPaths(text).includes(member.id);
 }
 export { createFakeChannelSource } from './fake.js';
 export { createChannelSocket } from './socket.js';

package/dist/voice-capture.d.ts

@@ -18,8 +18,20 @@ export interface VoiceRecording {
     /** The recording reached `maxMs` and stopped on its own. */
     readonly truncated: boolean;
 }
+/** Live capture facts. PCM elapsed time and level come from kept samples, never a synthetic waveform. */
+export interface VoiceCaptureProgress {
+    readonly elapsedMs: number;
+    /** Root mean square amplitude in [0, 1]; unavailable on the MediaRecorder fallback. */
+    readonly level: number | undefined;
+    readonly paused: boolean;
+    readonly canPause: boolean;
+}
 export interface VoiceCapture {
     readonly start: () => Promise<VoiceStart>;
+    readonly progress: () => VoiceCaptureProgress | null;
+    /** PCM only: pauses/resumes appending samples. False when unavailable or already ended. */
+    readonly pause: () => boolean;
+    readonly resume: () => boolean;
     /** Ends the recording and returns it; null when nothing was recorded (never started, cancelled, or empty). */
     readonly stop: () => Promise<VoiceRecording | null>;
     /** Ends the recording, releases the microphone and discards the audio. */

package/dist/voice-capture.js

@@ -213,7 +213,7 @@ export function createVoiceCapture(options = {}) {
         }
         let cancelled;
         const current = {
-            stream, context, source: null, node: null, chunks: [], samples: 0, startedAt: null, truncated: false, cancelled: false, ended: false,
+            stream, context, source: null, node: null, chunks: [], samples: 0, startedAt: null, truncated: false, cancelled: false, ended: false, paused: false, level: 0,
             maxSamples: Number.isFinite(maxMs) && maxMs > 0 ? Math.floor((maxMs / 1000) * WAV_RATE) : Number.POSITIVE_INFINITY,
             cancel: () => cancelled(),
         };
@@ -251,7 +251,7 @@ export function createVoiceCapture(options = {}) {
             return refused('unsupported', error instanceof Error ? error.message : String(error));
         }
         current.node.onaudioprocess = event => {
-            if (current.ended)
+            if (current.ended || current.paused)
                 return;
             const input = event.inputBuffer.getChannelData(0);
             if (current.startedAt === null) {
@@ -261,6 +261,10 @@ export function createVoiceCapture(options = {}) {
             const chunk = downsample(input, context.sampleRate);
             const room = current.maxSamples - current.samples;
             const kept = chunk.length > room ? chunk.subarray(0, room) : chunk;
+            let squares = 0;
+            for (const sample of kept)
+                squares += sample * sample;
+            current.level = kept.length ? Math.min(1, Math.sqrt(squares / kept.length)) : 0;
             current.chunks.push(kept);
             current.samples += kept.length;
             if (current.samples >= current.maxSamples)
@@ -298,6 +302,17 @@ export function createVoiceCapture(options = {}) {
         }
     };
     return {
+        progress() {
+            if (wav)
+                return { elapsedMs: wav.samples / WAV_RATE * 1000, level: wav.level, paused: wav.paused, canPause: !wav.ended && wav.startedAt !== null };
+            if (!session || session.startedAt === null)
+                return null;
+            return { elapsedMs: Math.min(Math.max(0, (session.stoppedAt ?? now()) - session.startedAt), maxMs > 0 ? maxMs : Infinity), level: undefined, paused: false, canPause: false };
+        },
+        pause() { if (!wav || wav.ended || wav.startedAt === null)
+            return false; wav.paused = true; return true; },
+        resume() { if (!wav || wav.ended || wav.startedAt === null)
+            return false; wav.paused = false; return true; },
         async start() {
             if (session || wav || opening)
                 return { kind: 'refused', code: 'failed', reason: 'Already recording.' };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hachej/boring-ui-kit",
-  "version": "0.4.25",
+  "version": "0.4.26",
   "license": "MIT",
   "private": false,
   "type": "module",
@@ -59,6 +59,14 @@
       "types": "./dist/chat-view.d.ts",
       "import": "./dist/chat-view.js"
     },
+    "./chat-react": {
+      "types": "./dist/chat-react.d.ts",
+      "import": "./dist/chat-react.js"
+    },
+    "./chat-text": {
+      "types": "./dist/chat-text.d.ts",
+      "import": "./dist/chat-text.js"
+    },
     "./voice-capture": {
       "types": "./dist/voice-capture.d.ts",
       "import": "./dist/voice-capture.js"
@@ -138,7 +146,7 @@
     }
   },
   "peerDependencies": {
-    "@hachej/boring-files": "^0.4.25",
+    "@hachej/boring-files": "^0.4.26",
     "@earendil-works/pi-durable": "~1.2.0",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",