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

package/lib/types/cli-version.d.ts

@@ -0,0 +1,82 @@
+/**
+ * The family's CLI version probe: one bounded `<cli> --version` spawn whose
+ * answer is cached against the executable's own identity (resolved path +
+ * mtime + size), so a status surface can report `cliVersion` without paying a
+ * spawn per call and without ever reporting a stale version across an upgrade.
+ *
+ * The probe exists because `cliVersion` is a condition-hash input for the
+ * evaluation (`LocalAgentEffectiveSettings`), and the CLI's self-reported
+ * version is the only value a harness can state honestly: the scoped config
+ * never names it, and a package-manifest read would name whatever the host
+ * happens to resolve, not the binary a delegation round actually spawns.
+ *
+ * Degrade, never explode: an unresolvable executable, a non-zero exit, a
+ * timeout, or output with no version-shaped token all resolve `undefined` —
+ * the absent field is the honest condition input, exactly as
+ * `LocalAgentEffectiveSettings` specifies for a knob a harness cannot read.
+ * @module @khorsheed/dsh-local-agent/cli-version
+ */
+import type { SubprocessHandle, SubprocessSpawnSpec } from '@deepseek-ai/dsh-subprocess';
+/** How long one `--version` probe may run before it is terminated. */
+export declare const CLI_VERSION_PROBE_TIMEOUT_MS = 5000;
+/**
+ * How long a FAILED probe is remembered. A success is cached against the
+ * executable's identity and never expires (a new binary is a new key), but a
+ * failure may be transient (a machine under load hitting the timeout), so it
+ * expires instead of poisoning the field until the next CLI upgrade.
+ */
+export declare const CLI_VERSION_FAILURE_TTL_MS = 60000;
+/**
+ * The version token inside a `--version` banner.
+ * @param output - the probe's collected output.
+ * @returns the first version-shaped token, or undefined when there is none.
+ */
+export declare function parseCliVersion(output: string): string | undefined;
+/** One `<cli> --version` probe request. */
+export interface CliVersionProbe {
+    /**
+     * The probe argv. `argv[0]` is the executable (resolved against `PATH` when
+     * it carries no separator); the rest are the version flags, plus — for a
+     * launcher-style argv such as the sub-dsh's `node … bin.js --version` — the
+     * entry script, which is what actually carries the version.
+     */
+    readonly argv: readonly string[];
+    /** Working directory for the probe; the harness's scoped home is always safe. */
+    readonly cwd: string;
+    /** The shared subprocess seam (`ctx.subprocess.spawn`). */
+    readonly spawn: (spec: SubprocessSpawnSpec) => SubprocessHandle;
+    /**
+     * Explicit environment layer, normally `delegationEnv({ <HOME_VAR>: homeDir })`
+     * so the probe reads the SCOPED home like a delegation round would, never
+     * the user's own installation.
+     */
+    readonly env?: NodeJS.ProcessEnv | undefined;
+    /** Probe deadline; defaults to {@link CLI_VERSION_PROBE_TIMEOUT_MS}. */
+    readonly timeoutMs?: number | undefined;
+}
+/**
+ * Forget every cached probe. Exists for tests (whose stub executables and stub
+ * spawns must not inherit another test's answer) and for a caller that must
+ * force a re-probe; ordinary callers never need it, because a CLI upgrade
+ * changes the cache key by itself.
+ */
+export declare function clearCliVersionCache(): void;
+/**
+ * The cache key: the identity of every argv entry that names an existing file
+ * — the executable, plus a launcher argv's entry script. An upgrade rewrites
+ * one of those files, which changes the key, which re-probes. An executable
+ * that resolves to nothing keys on the raw argv instead, so a CLI that is not
+ * installed is not probed once per status call either.
+ */
+export declare function cliExecutableIdentity(argv: readonly string[]): string;
+/**
+ * The CLI's own version, probed at most once per executable identity.
+ * Concurrent callers share one in-flight probe; a success is remembered until
+ * the binary changes; a failure is remembered for
+ * {@link CLI_VERSION_FAILURE_TTL_MS} so a transient miss recovers without
+ * spawning per status call.
+ * @param probe - the probe request.
+ * @returns the version, or undefined when the CLI cannot be asked.
+ */
+export declare function probeCliVersion(probe: CliVersionProbe): Promise<string | undefined>;
+//# sourceMappingURL=cli-version.d.ts.map

package/lib/types/cli-version.js

@@ -0,0 +1,165 @@
+/**
+ * The family's CLI version probe: one bounded `<cli> --version` spawn whose
+ * answer is cached against the executable's own identity (resolved path +
+ * mtime + size), so a status surface can report `cliVersion` without paying a
+ * spawn per call and without ever reporting a stale version across an upgrade.
+ *
+ * The probe exists because `cliVersion` is a condition-hash input for the
+ * evaluation (`LocalAgentEffectiveSettings`), and the CLI's self-reported
+ * version is the only value a harness can state honestly: the scoped config
+ * never names it, and a package-manifest read would name whatever the host
+ * happens to resolve, not the binary a delegation round actually spawns.
+ *
+ * Degrade, never explode: an unresolvable executable, a non-zero exit, a
+ * timeout, or output with no version-shaped token all resolve `undefined` —
+ * the absent field is the honest condition input, exactly as
+ * `LocalAgentEffectiveSettings` specifies for a knob a harness cannot read.
+ * @module @khorsheed/dsh-local-agent/cli-version
+ */
+import { statSync } from 'node:fs';
+import { delimiter, isAbsolute, join, resolve } from 'node:path';
+/** How long one `--version` probe may run before it is terminated. */
+export const CLI_VERSION_PROBE_TIMEOUT_MS = 5_000;
+/**
+ * How long a FAILED probe is remembered. A success is cached against the
+ * executable's identity and never expires (a new binary is a new key), but a
+ * failure may be transient (a machine under load hitting the timeout), so it
+ * expires instead of poisoning the field until the next CLI upgrade.
+ */
+export const CLI_VERSION_FAILURE_TTL_MS = 60_000;
+/** SIGTERM to SIGKILL grace for a probe that ignores the timeout's terminate. */
+const PROBE_GRACE_MS = 2_000;
+/** In-memory cap per collected probe stream; a version banner is a few bytes. */
+const PROBE_OUTPUT_MAX_BYTES = 4 * 1024;
+/**
+ * A version-shaped token: `1.2.3` with an optional prerelease/build tail.
+ * Every family CLI prints one inside a banner of its own shape — codex
+ * `codex-cli 0.144.0`, claude `2.1.263 (Claude Code)`, kimi a bare `0.39.1`,
+ * dsh `0.1.1-rc.2` — so the token, not the banner, is what this parses.
+ */
+const VERSION_TOKEN = /\d+\.\d+\.\d+(?:[-+][0-9A-Za-z][0-9A-Za-z.-]*)?/;
+/**
+ * The version token inside a `--version` banner.
+ * @param output - the probe's collected output.
+ * @returns the first version-shaped token, or undefined when there is none.
+ */
+export function parseCliVersion(output) {
+    return VERSION_TOKEN.exec(output)?.[0];
+}
+const cache = new Map();
+/**
+ * Forget every cached probe. Exists for tests (whose stub executables and stub
+ * spawns must not inherit another test's answer) and for a caller that must
+ * force a re-probe; ordinary callers never need it, because a CLI upgrade
+ * changes the cache key by itself.
+ */
+export function clearCliVersionCache() {
+    cache.clear();
+}
+/** `path:mtimeMs:size` for an existing file, undefined when it is not one. */
+function stampFile(path) {
+    try {
+        const stats = statSync(path);
+        return stats.isFile() ? `${path}:${stats.mtimeMs}:${stats.size}` : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Whether an argv entry names a path rather than a bare command or a flag. */
+function looksLikePath(entry) {
+    return entry.includes('/') || (process.platform === 'win32' && entry.includes('\\'));
+}
+/**
+ * Resolve `argv[0]` to a real file: used as-is when it names a path,
+ * otherwise searched along `PATH` (with `PATHEXT` on Windows) exactly as the
+ * spawn seam will resolve it.
+ */
+function resolveExecutable(command) {
+    if (command === '')
+        return undefined;
+    if (looksLikePath(command))
+        return stampFile(isAbsolute(command) ? command : resolve(command));
+    const extensions = process.platform === 'win32'
+        ? (process.env['PATHEXT'] ?? '.EXE;.CMD;.BAT').split(';')
+        : [''];
+    for (const dir of (process.env['PATH'] ?? '').split(delimiter)) {
+        if (dir === '')
+            continue;
+        for (const extension of extensions) {
+            const stamped = stampFile(join(dir, command + extension));
+            if (stamped !== undefined)
+                return stamped;
+        }
+    }
+    return undefined;
+}
+/**
+ * The cache key: the identity of every argv entry that names an existing file
+ * — the executable, plus a launcher argv's entry script. An upgrade rewrites
+ * one of those files, which changes the key, which re-probes. An executable
+ * that resolves to nothing keys on the raw argv instead, so a CLI that is not
+ * installed is not probed once per status call either.
+ */
+export function cliExecutableIdentity(argv) {
+    const parts = [resolveExecutable(argv[0] ?? '') ?? `argv:${argv[0] ?? ''}`];
+    for (const entry of argv.slice(1)) {
+        if (!looksLikePath(entry))
+            continue;
+        const stamped = stampFile(isAbsolute(entry) ? entry : resolve(entry));
+        if (stamped !== undefined)
+            parts.push(stamped);
+    }
+    return parts.join(' ');
+}
+/** Spawn the probe once and map its output to a version; never throws. */
+async function runProbe(probe) {
+    try {
+        const child = probe.spawn({
+            argv: [...probe.argv],
+            cwd: probe.cwd,
+            stdio: {
+                stdin: 'ignore',
+                stdout: { maxBytes: PROBE_OUTPUT_MAX_BYTES },
+                stderr: { maxBytes: PROBE_OUTPUT_MAX_BYTES },
+            },
+            graceMs: PROBE_GRACE_MS,
+            signal: AbortSignal.timeout(probe.timeoutMs ?? CLI_VERSION_PROBE_TIMEOUT_MS),
+            ...probe.env === undefined ? {} : { env: probe.env },
+        });
+        const outcome = await child.done;
+        // A non-zero exit (or a signal from the timeout) means the CLI did not
+        // answer the question asked. Parsing its diagnostics would invent a
+        // version out of an error message, so the honest answer is absence.
+        if (outcome.exitCode !== 0)
+            return undefined;
+        const stdout = child.collected.stdout?.readFrom(0).text ?? '';
+        const stderr = child.collected.stderr?.readFrom(0).text ?? '';
+        return parseCliVersion(`${stdout}\n${stderr}`);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * The CLI's own version, probed at most once per executable identity.
+ * Concurrent callers share one in-flight probe; a success is remembered until
+ * the binary changes; a failure is remembered for
+ * {@link CLI_VERSION_FAILURE_TTL_MS} so a transient miss recovers without
+ * spawning per status call.
+ * @param probe - the probe request.
+ * @returns the version, or undefined when the CLI cannot be asked.
+ */
+export async function probeCliVersion(probe) {
+    const key = cliExecutableIdentity(probe.argv);
+    const cached = cache.get(key);
+    if (cached !== undefined && (cached.failedAt === undefined || Date.now() - cached.failedAt < CLI_VERSION_FAILURE_TTL_MS)) {
+        return cached.promise;
+    }
+    const entry = { promise: runProbe(probe) };
+    cache.set(key, entry);
+    const version = await entry.promise;
+    if (version === undefined)
+        entry.failedAt = Date.now();
+    return version;
+}

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

@@ -0,0 +1,17 @@
+/**
+ * The at-a-glance credential dot for the settings-card headers: the same
+ * visual as the family settings section's per-harness row dot (green =
+ * authenticated, red = not, grey = checking/unavailable).
+ * @module @khorsheed/dsh-local-agent/client — auth status dot
+ */
+import type { HarnessAuthStatusKind } from './auth-status.ts';
+/** Props for the credential dot. */
+export interface AuthStatusDotProps {
+    /** The latest known status kind. */
+    status: HarnessAuthStatusKind;
+    /** The localized aria label (the card's auth copy namespace). */
+    label: string;
+}
+/** One 8px status dot with an accessible label. */
+export declare function AuthStatusDot({ status, label }: AuthStatusDotProps): import("react").JSX.Element;
+//# sourceMappingURL=AuthStatusDot.d.ts.map

package/lib/types/client/AuthStatusDot.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import css from './AuthStatusDot.module.css';
+/** One 8px status dot with an accessible label. */
+export function AuthStatusDot({ status, label }) {
+    const modifier = status === 'authenticated' ? css.dotOn
+        : status === 'anonymous' ? css.dotOff
+            : css.dotPending;
+    return _jsx("span", { className: `${css.credentialDot} ${modifier}`, role: "img", "aria-label": label, "data-auth-status": status });
+}

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

@@ -0,0 +1,17 @@
+import type { LocalAgentModelDirectory } from '../types.ts';
+import { type ConfigurationTranslate } from './ModelConfigurationFields.tsx';
+export interface ModelDirectoryFace {
+    read(refresh: boolean): Promise<LocalAgentModelDirectory | null>;
+    follow(signal: AbortSignal): AsyncIterable<LocalAgentModelDirectory>;
+}
+export interface HarnessModelPickerProps {
+    face: ModelDirectoryFace;
+    value: string;
+    onChange(value: string): void;
+    disabled?: boolean | undefined;
+    defaultLabel?: string | undefined;
+    t: ConfigurationTranslate;
+}
+/** Discover while expanded or resolving an empty choice; settings remain caller-owned drafts. */
+export declare function HarnessModelPicker({ face, value, onChange, disabled, t }: HarnessModelPickerProps): import("react").JSX.Element;
+//# sourceMappingURL=HarnessModelPicker.d.ts.map

package/lib/types/client/HarnessModelPicker.js

@@ -0,0 +1,48 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from 'react';
+import { ModelConfigurationFields } from './ModelConfigurationFields.js';
+import css from './MemberConfiguration.module.css';
+import { useConfigurationMenu } from './use-configuration-menu.js';
+/** Discover while expanded or resolving an empty choice; settings remain caller-owned drafts. */
+export function HarnessModelPicker({ face, value, onChange, disabled, t }) {
+    const menu = useConfigurationMenu('below');
+    const { open, setOpen } = menu;
+    const [surface, setSurface] = useState();
+    const directory = surface?.face === face ? surface.directory : undefined;
+    const currentFace = useRef(face);
+    currentFace.current = face;
+    const setDirectory = (directory) => { if (currentFace.current === face)
+        setSurface({ face, directory }); };
+    const [error, setError] = useState();
+    useEffect(() => {
+        if (!open && value)
+            return;
+        const controller = new AbortController();
+        let timer;
+        const follow = async () => {
+            try {
+                for await (const result of face.follow(controller.signal)) {
+                    if (controller.signal.aborted)
+                        return;
+                    setDirectory(result);
+                    setError(undefined);
+                }
+            }
+            catch (error) {
+                if (!controller.signal.aborted)
+                    setError(error instanceof Error ? error.message : String(error));
+            }
+            if (!controller.signal.aborted)
+                timer = setTimeout(() => { void follow(); }, 1_000);
+        };
+        void follow();
+        return () => { controller.abort(); clearTimeout(timer); };
+    }, [face, open, Boolean(value)]);
+    useEffect(() => {
+        const first = directory?.entries.find(entry => !entry.hidden);
+        if (!value && !disabled && first)
+            onChange(first.value);
+    }, [directory, value, disabled, onChange]);
+    const entry = directory?.entries.find(entry => entry.value === value);
+    return _jsxs("details", { ref: menu.root, className: `${css.root} ${css.settings}`, open: open, onToggle: event => setOpen(event.currentTarget.open), children: [_jsx("summary", { "aria-label": t('configuration.model'), "aria-expanded": open, children: _jsx("span", { className: css.triggerLabel, children: entry?.label ?? (value || t('configuration.choose')) }) }), open && _jsxs("div", { ref: menu.panel, className: css.panel, style: menu.style, children: [error && _jsx("div", { role: "alert", children: error }), !directory && _jsx("span", { role: "status", children: t('loading') }), _jsx(ModelConfigurationFields, { directory: directory, value: { model: value ? { mode: 'value', value } : { mode: 'default' }, effort: { mode: 'default' } }, onChange: selection => { onChange(selection.model.mode === 'value' ? selection.model.value : ''); setOpen(false); }, showEffort: false, disabled: disabled, t: t })] })] });
+}

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

@@ -0,0 +1,41 @@
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+import type { LocalAgentRosterRow, LocalAgentSessionRecord } from '@khorsheed/dsh-local-agent/types';
+import type { PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+import { NS } from './locales.ts';
+/** One harness the family renders a trigger for. */
+export interface LocalAgentHarnessView {
+    /** Harness command prefix, e.g. `kimi`. */
+    id: string;
+    /** Trigger label, e.g. `Kimi`. */
+    label: string;
+}
+/** Injected business face of the session-header records action. */
+export interface LocalAgentRecordsActionInjected {
+    /** Registered harnesses, in registration order. */
+    roster: () => Promise<readonly LocalAgentRosterRow[] | undefined>;
+    /**
+     * One harness's scoped sessions, narrowed to the given dsh session's cwd.
+     * @param name - the harness name.
+     * @param sessionId - the dsh session whose workspace the records must match.
+     */
+    sessions: (name: string, sessionId: SessionId) => Promise<readonly LocalAgentSessionRecord[] | undefined>;
+}
+/** Full props for the session-header records action. */
+export type LocalAgentRecordsActionProps = PropsRuntime<'conversation.session.header.actions'> & PropsLocale<typeof NS> & LocalAgentRecordsActionInjected;
+/** One harness's records dropdown: trigger and popover. */
+export declare function RecordsDropdown({ harness, sessionId, listRecords, t }: {
+    harness: LocalAgentHarnessView;
+    sessionId: SessionId;
+    listRecords: (sessionId: SessionId) => Promise<readonly LocalAgentSessionRecord[] | undefined>;
+    t: LocalAgentRecordsActionProps['t'];
+}): import("react").JSX.Element;
+/**
+ * Session-header entry point for the local-agent family: fetches the harness
+ * roster through the local-agent Remote channel on mount and renders one
+ * records dropdown per harness. The Remote channel is read-only and emits no
+ * session events, so these UI refreshes never leave command nodes in the log.
+ * @param props - runtime slot currency plus the injected query face.
+ * @returns the per-harness triggers and their popovers.
+ */
+export declare function LocalAgentRecordsAction({ sessionId, roster, sessions, t }: LocalAgentRecordsActionProps): import("react").JSX.Element;
+//# sourceMappingURL=LocalAgentRecordsAction.d.ts.map

package/lib/types/client/LocalAgentRecordsAction.js

@@ -0,0 +1,74 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { IconChevronDownOutlineMedium } from './icons.js';
+import css from './LocalAgentRecordsAction.module.css';
+/** One harness's records dropdown: trigger and popover. */
+export function RecordsDropdown({ harness, sessionId, listRecords, t }) {
+    const [open, setOpen] = useState(false);
+    const [load, setLoad] = useState({ phase: 'idle' });
+    const rootRef = useRef(null);
+    const triggerRef = useRef(null);
+    useEffect(() => {
+        if (!open)
+            return;
+        setLoad({ phase: 'loading' });
+        let cancelled = false;
+        void listRecords(sessionId).then((records) => {
+            if (cancelled)
+                return;
+            setLoad(records === undefined
+                ? { phase: 'unavailable' }
+                : { phase: 'loaded', records });
+        }).catch(() => {
+            if (!cancelled)
+                setLoad({ phase: 'error' });
+        });
+        return () => { cancelled = true; };
+    }, [open, listRecords, sessionId]);
+    useEffect(() => {
+        if (!open)
+            return;
+        const closeOutside = (event) => {
+            if (event.target instanceof Node && !rootRef.current?.contains(event.target)) {
+                setOpen(false);
+            }
+        };
+        document.addEventListener('pointerdown', closeOutside);
+        return () => { document.removeEventListener('pointerdown', closeOutside); };
+    }, [open]);
+    const rows = useMemo(() => (load.phase === 'loaded' ? load.records : []), [load]);
+    const empty = load.phase === 'loaded' && rows.length === 0;
+    const onKeyDown = (event) => {
+        if (event.key !== 'Escape' || !open)
+            return;
+        event.preventDefault();
+        setOpen(false);
+        triggerRef.current?.focus();
+    };
+    return (_jsxs("div", { ref: rootRef, className: css.root, onKeyDown: onKeyDown, children: [_jsxs("button", { ref: triggerRef, type: "button", className: css.trigger, "aria-haspopup": "listbox", "aria-expanded": open, "aria-label": t('list.aria', { harness: harness.label }), onClick: () => { setOpen(value => !value); }, children: [harness.label, _jsx(IconChevronDownOutlineMedium, { className: open ? css.triggerOpen : undefined })] }), open && (_jsxs("ul", { className: css.menu, role: "listbox", "aria-label": t('list.title', { harness: harness.label }), children: [load.phase === 'loading' && _jsx("li", { className: css.row, children: t('loading') }), load.phase === 'unavailable' && _jsx("li", { className: css.row, children: t('unknown.command', { harness: harness.label, command: harness.id }) }), load.phase === 'error' && _jsx("li", { className: css.row, children: t('error', { harness: harness.label }) }), empty && (_jsx("li", { className: css.row, children: _jsx("span", { className: css.label, children: t('empty', { harness: harness.label }) }) })), empty && _jsx("li", { className: css.row, children: t('login.hint', { command: harness.id }) }), rows.map(row => (_jsxs("li", { className: css.row, role: "option", "aria-label": t('row.aria', { harness: harness.label, sessionId: row.id }), children: [_jsx("span", { className: css.label, title: row.id, children: row.id }), _jsx("span", { className: css.kind, children: t('workdir') }), _jsx("span", { className: css.status, title: row.workDir, children: row.workDir })] }, row.id)))] }))] }));
+}
+/**
+ * Session-header entry point for the local-agent family: fetches the harness
+ * roster through the local-agent Remote channel on mount and renders one
+ * records dropdown per harness. The Remote channel is read-only and emits no
+ * session events, so these UI refreshes never leave command nodes in the log.
+ * @param props - runtime slot currency plus the injected query face.
+ * @returns the per-harness triggers and their popovers.
+ */
+export function LocalAgentRecordsAction({ sessionId, roster, sessions, t }) {
+    const [harnesses, setHarnesses] = useState([]);
+    useEffect(() => {
+        let cancelled = false;
+        void roster().then((rows) => {
+            if (cancelled || rows === undefined)
+                return;
+            setHarnesses(rows.map(row => ({ id: row.name, label: row.displayName })));
+        }).catch(() => {
+            // A failed roster fetch leaves the header without triggers; the settings
+            // section surfaces the failure with a retry instead.
+        });
+        return () => { cancelled = true; };
+    }, [roster]);
+    const listRecords = (id) => (target) => sessions(id, target);
+    return (_jsx("div", { className: css.family, children: harnesses.map(harness => (_jsx(RecordsDropdown, { harness: harness, sessionId: sessionId, listRecords: listRecords(harness.id), t: t }, harness.id))) }));
+}

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

@@ -0,0 +1,79 @@
+import type { ReactNode } from 'react';
+import type { ComposerChainProps } from '@deepseek-ai/dsh-client-ui-conversation/client';
+import type { PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+import type { LocalAgentDelegationView, LocalAgentModelInfo, LocalAgentPromptResult } from '@khorsheed/dsh-local-agent/types';
+import { NS } from './locales.ts';
+/** What the chain selector hands the elected component. */
+export interface MemberComposerMatch {
+    /**
+     * The elected session's id — a one-shot subagent session, possibly a family
+     * member (the component confirms through the Remote).
+     */
+    childSessionId: string;
+}
+/**
+ * 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 declare function selectCliMember(owner: ComposerChainProps): MemberComposerMatch | null;
+/**
+ * Injected business face: the member channel's gateway remotes, narrowed to
+ * plain values (an RPC failure surfaces as undefined, which the component
+ * renders through its own copy rather than throwing into the slot tree).
+ */
+export interface MemberComposerInjected {
+    renderMemberInbox?: ((childSessionId: string) => ReactNode) | undefined;
+    renderMemberConfiguration?: ((childSessionId: string) => ReactNode) | undefined;
+    /** The delegation view for a child session; null = not a family member. */
+    memberOf: (childSessionId: string) => Promise<LocalAgentDelegationView | null | undefined>;
+    /** Send one human follow-up to the member (facade resume host-side). */
+    promptMember: (childSessionId: string, text: string, requestId?: string) => Promise<LocalAgentPromptResult | undefined>;
+    /** Interrupt the member's in-flight run. */
+    stopMember: (childSessionId: string) => Promise<boolean | undefined>;
+    /**
+     * The in-flight delegation child session ids (the second running source:
+     * the official summary `running` flag is agent-based and stays false for
+     * external CLI runs, which have no live host agent). undefined = RPC
+     * failure; the component keeps the last known bit rather than flapping.
+     */
+    activeDelegations: () => Promise<readonly string[] | undefined>;
+    /**
+     * The member's model surface; null = no picker (a brokerless harness keeps
+     * its pre-broker behavior exactly), undefined = RPC failure (keep the last
+     * known surface rather than flapping the picker off).
+     */
+    memberModel: (childSessionId: string) => Promise<LocalAgentModelInfo | null | undefined>;
+    /**
+     * Set (undefined = clear) the member's session-level model override; the
+     * structured error renders inline like a promptMember failure.
+     */
+    setMemberModel: (childSessionId: string, model?: string) => Promise<LocalAgentPromptResult | undefined>;
+}
+/** Full chain props after the member selector accepts the owner currency. */
+export type MemberComposerProps = PropsRuntime<'conversation.composer'> & {
+    matched: MemberComposerMatch;
+} & PropsLocale<typeof NS> & MemberComposerInjected;
+/** Test hook: drop every cached membership answer. */
+export declare function resetMembershipCache(): void;
+/**
+ * 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 declare function MemberComposer({ matched, useSession, useProjection, memberOf, promptMember, stopMember, activeDelegations, memberModel, setMemberModel, renderMemberConfiguration, renderMemberInbox, t }: MemberComposerProps): import("react").JSX.Element;
+//# sourceMappingURL=MemberComposer.d.ts.map