@khorsheed/dsh-local-agent 0.1.0-rc.6

package/lib/types/client/MemberComposer.js

@@ -0,0 +1,308 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Writable composer for family CLI member sessions, elected through the
+ * 'conversation.composer' chain at priority -20 (ui-subagent's read-only
+ * takeover sits at -10; chain election is ascending, first non-null selector
+ * wins). The chain-slot contract requires a selector to be a PURE function of
+ * the owner props, so membership is decided in two stages: the selector coarse-
+ * filters on the session snapshot (one-shot subagent sessions elect), and the
+ * component confirms real family membership through the `memberOf` Remote —
+ * a session the family never delegated renders the same read-only panel the
+ * official composer shows, never a writable box. The verification window is
+ * a NEUTRAL checking state (no read-only semantics), an RPC failure is never
+ * read as "not a member", and a confirmed membership is cached per session so
+ * a re-enter renders the writable box on the first frame. Send goes to the
+ * `promptMember` Remote (the facade resume), never to the official input
+ * machine; Stop goes to `stopMember`.
+ */
+import { requestId } from './request-id.js';
+import { useEffect, useRef, useState } from 'react';
+import { IconChevronDownOutlineMedium } from './icons.js';
+import { memberDockLines } from './member-dock.js';
+import css from './MemberComposer.module.css';
+/**
+ * Pure coarse filter for the composer chain: elect any one-shot subagent
+ * session. Deliberately wide (selector purity allows no async membership
+ * check) — the component degrades to the read-only panel when the delegation
+ * registry has no record for the session.
+ * @param owner - the composer chain currency dispatched by ConversationRoot.
+ * @returns the match carrying the child session id, or null to pass the
+ *   election down the chain.
+ */
+export function selectCliMember(owner) {
+    // Pending interactions (questions/approvals) belong to the official
+    // ApprovalPanel — a chain entry at priority 1. Election runs ascending, so
+    // this -20 entry would shadow it: decline and let the interaction render.
+    // The owner prop moved between host lines: rc carries an `interactions`
+    // array, 0.1.2 a singular `pendingInteraction` — probe both (feature
+    // detection, not a version check).
+    const legacy = owner.interactions;
+    if (legacy !== undefined) {
+        if (legacy.length > 0)
+            return null;
+    }
+    else if (owner.pendingInteraction != null) {
+        return null;
+    }
+    const session = owner.session;
+    const subagent = session?.subagent;
+    if (session === undefined || subagent === undefined || subagent === null)
+        return null;
+    if (subagent.address.mode !== 'one-shot')
+        return null;
+    return { childSessionId: session.sessionId };
+}
+/** RPC-failure retry budget for the membership probe (see the probe effect). */
+const MEMBER_PROBE_RETRIES = 2;
+/** Delay between membership probe retries. */
+const MEMBER_PROBE_RETRY_MS = 300;
+/** In-flight delegation poll cadence (the taskpilot dock's proven cadence). */
+const ACTIVE_DELEGATIONS_POLL_MS = 1_500;
+/** The locale key of each model-source layer's label (the chip's title). */
+const MODEL_SOURCE_KEYS = {
+    'override': 'member.model.source.override',
+    'delegation': 'member.model.source.delegation',
+    'settings': 'member.model.source.settings',
+    'cli-config': 'member.model.source.cli-config',
+    'cli-builtin': 'member.model.source.cli-builtin',
+};
+/**
+ * Session-level positive membership cache: a recorded delegation is immutable
+ * for the session's lifetime, so a confirmed member re-enter renders the
+ * writable box on the first frame instead of re-flashing the checking state.
+ * Null answers (not yet delegated) are never cached — the record lands with
+ * the first round's settle, and the probe effect re-checks on running flips.
+ */
+const membershipCache = new Map();
+/** Test hook: drop every cached membership answer. */
+export function resetMembershipCache() {
+    membershipCache.clear();
+}
+/**
+ * The member composer: a writable box for family member sessions and the
+ * official-looking read-only panel for every other one-shot session. Drafts
+ * stay in local state (the official input machine is deliberately NOT wired —
+ * its send path is hardwired to the host prompt pipeline this channel must
+ * bypass). A run in flight disables the input and swaps Send for Stop — the
+ * running bit is DUAL-SOURCE: the session summary's flag (agent-based; the
+ * dsh member's sub-instance drives it natively) OR the family's in-flight
+ * delegation registry polled through `activeDelegations` (the only source
+ * that lights up for external CLI runs, which have no live host agent).
+ * @param props - selector match, standard slot props, locale seat, and the
+ *   injected gateway face.
+ * @returns the composer, the neutral checking state while probing, or the
+ *   read-only panel when not a member.
+ */
+export function MemberComposer({ matched, useSession, useProjection, memberOf, promptMember, stopMember, activeDelegations, memberModel, setMemberModel, renderMemberConfiguration, renderMemberInbox, t }) {
+    const [membership, setMembership] = useState(() => membershipCache.get(matched.childSessionId));
+    const [draft, setDraft] = useState('');
+    const [sending, setSending] = useState(false);
+    const inputRequest = useRef();
+    /** The last structured promptMember failure, rendered inline. */
+    const [error, setError] = useState(null);
+    const sessionRunning = useSession(snapshot => snapshot.running) ?? false;
+    /** The polled in-flight bit for this child (second running source). */
+    const [memberActive, setMemberActive] = useState(false);
+    /** The member's model surface; undefined = not fetched yet, null = no picker. */
+    const [modelSurface, setModelSurface] = useState(undefined);
+    /** The picker's dropdown open bit. */
+    const [modelMenuOpen, setModelMenuOpen] = useState(false);
+    /** The picker's root node (click-outside closes the dropdown). */
+    const modelPickerRef = useRef(null);
+    /** The child the current membership answer belongs to (re-probes on switch). */
+    const membershipFor = useRef(null);
+    /** Mirror of `membership` for the probe effect (kept out of its deps: a null answer must not self-trigger). */
+    const membershipRef = useRef(undefined);
+    membershipRef.current = membership;
+    // The member dock self-renders ambient state from the projection seat: the
+    // official panels (StatsLine on 'conversation.composer.dock', TodoPanel on
+    // 'conversation.input.dock') live INSIDE the fallback InputBar that
+    // `overlay: true` hides on election, so no official dock row can reach a
+    // member session. One bag entry per projection a contributor reads.
+    const projections = {
+        tokenUsage: useProjection('tokenUsage'),
+        todos: useProjection('todos'),
+    };
+    // Second running source: poll the family's in-flight delegation registry.
+    // The official summary flag never lights up for external CLI runs (no live
+    // host agent), so without this the Stop button and the running badge never
+    // appear and the membership re-probe below never fires in production. An
+    // RPC failure keeps the last known bit instead of flapping Stop off.
+    useEffect(() => {
+        let cancelled = false;
+        const childId = matched.childSessionId;
+        const tick = () => {
+            void activeDelegations().then((ids) => {
+                if (cancelled || ids === undefined)
+                    return;
+                setMemberActive(ids.includes(childId));
+            }, () => { });
+        };
+        tick();
+        const timer = setInterval(tick, ACTIVE_DELEGATIONS_POLL_MS);
+        return () => { cancelled = true; clearInterval(timer); };
+    }, [activeDelegations, matched.childSessionId]);
+    const running = sessionRunning || memberActive;
+    useEffect(() => {
+        const childId = matched.childSessionId;
+        if (membershipFor.current !== childId) {
+            // A different child: seed from the positive cache (a member re-enter
+            // skips the probe entirely) and reset to checking when uncached.
+            membershipFor.current = childId;
+            const cached = membershipCache.get(childId);
+            setMembership(cached);
+            if (cached !== undefined)
+                return;
+        }
+        else if (membershipRef.current !== null && membershipRef.current !== undefined) {
+            return; // already resolved for this child
+        }
+        // A null answer (not yet a member) re-probes on every running flip: the
+        // delegation record lands with the first round's settle (exec) or the
+        // live handshake, exactly when running changes — so an open panel flips
+        // from the one-shot read-only fallback to the writable member box on its
+        // own, without a session re-enter. An UNDEFINED answer is an RPC failure,
+        // never membership evidence: it keeps the neutral checking state and
+        // retries within a bounded budget before degrading to the read-only
+        // panel, so a transient failure never flashes "one-shot" at a member.
+        let cancelled = false;
+        let timer;
+        let attempts = 0;
+        const settle = (view) => {
+            if (cancelled)
+                return;
+            if (view === undefined && attempts < MEMBER_PROBE_RETRIES) {
+                attempts += 1;
+                timer = setTimeout(probe, MEMBER_PROBE_RETRY_MS);
+                return;
+            }
+            const resolved = view === undefined ? null : view;
+            if (resolved !== null)
+                membershipCache.set(childId, resolved);
+            setMembership(resolved);
+        };
+        const probe = () => {
+            // A rejected RPC is the same transient failure as an undefined value.
+            void memberOf(childId).then(settle, () => settle(undefined));
+        };
+        probe();
+        return () => {
+            cancelled = true;
+            if (timer !== undefined)
+                clearTimeout(timer);
+        };
+    }, [memberOf, matched.childSessionId, running]);
+    // The model surface: fetched once membership resolves, and re-fetched on
+    // every running flip — a switch is refused while a round is in flight and a
+    // live runtime respawns on the next round, so run edges are exactly when
+    // `switchable`/`effective` can move. Undefined answers (RPC failure) keep
+    // the last known surface, mirroring the activeDelegations poll's rule.
+    useEffect(() => {
+        if (membership === undefined || membership === null)
+            return;
+        const childId = matched.childSessionId;
+        let cancelled = false;
+        void memberModel(childId).then((info) => {
+            if (cancelled || info === undefined)
+                return;
+            setModelSurface({ child: childId, info });
+        }, () => { });
+        return () => { cancelled = true; };
+    }, [memberModel, matched.childSessionId, membership, running]);
+    // Click-outside closes the model dropdown (the dock capsules' pattern).
+    useEffect(() => {
+        if (!modelMenuOpen)
+            return;
+        const onPointerDown = (event) => {
+            if (modelPickerRef.current?.contains(event.target) === true)
+                return;
+            setModelMenuOpen(false);
+        };
+        document.addEventListener('mousedown', onPointerDown);
+        return () => { document.removeEventListener('mousedown', onPointerDown); };
+    }, [modelMenuOpen]);
+    if (membership === undefined) {
+        return _jsx("div", { className: css.frame, role: "status", children: _jsx("span", { children: t('member.checking') }) });
+    }
+    if (membership === null) {
+        // Not a family member: render the official one-shot read-only panel
+        // (visually aligned with ui-subagent's SubagentReadOnlyComposer), never a
+        // writable box.
+        return (_jsxs("div", { className: css.frame, role: "status", children: [_jsx("strong", { children: t('member.readonly.title') }), _jsx("span", { children: t('member.readonly.body') })] }));
+    }
+    const busy = sending || (running && renderMemberInbox === undefined);
+    const dockLines = memberDockLines(projections, t);
+    /** The chip label: the effective model id when any layer names one (codex's
+        catalog default counts — it names the CLI's own default); otherwise the
+        localized "Default", annotated with the last observed model when the
+        delegation records know what actually ran. */
+    const modelLabel = (info) => info.effective
+        ?? (info.lastObserved === undefined
+            ? t('member.model.default')
+            : t('member.model.defaultLastObserved', { model: info.lastObserved }));
+    // The surface stamped with another child (a session switch mid-fetch) never
+    // flashes its model at this member.
+    const modelInfo = modelSurface !== undefined && modelSurface.child === matched.childSessionId
+        ? modelSurface.info
+        : null;
+    const send = () => {
+        const text = draft.trim();
+        if (text === '' || busy)
+            return;
+        setSending(true);
+        setError(null);
+        if (inputRequest.current?.child !== matched.childSessionId || inputRequest.current.text !== text)
+            inputRequest.current = { child: matched.childSessionId, text, id: requestId() };
+        const submit = renderMemberInbox === undefined ? promptMember(matched.childSessionId, text) : promptMember(matched.childSessionId, text, inputRequest.current.id);
+        void submit.then((result) => {
+            setSending(false);
+            if (result !== undefined && result.ok) {
+                setDraft('');
+                inputRequest.current = undefined;
+            }
+            else {
+                setError(result !== undefined && !result.ok ? result.error : t('member.sendFailed'));
+            }
+        }).catch(() => { setSending(false); setError(t('member.sendFailed')); });
+    };
+    const stop = () => {
+        void stopMember(matched.childSessionId);
+    };
+    /**
+     * Apply a picker choice (undefined = clear the override). The displayed
+     * value only ever moves on an authoritative re-read after `{ ok: true }`,
+     * so a refused switch leaves the chip on the real model — the structured
+     * error rides the same inline line a promptMember failure uses.
+     */
+    const chooseModel = (model) => {
+        setModelMenuOpen(false);
+        setError(null);
+        const childId = matched.childSessionId;
+        void setMemberModel(childId, model).then((result) => {
+            if (result !== undefined && result.ok) {
+                void memberModel(childId).then((info) => {
+                    if (info !== undefined)
+                        setModelSurface({ child: childId, info });
+                }, () => { });
+            }
+            else {
+                setError(result !== undefined && !result.ok ? result.error : t('member.model.failed'));
+            }
+        });
+    };
+    const onChange = (event) => {
+        setDraft(event.target.value);
+    };
+    const onKeyDown = (event) => {
+        // Shift+Enter is the native newline; an IME-composition Enter picks a
+        // candidate and must not send.
+        if (event.key !== 'Enter' || event.shiftKey || event.nativeEvent.isComposing)
+            return;
+        event.preventDefault();
+        if (!event.repeat)
+            send(); // held-down Enter must not machine-gun sends
+    };
+    return (_jsxs("div", { className: css.root, children: [error !== null && _jsx("div", { className: css.error, role: "alert", children: error }), renderMemberInbox?.(matched.childSessionId), _jsxs("div", { className: css.card, children: [_jsxs("div", { className: css.header, children: [_jsx("span", { children: t('member.title', { harness: membership.harnessDisplayName ?? membership.provider }) }), running && _jsx("span", { className: css.running, children: t('member.running') })] }), _jsx("textarea", { className: css.input, value: draft, rows: 2, disabled: busy, placeholder: t('member.placeholder'), onChange: onChange, onKeyDown: onKeyDown }), _jsxs("div", { className: css.row, children: [renderMemberConfiguration !== undefined ? renderMemberConfiguration(matched.childSessionId) : modelInfo !== null && (_jsxs("div", { className: css.modelPicker, ref: modelPickerRef, children: [_jsxs("button", { type: "button", className: css.modelChip, disabled: busy || !modelInfo.switchable, title: !modelInfo.switchable && modelInfo.reason !== undefined
+                                            ? modelInfo.reason
+                                            : t('member.model.title', { model: modelLabel(modelInfo), source: t(MODEL_SOURCE_KEYS[modelInfo.source]) }), "aria-label": t('member.model.picker'), "aria-haspopup": "menu", "aria-expanded": modelMenuOpen, onClick: () => { setModelMenuOpen(open => !open); }, children: [_jsx("span", { className: css.modelChipLabel, children: modelLabel(modelInfo) }), _jsx(IconChevronDownOutlineMedium, { className: modelMenuOpen ? css.chevronOpen : css.chevron })] }), modelMenuOpen && (_jsx("div", { className: css.modelMenu, role: "menu", "aria-label": t('member.model.picker'), children: modelInfo.choices.length === 0 && modelInfo.override === undefined ? (_jsx("span", { className: css.modelItemHint, role: "menuitem", "aria-disabled": "true", children: t('member.model.empty') })) : (_jsxs(_Fragment, { children: [modelInfo.choices.map(choice => (_jsxs("button", { type: "button", role: "menuitemradio", "aria-checked": choice === modelInfo.effective, className: choice === modelInfo.effective ? css.modelItemCurrent : css.modelItem, onClick: () => { chooseModel(choice); }, children: [_jsx("span", { className: css.modelItemLabel, children: choice }), _jsx("span", { className: css.modelItemCheck, "aria-hidden": true, children: choice === modelInfo.effective ? '✓' : '' })] }, choice))), modelInfo.override !== undefined && (_jsx("button", { type: "button", role: "menuitem", className: css.modelItemReset, onClick: () => { chooseModel(undefined); }, children: t('member.model.followSettings') }))] })) }))] })), running && (_jsx("button", { type: "button", className: css.primary, "aria-label": t('member.stop'), onClick: stop, children: _jsx("svg", { viewBox: "0 0 16 16", width: "16", height: "16", "aria-hidden": true, children: _jsx("rect", { x: "3", y: "3", width: "10", height: "10", rx: "3", fill: "currentColor" }) }) })), (!running || renderMemberInbox !== undefined) && (_jsx("button", { type: "button", className: css.primary, "aria-label": t('member.send'), disabled: draft.trim() === '' || busy, onClick: send, children: _jsx("svg", { viewBox: "0 0 16 16", width: "16", height: "16", "aria-hidden": true, children: _jsx("path", { d: "M8.3125 0.980183C8.66767 1.0531 8.97902 1.20418 9.2627 1.43233C9.48724 1.61297 9.73029 1.85793 9.97949 2.10714L14.707 6.83468L13.293 8.24874L9 3.95577V15.0417H7V3.95577L2.70703 8.24874L1.29297 6.83468L6.02051 2.10714C6.26971 1.85793 6.51277 1.61297 6.7373 1.43233C6.97662 1.23986 7.28445 1.04402 7.6875 0.980183C7.8973 0.947006 8.1031 0.95516 8.3125 0.980183Z", fill: "currentColor" }) }) }))] })] }), dockLines.length > 0 && (_jsx("div", { className: css.dock, "data-member-dock": true, children: dockLines.map(line => (_jsx("div", { className: css.dockRow, "data-member-stats": line.id === 'stats' ? '' : undefined, "data-member-dock-row": line.id, children: line.text }, line.id))) }))] }));
+}

package/lib/types/client/MemberConfiguration.d.ts

@@ -0,0 +1,9 @@
+import type { MemberConfigurationStore } from './member-configuration.ts';
+import { type ConfigurationTranslate } from './ModelConfigurationFields.tsx';
+import type { LivePaintDiagnostics } from './live-paint.ts';
+export declare function MemberConfiguration({ store, t, diagnostics }: {
+    store: MemberConfigurationStore;
+    t: ConfigurationTranslate;
+    diagnostics?: LivePaintDiagnostics;
+}): import("react").JSX.Element;
+//# sourceMappingURL=MemberConfiguration.d.ts.map

package/lib/types/client/MemberConfiguration.js

@@ -0,0 +1,46 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { requestId } from './request-id.js';
+import { useState, useSyncExternalStore } from 'react';
+import { ModelConfigurationFields } from './ModelConfigurationFields.js';
+import css from './MemberConfiguration.module.css';
+import { MemberPaintDiagnostics } from './MemberPaintDiagnostics.js';
+import { useConfigurationMenu } from './use-configuration-menu.js';
+export function MemberConfiguration({ store, t, diagnostics }) {
+    const snapshot = useSyncExternalStore(store.subscribe, store.getSnapshot);
+    const menu = useConfigurationMenu('above');
+    const [busy, setBusy] = useState(false);
+    const [error, setError] = useState();
+    const state = snapshot.state;
+    const current = state?.round?.configuration ?? state?.current;
+    const selection = state?.pending?.selection ?? state?.operation?.selection ?? state?.current.selection;
+    const label = (selection, model = current?.resolved.model, effort = current?.resolved.effort) => {
+        const value = selection?.model.mode === 'value' ? selection.model.value : model;
+        const entry = snapshot.directory?.entries.find(entry => entry.value === value || entry.resolvedModel === value);
+        const strength = selection?.effort.mode === 'value' ? selection.effort.value : effort;
+        return [entry?.label ?? value ?? t('loading'), entry?.reasoning?.options.find(option => option.value === strength)?.label ?? strength].filter(Boolean).join(' · ');
+    };
+    const currentLabel = label(current?.selection);
+    const disabled = busy || !snapshot.connected || state?.lockedReason !== undefined;
+    const act = async (operation, next) => {
+        if (!state || disabled)
+            return;
+        setBusy(true);
+        setError(undefined);
+        try {
+            const request = requestId();
+            const receipt = operation === 'retry' ? (await store.face.retry(store.id, state.revision), undefined)
+                : operation === 'cancel' ? await store.face.cancel(store.id, request, state.revision)
+                    : await store.face.select(store.id, request, state.revision, next);
+            if (receipt && ['failed', 'conflict', 'locked', 'unsupported'].includes(receipt.status))
+                setError(receipt.error ?? t('configuration.failed'));
+            await store.refresh();
+        }
+        catch (error) {
+            setError(error instanceof Error ? error.message : String(error));
+        }
+        finally {
+            setBusy(false);
+        }
+    };
+    return _jsxs("details", { className: css.root, ref: menu.root, open: menu.open, onToggle: event => menu.setOpen(event.currentTarget.open), children: [_jsx("summary", { "aria-label": t('configuration.title'), "aria-expanded": menu.open, children: _jsxs("span", { className: css.triggerLabel, children: [currentLabel, state?.pending || state?.operation ? ` · ${t('configuration.pending')}` : ''] }) }), diagnostics && _jsx(MemberPaintDiagnostics, { sessionId: store.id, diagnostics: diagnostics }), _jsxs("div", { ref: menu.panel, className: css.panel, style: menu.style, children: [selection && _jsx(ModelConfigurationFields, { directory: snapshot.directory, value: selection, resolvedModel: state?.current.resolved.model, resolvedEffort: state?.current.resolved.effort, disabled: disabled, t: t, onChange: selection => { void act('select', selection); } }), state?.pending && _jsxs("div", { role: "status", children: [t('configuration.pending'), ": ", label(state.pending.selection)] }), state?.operation && _jsxs("div", { role: "status", children: [t('configuration.applying'), ": ", label(state.operation.selection)] }), state?.round && _jsx("small", { children: t('configuration.boundary') }), !snapshot.connected && _jsx("div", { role: "status", children: t('configuration.reconnecting') }), (error ?? state?.error ?? snapshot.error) && _jsx("div", { role: "alert", children: error ?? state?.error ?? snapshot.error }), state?.lockedReason && _jsx("div", { role: "status", children: state.lockedReason }), (state?.pending || state?.operation || state?.status === 'failed') && _jsxs("div", { className: css.actions, children: [(state?.pending || state?.operation) && _jsx("button", { type: "button", disabled: disabled, onClick: () => { void act('cancel'); }, children: t('configuration.cancel') }), state?.status === 'failed' && _jsx("button", { type: "button", disabled: disabled, onClick: () => { void act('retry'); }, children: t('configuration.retry') })] })] })] });
+}

package/lib/types/client/MemberInboxView.d.ts

@@ -0,0 +1,12 @@
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import type { LocalAgentMemberInbox, LocalAgentPromptResult } from '../types.ts';
+import type { NS } from './locales.ts';
+export interface MemberInboxFace {
+    read(): Promise<LocalAgentMemberInbox | undefined>;
+    control(action: 'pause' | 'resume' | 'cancel' | 'reconcile', requestId?: string, outcome?: 'done' | 'cancelled', evidence?: string): Promise<LocalAgentPromptResult | undefined>;
+}
+/** Core owns admission; the dock displays only inputs still waiting for it. */
+export declare function MemberInboxView({ face, t }: {
+    face: MemberInboxFace;
+} & PropsLocale<typeof NS>): import("react").JSX.Element | null;
+//# sourceMappingURL=MemberInboxView.d.ts.map

package/lib/types/client/MemberInboxView.js

@@ -0,0 +1,38 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useId, useState } from 'react';
+import { IconChevronDownOutlineMedium, IconChevronUpOutlineMedium, IconQueueOutlineMedium, IconTrashOutlineMedium } from './icons.js';
+import css from './MemberInboxView.module.css';
+/** Core owns admission; the dock displays only inputs still waiting for it. */
+export function MemberInboxView({ face, t }) {
+    const [state, setState] = useState();
+    const [error, setError] = useState();
+    const [evidence, setEvidence] = useState('');
+    const [expanded, setExpanded] = useState(false);
+    const listId = useId();
+    useEffect(() => {
+        let closed = false;
+        const refresh = () => { void face.read().then(value => { if (!closed && value !== undefined)
+            setState(value); }, () => { }); };
+        refresh();
+        const timer = setInterval(refresh, 750);
+        return () => { closed = true; clearInterval(timer); };
+    }, [face]);
+    if (state === undefined)
+        return null;
+    const queued = state.messages.filter(row => row.status === 'queued');
+    const recovery = state.messages.filter(row => row.status === 'uncertain' || row.status === 'failed').slice(-8);
+    if (queued.length === 0 && recovery.length === 0 && !state.paused && error === undefined && state.error === undefined)
+        return null;
+    const control = (action, requestId, outcome) => {
+        setError(undefined);
+        void face.control(action, requestId, outcome, evidence).then(async (result) => {
+            if (result?.ok !== true)
+                setError(result?.error ?? t('member.sendFailed'));
+            const next = await face.read();
+            if (next !== undefined)
+                setState(next);
+        }).catch(failure => setError(String(failure)));
+    };
+    const pause = _jsx("button", { className: css.action, type: "button", onClick: () => control(state.paused ? 'resume' : 'pause'), children: t(state.paused ? 'inbox.resume' : 'inbox.pause') });
+    return _jsx("section", { className: css.root, "aria-label": t('inbox.title'), children: _jsxs("div", { className: css.panel, children: [queued.length > 1 && _jsxs("div", { className: css.header, children: [_jsxs("button", { className: css.toggle, type: "button", "aria-expanded": expanded, "aria-controls": listId, onClick: () => setExpanded(value => !value), children: [_jsx(IconQueueOutlineMedium, {}), _jsxs("span", { children: [t('inbox.title'), " \u00B7 ", queued.length] }), expanded ? _jsx(IconChevronUpOutlineMedium, {}) : _jsx(IconChevronDownOutlineMedium, {})] }), pause] }), (queued.length === 1 || expanded) && queued.length > 0 && _jsx("ul", { className: css.list, id: listId, children: queued.map(row => _jsxs("li", { className: css.row, children: [_jsx("span", { className: css.lead, "aria-label": t('inbox.status.queued'), children: _jsx(IconQueueOutlineMedium, {}) }), _jsx("span", { className: css.preview, title: row.text, children: row.text }), queued.length === 1 && pause, _jsx("button", { className: css.iconAction, type: "button", "aria-label": t('inbox.cancel'), title: t('inbox.cancel'), onClick: () => control('cancel', row.id), children: _jsx(IconTrashOutlineMedium, {}) })] }, row.id)) }), state.paused && _jsxs("div", { className: css.notice, children: [_jsx("span", { children: t('inbox.paused') }), queued.length === 0 && pause] }), (error ?? state.error) !== undefined && _jsx("p", { className: css.notice, role: "alert", children: error ?? state.error }), recovery.map(row => _jsxs("div", { className: css.recovery, children: [_jsxs("span", { children: [t(`inbox.status.${row.status}`), " \u00B7 ", row.text.slice(0, 160)] }), row.error !== undefined && _jsx("p", { children: row.error }), row.status === 'uncertain' && _jsxs("div", { className: css.reconcile, children: [_jsx("input", { value: evidence, "aria-label": t('inbox.evidence'), placeholder: t('inbox.evidence'), onChange: event => setEvidence(event.target.value) }), _jsx("button", { className: css.action, type: "button", disabled: evidence.trim() === '', onClick: () => control('reconcile', row.id, 'done'), children: t('inbox.confirmDone') }), _jsx("button", { className: css.action, type: "button", disabled: evidence.trim() === '', onClick: () => control('reconcile', row.id, 'cancelled'), children: t('inbox.confirmCancelled') })] })] }, row.id))] }) });
+}

package/lib/types/client/MemberLiveNode.d.ts

@@ -0,0 +1,14 @@
+import type { PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+import type { MemberLiveOutputs } from './live-output.ts';
+import { NS } from './locales.ts';
+export type MemberLiveNodeProps = PropsRuntime<'conversation.chat.node', 'local-agent-stream'> & PropsLocale<typeof NS> & {
+    outputs: MemberLiveOutputs;
+};
+export declare function MemberLiveNode({ node, outputs, t }: MemberLiveNodeProps): import("react").JSX.Element;
+/** Same subscription in Room: run boundary excludes retained output from earlier turns. */
+export declare function MemberLiveOutputView({ sessionId, startedAt, outputs, t }: {
+    sessionId: string;
+    startedAt: number;
+    outputs: MemberLiveOutputs;
+} & PropsLocale<typeof NS>): import("react").JSX.Element;
+//# sourceMappingURL=MemberLiveNode.d.ts.map

package/lib/types/client/MemberLiveNode.js

@@ -0,0 +1,74 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/** Generation-time text rendered through the public Markdown component. */
+import { useEffect, useLayoutEffect, useRef, useSyncExternalStore } from 'react';
+import { MarkdownText } from '@deepseek-ai/dsh-client-ui-primitives';
+export function MemberLiveNode({ node, outputs, t }) {
+    const data = node.data;
+    const store = outputs.get(data.sessionId);
+    const snapshot = useSyncExternalStore(store.subscribe, store.getSnapshot);
+    const live = snapshot.items.get(data.id);
+    const text = live?.text ?? data.text;
+    return _jsx(StreamText, { id: data.id, kind: live?.kind ?? data.kind, text: text, receivedAt: live?.receivedAt, sessionId: data.sessionId, turn: live?.turn ?? data.turn, revision: live?.revision, baseline: live?.baseline ?? true, surface: "member", diagnostics: outputs.diagnostics, recovering: live === undefined || !snapshot.connected, t: t });
+}
+/** Same subscription in Room: run boundary excludes retained output from earlier turns. */
+export function MemberLiveOutputView({ sessionId, startedAt, outputs, t }) {
+    const store = outputs.get(sessionId);
+    const snapshot = useSyncExternalStore(store.subscribe, store.getSnapshot);
+    return _jsx("div", { "data-member-output": sessionId, children: [...snapshot.items.values()].filter(item => item.receivedAt >= startedAt).map(item => (_jsx(StreamText, { ...item, sessionId: sessionId, surface: "room", diagnostics: outputs.diagnostics, recovering: !snapshot.connected, t: t }, item.id))) });
+}
+/** Local diagnostics only. Two animation frames bound a foreground paint from above.
+ * The wall-clock subtraction is meaningful only when browser and host share a clock.
+ * Keep independent callbacks across updates so slow paints cannot disappear from P95.
+ */
+function StreamText({ id, kind, text, receivedAt, recovering, sessionId, turn, revision, baseline, surface, diagnostics, t }) {
+    const element = useRef(null);
+    const samples = useRef([]);
+    const frames = useRef(new Set());
+    const unfinished = useRef(new Set());
+    useEffect(() => () => {
+        for (const frame of frames.current)
+            cancelAnimationFrame(frame);
+        frames.current.clear();
+        for (const complete of unfinished.current)
+            complete('unmounted', Date.now());
+        unfinished.current.clear();
+    }, []);
+    useLayoutEffect(() => {
+        if (receivedAt === undefined || revision === undefined || baseline)
+            return;
+        const complete = diagnostics.begin(sessionId, turn, revision, surface);
+        if (complete === undefined)
+            return;
+        if (document.visibilityState !== 'visible') {
+            complete('hidden', Date.now());
+            return;
+        }
+        unfinished.current.add(complete);
+        const first = requestAnimationFrame(() => {
+            frames.current.delete(first);
+            const second = requestAnimationFrame(() => {
+                frames.current.delete(second);
+                unfinished.current.delete(complete);
+                if (element.current === null) {
+                    complete('unmounted', Date.now());
+                    return;
+                }
+                if (document.visibilityState !== 'visible') {
+                    complete('hidden', Date.now());
+                    return;
+                }
+                complete('painted', Date.now());
+                const elapsed = Date.now() - receivedAt;
+                if (elapsed < 0)
+                    return; // Different clocks cannot establish a latency claim.
+                samples.current.push(elapsed);
+                if (samples.current.length > 256)
+                    samples.current.shift();
+                element.current.dataset.livePaintSamples = JSON.stringify(samples.current);
+            });
+            frames.current.add(second);
+        });
+        frames.current.add(first);
+    }, [receivedAt, revision, baseline, diagnostics, sessionId, turn, surface]);
+    return _jsxs("section", { ref: element, "data-member-live": id, "data-live-received-at": receivedAt, children: [_jsxs("small", { children: [kind === 'think' ? t('stream.thinking') : t('stream.writing'), recovering ? ` · ${t('stream.recovering')}` : ''] }), _jsx(MarkdownText, { text: text, labels: { code: { copyLabel: t('stream.copy'), copiedLabel: t('stream.copied') }, footnotes: t('stream.footnotes') } })] });
+}

package/lib/types/client/MemberPaintDiagnostics.d.ts

@@ -0,0 +1,7 @@
+import type { LivePaintDiagnostics } from './live-paint.ts';
+/** Read-only DOM probe retained in the composer after transient output settles. */
+export declare function MemberPaintDiagnostics({ diagnostics, sessionId }: {
+    diagnostics: LivePaintDiagnostics;
+    sessionId: string;
+}): import("react").JSX.Element;
+//# sourceMappingURL=MemberPaintDiagnostics.d.ts.map

package/lib/types/client/MemberPaintDiagnostics.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useLayoutEffect, useRef } from 'react';
+/** Read-only DOM probe retained in the composer after transient output settles. */
+export function MemberPaintDiagnostics({ diagnostics, sessionId }) {
+    const element = useRef(null);
+    useLayoutEffect(() => {
+        let timer;
+        const update = () => {
+            timer = undefined;
+            if (element.current)
+                element.current.dataset.livePaintReport = JSON.stringify(diagnostics.report(sessionId));
+        };
+        update();
+        // Exporting a long round must not serialize its samples on every token.
+        const unsubscribe = diagnostics.subscribe(() => { timer ??= setTimeout(update, 250); });
+        return () => { unsubscribe(); if (timer !== undefined)
+            clearTimeout(timer); };
+    }, [diagnostics, sessionId]);
+    return _jsx("span", { hidden: true, ref: element, "data-member-paint-diagnostics": sessionId });
+}

package/lib/types/client/ModelConfigurationFields.d.ts

@@ -0,0 +1,15 @@
+import type { LocalAgentMemberConfiguration, LocalAgentModelDirectory } from '../types.ts';
+import type { LocalAgentKey } from './locales.ts';
+export type ConfigurationTranslate = (key: LocalAgentKey) => string;
+/** User choices are concrete; legacy inheritance stays a backend compatibility concern. */
+export declare function ModelConfigurationFields({ directory, value, onChange, resolvedModel, resolvedEffort, disabled, showEffort, t }: {
+    directory?: LocalAgentModelDirectory | undefined;
+    value: LocalAgentMemberConfiguration;
+    onChange(value: LocalAgentMemberConfiguration): void;
+    resolvedModel?: string | undefined;
+    resolvedEffort?: string | undefined;
+    disabled?: boolean | undefined;
+    showEffort?: boolean | undefined;
+    t: ConfigurationTranslate;
+}): import("react").JSX.Element;
+//# sourceMappingURL=ModelConfigurationFields.d.ts.map

package/lib/types/client/ModelConfigurationFields.js

@@ -0,0 +1,23 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import css from './MemberConfiguration.module.css';
+/** User choices are concrete; legacy inheritance stays a backend compatibility concern. */
+export function ModelConfigurationFields({ directory, value, onChange, resolvedModel, resolvedEffort, disabled, showEffort = true, t }) {
+    const [search, setSearch] = useState('');
+    const [pane, setPane] = useState(showEffort ? 'root' : 'model');
+    const entries = directory?.entries ?? [];
+    const model = value.model.mode === 'value' ? value.model.value : resolvedModel ?? entries.find(entry => !entry.hidden)?.value;
+    const entry = entries.find(entry => entry.value === model || entry.resolvedModel === model);
+    const options = entry?.reasoning?.options ?? [];
+    const effort = value.effort.mode === 'value' ? value.effort.value : resolvedEffort ?? entry?.reasoning?.default ?? options[0]?.value;
+    const query = search.trim().toLowerCase();
+    const candidates = entries.filter(entry => !query || `${entry.label} ${entry.value} ${entry.resolvedModel ?? ''}`.toLowerCase().includes(query));
+    const selectModel = (next) => {
+        const reasoning = entries.find(entry => entry.value === next)?.reasoning;
+        const nextEffort = next === model || reasoning?.options.some(option => option.value === effort) ? effort : reasoning?.default ?? reasoning?.options[0]?.value;
+        onChange({ model: { mode: 'value', value: next }, effort: nextEffort === undefined ? { mode: 'default' } : { mode: 'value', value: nextEffort } });
+        setPane(showEffort ? 'root' : 'model');
+    };
+    return _jsxs("fieldset", { className: css.fields, disabled: disabled, children: [pane === 'root' ? _jsxs(_Fragment, { children: [_jsxs("button", { type: "button", className: css.menuRow, onClick: () => setPane('model'), children: [_jsx("span", { children: t('configuration.model') }), ' ', _jsxs("span", { children: [entry?.label ?? model ?? t('loading'), " \u203A"] })] }), _jsxs("button", { type: "button", className: css.menuRow, disabled: options.length === 0, onClick: () => setPane('effort'), children: [_jsx("span", { children: t('configuration.effort') }), ' ', _jsxs("span", { children: [options.find(option => option.value === effort)?.label ?? effort ?? t('configuration.unavailable'), options.length ? ' ›' : ''] })] }), options.length === 0 && _jsx("small", { role: "status", children: t('configuration.effortUnknown') })] }) : _jsxs(_Fragment, { children: [showEffort && _jsxs("button", { type: "button", className: css.back, onClick: () => setPane('root'), children: ["\u2039 ", t('configuration.back')] }), pane === 'model' ? _jsxs(_Fragment, { children: [_jsx("input", { "aria-label": t('configuration.search'), placeholder: t('configuration.search'), value: search, onChange: event => setSearch(event.target.value) }), _jsxs("div", { className: css.candidates, role: "listbox", "aria-label": t('configuration.model'), children: [candidates.map(candidate => _jsxs("button", { type: "button", role: "option", "aria-selected": candidate.value === model, onClick: () => selectModel(candidate.value), children: [_jsxs("span", { className: css.optionLabel, children: [_jsx("strong", { children: candidate.label }), candidate.value === model && _jsx("span", { "aria-hidden": "true", className: css.check, children: "\u2713" })] }), _jsxs("small", { children: [candidate.value, candidate.resolvedModel ? ` → ${candidate.resolvedModel}` : ''] })] }, candidate.value)), candidates.length === 0 && _jsx("span", { children: t('configuration.empty') })] })] }) : _jsx("div", { className: css.candidates, role: "listbox", "aria-label": t('configuration.effort'), children: options.map(option => _jsxs("button", { type: "button", role: "option", "aria-selected": option.value === effort, onClick: () => { if (model)
+                                onChange({ model: { mode: 'value', value: model }, effort: { mode: 'value', value: option.value } }); setPane('root'); }, children: [_jsxs("span", { className: css.optionLabel, children: [_jsx("strong", { children: option.label }), option.value === effort && _jsx("span", { "aria-hidden": "true", className: css.check, children: "\u2713" })] }), option.description && _jsx("small", { children: option.description })] }, option.value)) })] }), directory && directory.status !== 'ready' && _jsx("small", { role: "status", children: t(`configuration.directory.${directory.status}`) })] });
+}