@hachej/boring-ui-kit 0.4.46 → 0.4.47

package/README.md

@@ -18,10 +18,6 @@ See [scaffold guide](../../docs/contracts/SCAFFOLD.md) and [audit](../../docs/co
 
 ## Business task board
 
-`@hachej/boring-ui-kit/task-board` is a dependency-free host-record model: `TaskRecord`, `TaskState`, `TaskFilter`, `selectTasks`, `taskReference`, `taskFromUrl`, `taskUrl` and `TASK_STATES`. `selectTasks(tasks, { filter, currentUser, limit })` filters then sorts newest-first without mutating input. `mine` requires the host adapter's `requesterId`; it is never an authorization boundary. These business tasks are not native Pi execution tasks. The model also accepts host display metadata (`age`, `requester`, `refiner`, `captureCount`, `folder`), question `askedBy`/`askedAt`, and file `kind: 'markdown' | 'mockup' | 'capture'`. These fields never determine ownership. `deriveTaskStatus` prioritizes the native viewer flag, explicit `waiting_on.type: 'builder'`, then high risk; unknown status yields `none`. `taskStatusLabel(status, locale?, viewerAction?)` supplies EN/FR question versus confirmation wording without inferring workflow authority.
-
-Copyable `TaskBoard`, `TaskDetail`, `TaskRequestCard` (also `TaskCard`) and `TaskStatusChip` presentation lives in the [`task-board` registry item](../../registry/README.md#task-board-task-board), using the app's Base UI controls/tokens. The [feature map](../../features/task-board.md) and [fictional example](../../examples/task-board/README.md) drive responsive columns/detail, URL navigation and compact own-request rows.
-
 ## Exact proposals and commands
 
 `actions.propose(selection, edits, summary)` retains an immutable proposal with its exact resource/scope/view/revision, viewer instance/epoch, buffer version, before/after text and ordered edits. It performs no publication and preserves existing human text. Every nonempty `find` must occur once; a missing or ambiguous edit rejects the entire transform.

package/dist/chat-react-session.d.ts

@@ -142,6 +142,7 @@ export declare function useChatSession<Content = unknown>(options: ChatSessionOp
     loading: boolean;
     developer: boolean;
     natural: boolean;
+    sending: boolean;
     send: () => void;
     putBack: (text: string, images: readonly ChatAttachment[]) => void;
     upload: (files: readonly File[], paste?: {

package/dist/chat-react-session.js

@@ -49,7 +49,14 @@ export function useChatSession(options) {
         return derive({ ...state.view, entries, docs: {} }, { mode, presentation, hideLine, renderEntry: undefined, renderTool: undefined, groupTool: undefined, artifacts: artifactDetect, subagent }).rows
             .map(row => ({ ...row, key: `history:${row.key}`, historical: true }));
     }, [state.view, state.history, mode, presentation, hideLine, artifactDetect, subagent]);
-    const rows = useMemo(() => [...earlier, ...derived.rows], [earlier, derived.rows]);
+    // What the person just sent is on screen at once, as their own message, until the server's copy arrives (the controller drops it then).
+    const echo = state.echo;
+    const echoRows = useMemo(() => (echo ?? []).map(item => ({ key: `echo:${item.key}`, type: 'user', local: item.state,
+        message: { role: 'user', timestamp: item.sentAt, content: item.draft.attachments.length ? [{ type: 'text', text: item.draft.text }, ...item.draft.attachments.map(attachment => attachment.content)] : item.draft.text } })), [echo]);
+    const rows = useMemo(() => [...earlier, ...derived.rows, ...echoRows], [earlier, derived.rows, echoRows]);
+    // Tells the controller the echoed messages are on screen (after the commit that drew them), for its timing record.
+    useLayoutEffect(() => { if (echo?.length)
+        controller.markShown?.(echo.map(item => item.key)); }, [echo, controller]);
     const files = useMemo(() => {
         const found = new Map();
         const open = onOpenFile ?? mentions?.open;
@@ -121,7 +128,9 @@ export function useChatSession(options) {
         if (images.length)
             controller.setAttachments([...images, ...draft.attachments.filter(item => !images.some(image => image.id === item.id))]);
     };
-    const working = Boolean(run);
+    // Working from the moment of sending: the status shows before the server has taken the message.
+    const sending = Boolean(echo?.some(item => item.state === 'sending'));
+    const working = Boolean(run) || sending;
     const waitingForAnswer = waitsForAnswer(derived.rows);
     const send = () => {
         if (sendBlocked || !current())
@@ -356,7 +365,7 @@ export function useChatSession(options) {
     const empty = connected && !state.view?.entries.length && !rows.length;
     const loading = (state.connection.kind === 'idle' || state.connection.kind === 'connecting') && !state.view;
     return { state, derived, rows, queued, queueActions, working, waitingForAnswer, connected, sendBlocked, error, setError, report, act, current,
-        files, empty, loading, developer, natural, send, putBack, upload, pasteText, picked, pending, uploading, activateMention,
+        files, empty, loading, developer, natural, sending, send, putBack, upload, pasteText, picked, pending, uploading, activateMention,
         pickMention: (path) => setPicked(value => value.includes(path) ? value : [...value, path]),
         dismissUpload: (id) => setPending(items => items.filter(item => item.id !== id)),
         currentModel: optimistic.model ?? viewModel, currentEffort: optimistic.effort ?? viewEffort,

package/dist/chat-view.d.ts

@@ -111,7 +111,8 @@ export type Part<Content = unknown> = {
 export type Row<Content = unknown> = ({
     readonly key: string;
     readonly type: 'user';
-    readonly message: UserMessage; /** `messageStyle="messaging"`: first of a run (see `markLeads`). */
+    readonly message: UserMessage; /** A message just sent that the server has not shown yet (`sending`), or whose send was not confirmed (`failed`). */
+    readonly local?: 'sending' | 'failed'; /** `messageStyle="messaging"`: first of a run (see `markLeads`). */
     readonly lead?: boolean;
 } | {
     readonly key: string;

package/dist/native-chat.d.ts

@@ -98,6 +98,34 @@ export type ChatHistoryState = {
     readonly hasMore: boolean;
     readonly error: unknown;
 };
+/**
+ * A message the person sent that the server has not shown yet. The chat draws it as their message at once (the echo), and drops it
+ * when the server's own copy arrives in the view, so it never shows twice. `failed`: the send was not confirmed (see `send`: `unknown`).
+ */
+export interface EchoMessage {
+    readonly key: string;
+    readonly draft: ChatDraft;
+    /** Wall-clock ms (`Date.now()`) when it was sent. */
+    readonly sentAt: number;
+    readonly state: 'sending' | 'failed';
+}
+/** Times in ms on `performance.now()` for one sent message, for tests and harnesses; a step not reached yet is absent. */
+export interface SendTiming {
+    readonly key: string;
+    /** The person pressed Enter (the controller's `send` was called). */
+    readonly enter: number;
+    /** The message was on screen (the chat's layout effect after it committed the echo). */
+    readonly shown?: number;
+    /** The first words of the reply reached the view. */
+    readonly firstWords?: number;
+    /** The reply was complete (the run ended). */
+    readonly done?: number;
+}
+export interface ChatTiming {
+    /** The connection first became usable (the composer can send). */
+    readonly inputReady?: number;
+    readonly sends: readonly SendTiming[];
+}
 export interface NativeChatSnapshot {
     readonly identity: ChatIdentity;
     readonly conversationId: Conversation['id'];
@@ -106,13 +134,20 @@ export interface NativeChatSnapshot {
     readonly draft: ChatDraft;
     /** Messages already taken from the composer that wait, in order, for the current send to be confirmed before they are submitted. */
     readonly outbox: readonly ChatDraft[];
+    /** Sent messages not yet in the server's view, oldest first: drawn at once as the person's messages. */
+    readonly echo: readonly EchoMessage[];
+    /** The steps of each send, for tests and harnesses. Also written as `performance.mark('boring-chat:<step>')`. */
+    readonly timing: ChatTiming;
     readonly history: ChatHistoryState;
     readonly send: ChatSendState;
     readonly stop: 'idle' | 'requested' | 'confirmed' | 'unconfirmed';
     readonly disposed: boolean;
 }
 /** Structural presentation seam. Native controllers retain their concrete IDs, methods and recovery return values. */
-export type ChatSnapshot = Omit<NativeChatSnapshot, 'conversationId' | 'send'> & {
+export type ChatSnapshot = Omit<NativeChatSnapshot, 'conversationId' | 'send' | 'echo' | 'timing'> & {
+    /** Absent from a controller that does not echo sent messages. */
+    readonly echo?: NativeChatSnapshot['echo'];
+    readonly timing?: NativeChatSnapshot['timing'];
     readonly conversationId: NativeChatSnapshot['conversationId'] | string;
     readonly send: ChatSendState | {
         readonly kind: 'idle' | 'submitting' | 'admitted';
@@ -122,7 +157,7 @@ export type ChatSnapshot = Omit<NativeChatSnapshot, 'conversationId' | 'send'> &
         readonly retryable: boolean;
     };
 };
-export type ChatController = Pick<NativeChatController, 'subscribe' | 'setText' | 'setAttachments' | 'clearHistory' | 'loadEarlier' | 'connect' | 'stop' | 'dispose'> & {
+export type ChatController = Partial<Pick<NativeChatController, 'markShown'>> & Pick<NativeChatController, 'subscribe' | 'setText' | 'setAttachments' | 'clearHistory' | 'loadEarlier' | 'connect' | 'stop' | 'dispose'> & {
     readonly getSnapshot: () => ChatSnapshot;
     readonly send: (whenBusy?: ChatAttempt['whenBusy'], input?: ChatSendInput) => Promise<unknown>;
     readonly reconcile: () => Promise<unknown>;
@@ -147,6 +182,8 @@ export interface NativeChatOptions {
 export declare function createNativeChatController(options: NativeChatOptions): {
     conversation: ChatConversation;
     getSnapshot: () => NativeChatSnapshot;
+    /** The chat reports which echoed messages are now on screen (called after the commit that drew them); it stamps `timing`. */
+    markShown: (keys: readonly string[]) => void;
     /** Reads the exact native submission with this controller's Context; observing never aborts or owns its execution. */
     submissionStatus: (submission: Submission) => Promise<SubmissionRecord>;
     subscribe: (listener: () => void) => (() => void);

package/dist/native-chat.js

@@ -20,7 +20,7 @@ export function createNativeChatController(options) {
     if (Object.values(identity).some(value => typeof value !== 'string' || !value))
         throw new TypeError('Explicit runtime, scope and principal identity are required');
     let snapshot = { identity, conversationId: conversation.id, connection: { kind: 'idle' },
-        draft: draft('', [], 0), outbox: Object.freeze([]), history: emptyHistory(), send: { kind: 'idle' }, stop: 'idle', disposed: false };
+        draft: draft('', [], 0), outbox: Object.freeze([]), echo: Object.freeze([]), timing: Object.freeze({ sends: Object.freeze([]) }), history: emptyHistory(), send: { kind: 'idle' }, stop: 'idle', disposed: false };
     const listeners = new Set();
     let watch, opening, disposing;
     const publish = (change) => {
@@ -79,11 +79,101 @@ export function createNativeChatController(options) {
                     item.textObserved = true;
             }
     };
+    let echoSeq = 0;
+    const echoes = [];
+    /** A sent message still not in the view after this long is dropped from the echo (the server may have changed its words); the transcript is the truth. */
+    const ECHO_LIFETIME_MS = 120_000;
+    const now = () => (globalThis.performance?.now?.() ?? Date.now());
+    const textOfContent = (content) => typeof content === 'string' ? content
+        : Array.isArray(content) ? content.flatMap(part => part && typeof part === 'object' && part.type === 'text' && typeof part.text === 'string' ? [part.text] : []).join('\n') : '';
+    /** The texts of the people's messages the view holds: placed ones and those waiting in the inbox. */
+    const userTexts = (view) => {
+        if (!view)
+            return [];
+        const texts = view.entries.flatMap(entry => (entry.model ?? []).flatMap(message => message.role === 'user' ? [textOfContent(message.content)] : []));
+        const items = view.docs['pi.inbox'] && typeof view.docs['pi.inbox'] === 'object' && !Array.isArray(view.docs['pi.inbox']) ? view.docs['pi.inbox']['items'] : undefined;
+        if (Array.isArray(items))
+            for (const item of items)
+                if (item && typeof item === 'object' && !Array.isArray(item))
+                    texts.push(textOfContent(item['content']));
+        return texts;
+    };
+    const countOf = (view, match) => userTexts(view).filter(text => match === '' || text.includes(match)).length;
+    const echoView = () => Object.freeze(echoes.map(item => Object.freeze({ key: item.key, draft: item.draft, sentAt: item.sentAt, state: item.failed ? 'failed' : 'sending' })));
+    /** Applies a change to the echo list and returns the snapshot field for it. */
+    const publishEcho = (change = {}) => publish({ ...change, echo: echoView() });
+    const echoOf = (draft) => echoes.find(item => item.draft === draft);
+    const dropEcho = (drafts) => {
+        let changed = false;
+        for (const item of drafts) {
+            const found = echoOf(item);
+            if (found) {
+                echoes.splice(echoes.indexOf(found), 1);
+                changed = true;
+            }
+        }
+        return changed;
+    };
+    // Timing: one record per send, kept for the last 20, readable from the snapshot and as performance marks.
+    const timings = [];
+    const mark = (step) => {
+        const at = now();
+        try {
+            globalThis.performance?.mark?.(`boring-chat:${step}`);
+        }
+        catch { /* marks are optional */ }
+        return at;
+    };
+    const stamp = (key, step) => {
+        const index = timings.findIndex(item => item.key === key);
+        if (index < 0 || timings[index][step] !== undefined)
+            return;
+        timings[index] = Object.freeze({ ...timings[index], [step]: mark(`${step}:${key}`) });
+    };
+    const publishTiming = (change = {}) => publish({ ...change, timing: Object.freeze({ ...(snapshot.timing.inputReady !== undefined ? { inputReady: snapshot.timing.inputReady } : {}), sends: Object.freeze([...timings]) }) });
+    /** Reads the view for the steps of the sends: the first words of a reply and its end. */
+    const observeTiming = (view) => {
+        const open = timings.filter(item => item.done === undefined && item.enter !== undefined);
+        if (!open.length)
+            return;
+        const live = view.docs['pi.live'], run = live && typeof live === 'object' && !Array.isArray(live) ? live['run'] : undefined;
+        const running = Boolean(run) && typeof run === 'object';
+        const generation = live && typeof live === 'object' && !Array.isArray(live) ? live['generation'] : undefined;
+        const message = generation && typeof generation === 'object' && !Array.isArray(generation) ? generation['message'] : undefined;
+        const streamed = message && typeof message === 'object' && !Array.isArray(message) && hasText([{ role: 'assistant', content: message['content'] }]);
+        const key = open[0].key;
+        const placed = view.entries.slice(firstEntries.get(key) ?? view.entries.length).some(entry => hasText(entry.model));
+        if (streamed || placed)
+            stamp(key, 'firstWords');
+        if (!running && timings.find(item => item.key === key)?.firstWords !== undefined)
+            stamp(key, 'done');
+    };
+    /** How many entries the view held when a message was sent: text after them is the reply. */
+    const firstEntries = new Map();
+    /** Drops the echoes whose message the view now holds (or that waited too long). */
+    const settleEchoes = (view) => {
+        if (!echoes.length)
+            return false;
+        const seen = new Map();
+        const remaining = echoes.filter(item => {
+            if (now() - item.at > ECHO_LIFETIME_MS && item.admitted)
+                return false;
+            const count = seen.get(item.match) ?? countOf(view, item.match);
+            seen.set(item.match, count);
+            return count < item.base + 1;
+        });
+        if (remaining.length === echoes.length)
+            return false;
+        echoes.splice(0, echoes.length, ...remaining);
+        return true;
+    };
     const acceptView = (view) => {
         observeText(view);
         const previous = snapshot.view?.entries;
         const appendOnly = !previous || previous.every((entry, index) => view.entries[index]?.id === entry.id);
-        publish({ view, ...(!appendOnly ? { history: invalidateHistory() } : {}) });
+        const changed = settleEchoes(view);
+        observeTiming(view);
+        publish({ view, ...(!appendOnly ? { history: invalidateHistory() } : {}), ...(changed ? { echo: echoView() } : {}), timing: Object.freeze({ ...(snapshot.timing.inputReady !== undefined ? { inputReady: snapshot.timing.inputReady } : {}), sends: Object.freeze([...timings]) }) });
     };
     const stillPending = (attempt) => (snapshot.send.kind === 'unknown' || snapshot.send.kind === 'submitting') && snapshot.send.attempt.requestId === attempt.requestId;
     const active = () => { if (snapshot.disposed)
@@ -93,7 +183,12 @@ export function createNativeChatController(options) {
     const markAdmitted = (attempt, submissionId, record) => {
         if (snapshot.disposed || !stillPending(attempt))
             return false;
-        publish({ send: { kind: 'admitted', attempt, submissionId, ...(record ? { record } : {}) } });
+        const found = echoOf(attempt.draft);
+        if (found) {
+            found.failed = false;
+            found.admitted = true;
+        }
+        publish({ send: { kind: 'admitted', attempt, submissionId, ...(record ? { record } : {}) }, ...(found ? { echo: echoView() } : {}) });
         return true;
     };
     /** Messages taken from the composer that wait for the current send (`outbox` in the snapshot). */
@@ -111,7 +206,8 @@ export function createNativeChatController(options) {
             item.resolve(undefined);
         if (snapshot.disposed)
             return;
-        putBack([...drafts, ...left.map(item => item.draft)], { ...change, ...(left.length || snapshot.outbox.length ? { outbox: Object.freeze([]) } : {}) });
+        const gone = dropEcho([...drafts, ...left.map(item => item.draft)]);
+        putBack([...drafts, ...left.map(item => item.draft)], { ...change, ...(gone ? { echo: echoView() } : {}), ...(left.length || snapshot.outbox.length ? { outbox: Object.freeze([]) } : {}) });
     };
     function putBack(selected, change = {}) {
         if (snapshot.disposed)
@@ -177,7 +273,10 @@ export function createNativeChatController(options) {
         })();
     }
     async function submitAttempt(attempt) {
-        publish({ send: { kind: 'submitting', attempt }, ...(!stopping && snapshot.stop !== 'idle' ? { stop: 'idle' } : {}) });
+        const retried = echoOf(attempt.draft);
+        if (retried)
+            retried.failed = false;
+        publish({ send: { kind: 'submitting', attempt }, ...(retried ? { echo: echoView() } : {}), ...(!stopping && snapshot.stop !== 'idle' ? { stop: 'idle' } : {}) });
         if (snapshot.disposed)
             return;
         try {
@@ -196,8 +295,12 @@ export function createNativeChatController(options) {
             // Refused: the message goes back into the composer. Unknown: it stays held by the attempt for `reconcile`/`retrySameRequest`.
             if (denied)
                 restore([attempt.draft], { send: { kind: 'blocked', reason: error instanceof Error ? error.message : 'Submission was not admitted' } });
-            else
-                publish({ send: { kind: 'unknown', attempt } });
+            else {
+                const found = echoOf(attempt.draft);
+                if (found)
+                    found.failed = true;
+                publish({ send: { kind: 'unknown', attempt }, ...(found ? { echo: echoView() } : {}) });
+            }
             return undefined;
         }
     }
@@ -228,6 +331,16 @@ export function createNativeChatController(options) {
     const controller = {
         conversation,
         getSnapshot: () => snapshot,
+        /** The chat reports which echoed messages are now on screen (called after the commit that drew them); it stamps `timing`. */
+        markShown: (keys) => {
+            if (snapshot.disposed)
+                return;
+            const before = timings.map(item => item.shown);
+            for (const key of keys)
+                stamp(key, 'shown');
+            if (timings.some((item, index) => item.shown !== before[index]))
+                publishTiming();
+        },
         /** Reads the exact native submission with this controller's Context; observing never aborts or owns its execution. */
         submissionStatus: async (submission) => {
             active();
@@ -331,7 +444,8 @@ export function createNativeChatController(options) {
                         throw new Error('Chat source returned another conversation');
                     }
                     watch = acquired;
-                    publish({ connection: live(), view: acquired.value });
+                    const ready = snapshot.timing.inputReady === undefined;
+                    publish({ connection: live(), view: acquired.value, ...(ready ? { timing: Object.freeze({ inputReady: mark('input-ready'), sends: Object.freeze([...timings]) }) } : {}) });
                     acquired.start(async (view) => {
                         if (snapshot.disposed || watch !== acquired)
                             return;
@@ -376,7 +490,19 @@ export function createNativeChatController(options) {
             }
             if (input?.restore)
                 restoreOf.set(selected, draft(input.restore.text, input.restore.attachments ?? [], 0));
-            const cleared = input ? {} : { draft: draft('', [], current.version + 1) };
+            // The message is the person's from this moment: it is drawn at once (the echo) and the composer is emptied, before any
+            // validation or network call. The server's copy replaces it when it arrives; a refusal puts the words back in the composer.
+            // (A steer takes a queued message back and sends it again, so it is not echoed twice.)
+            if (whenBusy !== 'steer') {
+                const enter = mark('enter');
+                const match = selected.text.trim(), key = `m${++echoSeq}`;
+                echoes.push({ key, draft: selected, match, base: countOf(snapshot.view, match) + echoes.filter(item => item.match === match).length, at: enter, sentAt: Date.now(), failed: false, admitted: false });
+                firstEntries.set(key, snapshot.view?.entries.length ?? 0);
+                timings.push(Object.freeze({ key, enter }));
+                if (timings.length > 20)
+                    firstEntries.delete(timings.shift().key);
+            }
+            const cleared = { ...(input ? {} : { draft: draft('', [], current.version + 1) }), echo: echoView(), timing: Object.freeze({ ...(snapshot.timing.inputReady !== undefined ? { inputReady: snapshot.timing.inputReady } : {}), sends: Object.freeze([...timings]) }) };
             if (sending) {
                 return new Promise(resolve => {
                     waiting.push({ draft: selected, whenBusy, resolve });

package/dist/remote-chat.d.ts

@@ -45,6 +45,12 @@ export interface RemoteChatOptions {
         readonly open?: (url: URL) => WebSocket;
         readonly pingMs?: number;
     };
+    /**
+     * How long the first view of a connection may take before the chat gives up and reports an error (default 18000). Without it a
+     * host that accepts the watch request but never sends a view leaves the page on « Connecting… » for good. Later views are
+     * bounded by the heartbeat.
+     */
+    readonly firstViewTimeoutMs?: number;
     /** Host events the socket carries beside the chat (`broadcast` on the server, for example presence or the conversation list). */
     readonly onEvent?: (event: unknown) => void;
 }

package/dist/remote-chat.js

@@ -99,6 +99,7 @@ export async function createRemoteChat(options) {
                     return;
                 closed = true;
                 clearInterval(timer);
+                clearTimeout(firstView);
                 if (current === socket)
                     current = undefined;
                 notify();
@@ -122,6 +123,14 @@ export async function createRemoteChat(options) {
                 socket.close(1000);
             }
             catch { /* closing */ } finish(); };
+            // A socket that opens but never sends its first view is closed (then HTTP is tried, or the error is reported).
+            const firstView = setTimeout(() => { if (!opened) {
+                try {
+                    socket.close();
+                }
+                catch { /* closing */ }
+                finish();
+            } }, options.firstViewTimeoutMs ?? 18_000);
             socket.onclose = finish;
             socket.onerror = () => { try {
                 socket.close();
@@ -169,6 +178,19 @@ export async function createRemoteChat(options) {
     }
     async function httpSource() {
         const stopped = new AbortController();
+        // The whole wait for the first view (the response, then its first line) is bounded: a host that never answers is an error with retry.
+        const limit = options.firstViewTimeoutMs ?? 18_000;
+        let giveUp;
+        const late = new Promise((_, reject) => { giveUp = setTimeout(() => { stopped.abort(); reject(new WatchRefused('Remote chat watch timed out before its first view', 408)); }, limit); });
+        late.catch(() => { });
+        try {
+            return await Promise.race([openHttp(stopped), late]);
+        }
+        finally {
+            clearTimeout(giveUp);
+        }
+    }
+    async function openHttp(stopped) {
         const response = await send(new Request(url('watch'), { signal: stopped.signal }));
         if (!response.ok || !response.body)
             throw new WatchRefused(`Remote chat watch failed: ${await reason(response)}`, response.status);

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

@@ -3,7 +3,7 @@ export { ChannelRequestError } from './error.js';
 import type { Card, ChannelMessage, ChannelSource, Member, SharedChatState } from './source.js';
 export type * from './source.js';
 export { channelAvatarStates, cardActions } from './source.js';
-export type SharedChatSnapshot = Omit<NativeChatSnapshot, 'conversationId' | 'send' | 'shared'> & {
+export type SharedChatSnapshot = Omit<NativeChatSnapshot, 'conversationId' | 'send' | 'shared' | 'echo' | 'timing'> & {
     readonly conversationId: string;
     readonly shared: SharedChatState;
     readonly send: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hachej/boring-ui-kit",
-  "version": "0.4.46",
+  "version": "0.4.47",
   "license": "MIT",
   "private": false,
   "type": "module",
@@ -147,14 +147,10 @@
     "./mark-store": {
       "types": "./dist/mark-store.d.ts",
       "import": "./dist/mark-store.js"
-    },
-    "./task-board": {
-      "types": "./dist/task-board.d.ts",
-      "import": "./dist/task-board.js"
     }
   },
   "peerDependencies": {
-    "@hachej/boring-files": "^0.4.46",
+    "@hachej/boring-files": "^0.4.47",
     "@earendil-works/pi-durable": "~1.4.0",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",

package/r/agent-target.json

@@ -4,15 +4,15 @@
   "title": "Point and dictate on app data",
   "description": "Tap explicitly marked JSON app context, dictate once and show the same app agent’s native reply without opening chat. Host-controlled presentation; no feedback report or second controller.",
   "dependencies": [
-    "@hachej/boring-ui-kit@^0.4.46",
-    "@hachej/boring-feedback@^0.4.46",
+    "@hachej/boring-ui-kit@^0.4.47",
+    "@hachej/boring-feedback@^0.4.47",
     "@earendil-works/pi-durable@~1.4.0",
     "react@^19.0.0",
     "react-dom@^19.0.0"
   ],
   "registryDependencies": [
-    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.46/r/app-shell.json",
-    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.46/r/pi-chat.json"
+    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.47/r/app-shell.json",
+    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.47/r/pi-chat.json"
   ],
   "files": [
     {