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

package/lib/records.js

@@ -0,0 +1,109 @@
+import { t as resolveDshSessionLog } from "./session-log-DOsSz56-.js";
+import { join } from "node:path";
+import { readFile, readdir } from "node:fs/promises";
+import { zstdDecompressSync } from "node:zlib";
+//#region lib/types/records.js
+/**
+* Session records adapter for the `dsh` harness: list the sub-dsh's own
+* sessions from its scoped-home store. The sub-dsh persists JSONL logs under
+* `<scoped home>/sessions/<project>/<session-id>/` (the same physical layout
+* the official JSONL persistence backend writes), so the adapter reads headers
+* directly instead of asking the parent's persistence service, which is bound
+* to the parent's own store root. WHICH file in that directory holds the log
+* is the host's generation choice, resolved through the same
+* {@link resolveDshSessionLog} the session mirror uses — the two readers must
+* never disagree about where a session's history lives.
+* @module @khorsheed/dsh-local-agent-dsh/records
+*/
+/** Parse the header line of a session log; undefined when it is not one. */
+function parseDshSessionHeader(firstLine) {
+	let parsed;
+	try {
+		parsed = JSON.parse(firstLine);
+	} catch {
+		return;
+	}
+	if (typeof parsed !== "object" || parsed === null) return void 0;
+	const header = parsed;
+	if (header.type !== "session" || typeof header.id !== "string") return void 0;
+	return {
+		id: header.id,
+		...typeof header.cwd === "string" ? { cwd: header.cwd } : {},
+		...typeof header.createdAt === "number" ? { createdAt: header.createdAt } : {}
+	};
+}
+/** Whether an fs error is a missing entry. */
+function isENOENT(error) {
+	return error.code === "ENOENT";
+}
+/**
+* Read a session log's first line (its header). The JSONL backend stores one
+* zstd frame per append batch; node's zstdDecompress decodes the first frame,
+* which holds the header line written at session creation.
+* @param logPath - the session log file to read (any generation, compressed
+*   or raw — the caller resolved which one).
+* @param compressed - whether the file is zstd-compressed; a raw log is read
+*   as text. Defaults to compressed, the backend's own default.
+* @returns the first line, or undefined when the file is empty/half-written.
+*/
+async function readDshSessionHeaderLine(logPath, compressed = true) {
+	let buffer;
+	try {
+		buffer = await readFile(logPath);
+	} catch (error) {
+		if (isENOENT(error)) return void 0;
+		throw error;
+	}
+	if (buffer.length === 0) return void 0;
+	let text;
+	try {
+		text = compressed ? zstdDecompressSync(buffer).toString("utf8") : buffer.toString("utf8");
+	} catch {
+		return;
+	}
+	const firstLine = text.split("\n", 1)[0];
+	return firstLine === void 0 ? void 0 : firstLine;
+}
+/**
+* List the sessions recorded in the harness scoped home, in the store's own
+* order (project directories first, then session directories).
+* @param homeDir - the `dsh` harness's scoped home (its `$DSH_HOME` root).
+* @returns the session records; an absent store yields an empty list.
+*/
+async function listDshSessions(homeDir) {
+	const root = join(homeDir, "sessions");
+	let projects;
+	try {
+		projects = await readdir(root);
+	} catch (error) {
+		if (isENOENT(error)) return [];
+		throw error;
+	}
+	const records = [];
+	for (const project of projects) {
+		if (!project.startsWith("--")) continue;
+		let sessionIds;
+		try {
+			sessionIds = await readdir(join(root, project));
+		} catch (error) {
+			if (isENOENT(error)) continue;
+			throw error;
+		}
+		for (const sessionId of sessionIds) {
+			const log = await resolveDshSessionLog(join(root, project, sessionId));
+			if (log === void 0) continue;
+			const headerLine = await readDshSessionHeaderLine(log.path, log.compressed);
+			if (headerLine === void 0) continue;
+			const header = parseDshSessionHeader(headerLine);
+			if (header === void 0) continue;
+			records.push({
+				id: header.id,
+				...header.cwd !== void 0 ? { workDir: header.cwd } : { workDir: project },
+				...header.createdAt !== void 0 ? { startedAt: header.createdAt } : {}
+			});
+		}
+	}
+	return records;
+}
+//#endregion
+export { listDshSessions, parseDshSessionHeader, readDshSessionHeaderLine };

package/lib/session-log-DOsSz56-.js

@@ -0,0 +1,88 @@
+import { join } from "node:path";
+import { readdir } from "node:fs/promises";
+//#region lib/types/session-log.js
+/**
+* Locating one sub-dsh session's log file inside its session directory.
+*
+* The host's JSONL persistence backend addresses its logs by SESSION FORMAT
+* GENERATION: version zero keeps the original `session.jsonl`, and every later
+* generation carries a lowercase `vN` component — `session.v3.jsonl` on host
+* 0.1.5. Either basename may additionally carry `.zstd` for the compressed
+* default. The backend itself "selects the numerically highest canonical
+* generation", and so does this module: a reader that hardcodes one filename
+* reads nothing the moment the host advances a generation, which is exactly
+* how a 0.1.5 sub-dsh round lost its observed model, its usage and its tool
+* calls at once while still settling `completed`.
+*
+* Both readers in this package — the session mirror's read-back and the
+* `/dsh sessions` records adapter — resolve through here, so the two can never
+* disagree about which file a session's history lives in.
+* @module @khorsheed/dsh-local-agent-dsh/session-log
+*/
+/**
+* The canonical raw-log basename, matched AFTER any compression suffix is
+* removed. Deliberately the host's own rule, character for character
+* (`@deepseek-ai/dsh-session-format`): `.v0`, leading zeros, uppercase and
+* temporary names are NOT canonical generations, and a reader that accepted
+* them would read a file the writer never published.
+*/
+const CANONICAL_LOG_FILENAME = /^session(?:\.v([1-9][0-9]*))?\.jsonl$/u;
+/**
+* Read the generation one session-directory entry names.
+* @param filename - one basename from a session directory.
+* @returns its generation and encoding, or undefined when the name is not a
+*   canonical log (`session.lock`, a temporary file, `session.v0.jsonl`, …).
+*/
+function parseDshSessionLogFilename(filename) {
+	const compressed = filename.endsWith(".zstd");
+	const raw = compressed ? filename.slice(0, -5) : filename;
+	const match = CANONICAL_LOG_FILENAME.exec(raw);
+	if (match === null) return void 0;
+	if (match[1] === void 0) return {
+		version: 0,
+		compressed
+	};
+	const version = Number(match[1]);
+	return Number.isSafeInteger(version) ? {
+		version,
+		compressed
+	} : void 0;
+}
+/**
+* Choose the log file of one session directory: the numerically HIGHEST
+* canonical generation present, preferring the compressed artifact when a
+* generation somehow has both (the backend writes one per its configured
+* encoding, so the pair only appears when a store changed settings).
+*
+* A directory with no canonical log — including one that holds only a
+* `session.lock` — yields undefined. Absence is reported, never guessed: a
+* caller that cannot find a log records nothing rather than inventing an empty
+* history.
+* @param dir - the session-owned directory.
+* @returns the chosen log, or undefined when the directory holds none.
+*/
+async function resolveDshSessionLog(dir) {
+	let entries;
+	try {
+		entries = await readdir(dir);
+	} catch {
+		return;
+	}
+	let best;
+	for (const filename of entries) {
+		const parsed = parseDshSessionLogFilename(filename);
+		if (parsed === void 0) continue;
+		if (best !== void 0) {
+			if (parsed.version < best.version) continue;
+			if (parsed.version === best.version && !(parsed.compressed && !best.compressed)) continue;
+		}
+		best = {
+			path: join(dir, filename),
+			filename,
+			...parsed
+		};
+	}
+	return best;
+}
+//#endregion
+export { resolveDshSessionLog as t };

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

@@ -0,0 +1,78 @@
+import type { HarnessModelPickerInput } from '@khorsheed/dsh-local-agent/client';
+import type { ReactNode } from 'react';
+import type { SettingsScope } from '@khorsheed/dsh-local-agent/src/client/settings-scope.ts';
+import type { InjectFace, PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+import { type ProviderAuthBlockProps, type ProviderAuthInjected } from '@khorsheed/dsh-local-agent/src/client/ProviderAuthBlock.tsx';
+import type { LocalAgentModelInfo } from '@khorsheed/dsh-local-agent/types';
+import { NS } from './locales.ts';
+/** The `local-agent-dsh` settings namespace section the card edits. */
+export interface DshCardSettings {
+    /** Whether the dsh harness, provider, and delegation tool are registered. */
+    enabled?: boolean;
+    /** Resident (live) mode: one resident sub-dsh serve process per member. */
+    live?: boolean;
+    /**
+     * The model every delegation round starts the sub-dsh with, spelled
+     * `provider/model`. Absent (the field cleared) means the plugin passes no
+     * `--model` at all — the host instance's own default selection decides.
+     */
+    model?: string;
+    /** Model identifiers saved before; the input's suggestions, capped at five. */
+    recentModels?: readonly string[];
+}
+/** Injected face of the dsh settings card. */
+export interface DshSettingsCardInjected {
+    renderModelPicker?: ((props: HarnessModelPickerInput) => ReactNode) | undefined;
+    /** Bound settings scope for the local-agent-dsh namespace. */
+    scope: SettingsScope<DshCardSettings>;
+    /** The auth block's query/command faces, backed by the family core Remote. */
+    auth: ProviderAuthInjected;
+    /** Translate bound to the family core's `local-agent` namespace (the auth block's copy lives there). */
+    authT: ProviderAuthBlockProps['t'];
+    /**
+     * The harness's memberless model surface (the core gateway's `harnessModel`
+     * Remote): the inherited default an unset field displays and the menu's
+     * choice vocabulary. Undefined or null when the gateway or the broker is
+     * absent — the card then keeps the bare input exactly as before brokers
+     * existed.
+     */
+    harnessModel: () => Promise<LocalAgentModelInfo | null | undefined>;
+    hooks: {
+        /** The same scope as a hooks source, so the card reacts to external writes. */
+        settings: SettingsScope<DshCardSettings>;
+    };
+}
+/**
+ * Full props of the 0.1.5 settings.plugin.item card entry. The removed slot's
+ * owner share was intentionally empty and its root scope delivered the global
+ * seats; the structural type below is exact about the one seat the auth block
+ * consumes (the slot name is gone from the alpha.2 SlotMap, so the
+ * registration goes through a duck-typed narrow — see client/index.ts).
+ */
+export type DshSettingsCardProps = InjectFace<DshSettingsCardInjected> & PropsLocale<typeof NS> & {
+    /** The standing root-scope global seat (ui-session's merge), delivered to the 0.1.5 card by the renderer. */
+    useSessions: ProviderAuthBlockProps['useSessions'];
+};
+/** Full props of the alpha.2 plugins.bundle.config entry (owner prop `view`). */
+export type DshBundleConfigProps = PropsRuntime<'plugins.bundle.config'> & InjectFace<DshSettingsCardInjected> & PropsLocale<typeof NS>;
+/**
+ * The dsh harness settings card in the 0.1.5 plugin configuration tab: the
+ * same collapsible chrome the official plugin cards use, re-implemented
+ * locally (the bundle-purity gate forbids value-importing the official chrome
+ * — the context-guard pattern), with the at-a-glance credential dot in the
+ * header. Explanation copy lives in hover/focus bubbles behind ⓘ anchors —
+ * the card's rows stay one line each.
+ * @param props - the injected scope/auth faces and copy.
+ * @returns the card.
+ */
+export declare function DshSettingsCard(props: DshSettingsCardProps): import("react").JSX.Element;
+/**
+ * The bundle's configuration on the alpha.2 Plugins page
+ * (`plugins.bundle.config`, keyed by package name): the page draws the title,
+ * the icon, and the crumb itself, so the entry renders the one-liner for the
+ * `summary` view and the bare form — with its own save control — for `page`.
+ * @param props - the owner view, the injected scope/auth faces, and copy.
+ * @returns the entry.
+ */
+export declare function DshBundleConfig({ view, useSettings, scope, auth, authT, renderModelPicker, harnessModel, useSessions, t }: DshBundleConfigProps): import("react").JSX.Element;
+//# sourceMappingURL=SettingsCard.d.ts.map

package/lib/types/client/SettingsCard.js

@@ -0,0 +1,200 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from 'react';
+import { Tooltip } from '@deepseek-ai/dsh-client-ui-primitives';
+import { IconChevronDownOutlineMedium } from './icons.js';
+// The shared auth block is bundled from the family core's source — the
+// sanctioned core/companion edge (the host half already depends on the core);
+// the block carries no runtime identity to share.
+import { ProviderAuthBlock, } from '@khorsheed/dsh-local-agent/src/client/ProviderAuthBlock.tsx';
+import { AuthStatusDot } from '@khorsheed/dsh-local-agent/src/client/AuthStatusDot.tsx';
+import { useHarnessAuthStatus } from '@khorsheed/dsh-local-agent/src/client/auth-status.ts';
+import css from './SettingsCard.module.css';
+/** How many previously-saved model identifiers the input suggests. */
+const RECENT_MODEL_LIMIT = 5;
+/**
+ * The staged card state both settings surfaces share: the delegation,
+ * resident-mode, and model edits write through the bound settingsScope
+ * immediately (revision-fenced), so a flip takes effect on the next
+ * delegation round without a reload; the harness's model surface is fetched
+ * while the surface is active (the 0.1.5 card opened, the alpha.2 page
+ * mounted) and re-fetched after every save.
+ * @param active - whether the surface currently shows the body (gates the model-surface fetch).
+ * @param useSettings - the bound settings hook from the inject hooks compartment.
+ * @param scope - the bound settings scope the writes go through.
+ * @param harnessModel - the harness's memberless model surface read.
+ * @param t - copy.
+ */
+function useCardState(active, useSettings, scope, harnessModel, t) {
+    const snapshot = useSettings(value => value);
+    const [saved, setSaved] = useState(false);
+    const [error, setError] = useState(false);
+    const ready = snapshot.status === 'ready' && snapshot.writable;
+    const enabled = snapshot.value?.enabled ?? false;
+    const live = snapshot.value?.live ?? false;
+    // The model input is a DRAFT until saved: `null` means "showing whatever the
+    // scope holds", so an external write (another tab, a YAML reload) still
+    // reaches the field while the user is not typing in it.
+    const storedModel = snapshot.value?.model ?? '';
+    const recentModels = snapshot.value?.recentModels ?? [];
+    const [modelDraft, setModelDraft] = useState(null);
+    const [modelSaved, setModelSaved] = useState(false);
+    const [modelError, setModelError] = useState(false);
+    const modelValue = modelDraft ?? storedModel;
+    // The harness's model surface, fetched while the surface is active (and
+    // re-fetched after a save): undefined until the first answer, null when the
+    // gateway or the broker is absent — the card then keeps the bare input with
+    // its recent-models suggestions, exactly as before brokers existed.
+    const [modelInfo, setModelInfo] = useState(undefined);
+    useEffect(() => {
+        if (!active)
+            return;
+        let stale = false;
+        void harnessModel().then((info) => {
+            if (!stale)
+                setModelInfo(info ?? null);
+        });
+        return () => { stale = true; };
+    }, [active, harnessModel, modelSaved]);
+    /**
+     * Commit the model field. A blank value UNSETS the key rather than storing
+     * an empty string, so the field re-inherits the YAML composition base — and
+     * with no base, the harness is back to passing no model at all.
+     */
+    const saveModel = () => {
+        const next = modelValue.trim();
+        setModelSaved(false);
+        setModelError(false);
+        const write = next === '' ? scope.unset('model') : scope.set('model', next);
+        void write.then(async () => {
+            // Most-recent-first, deduplicated, capped: the suggestion list is a
+            // memory of what this instance has actually run, never a catalog.
+            if (next !== '') {
+                await scope.set('recentModels', [next, ...recentModels.filter(value => value !== next)].slice(0, RECENT_MODEL_LIMIT));
+            }
+            setModelDraft(null);
+            setModelSaved(true);
+        }, () => { setModelError(true); });
+    };
+    const write = (field, value) => {
+        setSaved(false);
+        setError(false);
+        void scope.set(field, value).then(() => { setSaved(true); }, () => { setError(true); });
+    };
+    // The suggestion vocabulary: the broker's deduped union (settings + host
+    // default selection + recent) when the surface answered, the card's own
+    // recent-models memory when it did not. Never a hardcoded catalog. A
+    // non-empty list turns the field into a select-like control: the
+    // always-visible chevron opens the same vocabulary as a menu.
+    const choices = modelInfo?.choices ?? recentModels;
+    const [modelMenuOpen, setModelMenuOpen] = useState(false);
+    const [modelMenuUp, setModelMenuUp] = useState(false);
+    const modelFieldRef = useRef(null);
+    // Click-outside and Esc close the model menu (the member composer's picker
+    // pattern); the upward flip is measured when the menu opens.
+    useEffect(() => {
+        if (!modelMenuOpen)
+            return;
+        const onPointerDown = (event) => {
+            if (modelFieldRef.current?.contains(event.target) === true)
+                return;
+            setModelMenuOpen(false);
+        };
+        const onKeyDown = (event) => {
+            if (event.key === 'Escape')
+                setModelMenuOpen(false);
+        };
+        document.addEventListener('mousedown', onPointerDown);
+        document.addEventListener('keydown', onKeyDown);
+        return () => {
+            document.removeEventListener('mousedown', onPointerDown);
+            document.removeEventListener('keydown', onKeyDown);
+        };
+    }, [modelMenuOpen]);
+    const toggleModelMenu = () => {
+        if (!modelMenuOpen) {
+            const rect = modelFieldRef.current?.getBoundingClientRect();
+            if (rect !== undefined) {
+                const spaceBelow = window.innerHeight - rect.bottom;
+                setModelMenuUp(spaceBelow < 260 && rect.top > spaceBelow);
+            }
+        }
+        setModelMenuOpen(open => !open);
+    };
+    // An unset field DISPLAYS the default it follows (dimmed, as the input's
+    // placeholder — inherited, never pinned), down the chain the broker
+    // reports: the host's default-model selection, then a cli-builtin source
+    // that still names its default (a harness catalog's isDefault entry), then
+    // the last observed model the records know, and last the generic copy.
+    const inheritedModel = modelInfo != null && modelInfo.cliDefault !== undefined && modelInfo.cliDefault !== ''
+        ? modelInfo.cliDefault
+        : modelInfo != null && modelInfo.source === 'cli-builtin' && modelInfo.effective !== undefined && modelInfo.effective !== ''
+            ? modelInfo.effective
+            : modelInfo != null && modelInfo.lastObserved !== undefined && modelInfo.lastObserved !== ''
+                ? modelInfo.lastObserved
+                : undefined;
+    const modelPlaceholder = inheritedModel ?? t('model.placeholder');
+    // The menu's leading item: the same chain, spelled as the follow-default
+    // choice. It reads checked while the field is unset, and picking it clears
+    // the draft back to follow-default (a save then unsets the key).
+    const modelDefaultItem = modelInfo != null && modelInfo.cliDefault !== undefined && modelInfo.cliDefault !== ''
+        ? t('model.menuDefault.cli-config', { model: modelInfo.cliDefault })
+        : modelInfo != null && modelInfo.source === 'cli-builtin' && modelInfo.effective !== undefined && modelInfo.effective !== ''
+            ? t('model.menuDefault.cli-builtin', { model: modelInfo.effective })
+            : modelInfo != null && modelInfo.lastObserved !== undefined && modelInfo.lastObserved !== ''
+                ? t('model.menuDefault.last-observed', { model: modelInfo.lastObserved })
+                : t('model.menuDefault');
+    return {
+        snapshot, saved, error, ready, enabled, live, storedModel, modelValue,
+        modelSaved, modelError, choices, modelMenuOpen, modelMenuUp, modelFieldRef,
+        modelPlaceholder, modelDefaultItem, saveModel, write, toggleModelMenu,
+        setModelDraft, setModelMenuOpen,
+    };
+}
+/** The card body both settings surfaces share: the auth block, the delegation switch, the default-model block, and the resident-mode block. */
+function CardBody({ state, auth, authT, renderModelPicker, useSessions, t }) {
+    const { snapshot, saved, error, ready, enabled, live, storedModel, modelValue, modelSaved, modelError, choices, modelMenuOpen, modelMenuUp, modelFieldRef, modelPlaceholder, modelDefaultItem, saveModel, write, toggleModelMenu, setModelDraft, setModelMenuOpen, } = state;
+    // The free-text input, single-sourced for both presentations: bare when no
+    // vocabulary exists (a fresh install degrades to exactly the pre-picker
+    // field), or inside the select-like field next to its chevron. No datalist:
+    // the chevron menu is the single choice list.
+    const modelInputElement = (_jsx("input", { type: "text", className: css.modelInput, value: modelValue, placeholder: modelPlaceholder, "aria-label": t('model.title'), disabled: !ready, onChange: (event) => { setModelDraft(event.target.value); } }));
+    return (_jsxs("div", { className: css.body, children: [_jsxs("section", { className: css.block, children: [_jsx("h3", { className: css.blockTitle, children: t('auth.title') }), _jsx(ProviderAuthBlock, { harness: { id: 'dsh', label: 'dsh' }, useSessions: useSessions, status: auth.status, runCommand: auth.runCommand, t: authT }), _jsx("span", { className: css.hint, children: t('auth.host') })] }), _jsxs("section", { className: css.block, children: [_jsx("h3", { className: css.blockTitle, children: t('enable.title') }), _jsxs("div", { className: css.row, children: [_jsx("span", { className: css.rowLabel, children: t('enable.switch') }), _jsx("button", { type: "button", role: "switch", "aria-checked": enabled, "aria-label": t('enable.switch.aria'), className: enabled ? `${css.switch} ${css.switchOn}` : css.switch, disabled: !ready, onClick: () => { write('enabled', !enabled); }, children: _jsx("span", { className: css.knob }) })] }), _jsx("span", { className: css.hint, children: t(enabled ? 'enable.on' : 'enable.off') })] }), _jsxs("section", { className: css.block, children: [_jsxs("h3", { className: css.blockTitle, children: [t('model.title'), _jsx(Tooltip, { label: t('model.info'), side: "bottom", maxWidth: 360, children: _jsx("button", { type: "button", className: css.info, "aria-label": t('model.info.aria'), children: "\u24D8" }) })] }), _jsxs("div", { className: css.row, children: [renderModelPicker?.({ value: modelValue, onChange: setModelDraft, disabled: !ready, defaultLabel: modelDefaultItem }) ?? (choices.length > 0 ? (_jsxs("div", { className: css.modelField, ref: modelFieldRef, children: [modelInputElement, _jsx("button", { type: "button", className: css.modelMenuButton, "aria-label": t('model.menu'), "aria-haspopup": "menu", "aria-expanded": modelMenuOpen, disabled: !ready, onClick: () => { toggleModelMenu(); }, children: _jsx(IconChevronDownOutlineMedium, { className: modelMenuOpen ? `${css.modelMenuChevron} ${css.modelMenuChevronOpen}` : css.modelMenuChevron }) }), modelMenuOpen && (_jsxs("div", { className: modelMenuUp ? `${css.modelMenu} ${css.modelMenuUp}` : css.modelMenu, role: "menu", "aria-label": t('model.menu'), children: [_jsxs("button", { type: "button", role: "menuitemradio", "aria-checked": modelValue.trim() === '', className: modelValue.trim() === '' ? `${css.modelItemDefault} ${css.modelItemCurrent}` : css.modelItemDefault, onClick: () => { setModelDraft(''); setModelMenuOpen(false); }, children: [_jsx("span", { className: css.modelItemLabel, children: modelDefaultItem }), _jsx("span", { className: css.modelItemCheck, "aria-hidden": true, children: modelValue.trim() === '' ? '✓' : '' })] }), choices.map(choice => (_jsxs("button", { type: "button", role: "menuitemradio", "aria-checked": choice === modelValue, className: choice === modelValue ? css.modelItemCurrent : css.modelItem, onClick: () => { setModelDraft(choice); setModelMenuOpen(false); }, children: [_jsx("span", { className: css.modelItemLabel, children: choice }), _jsx("span", { className: css.modelItemCheck, "aria-hidden": true, children: choice === modelValue ? '✓' : '' })] }, choice)))] }))] })) : modelInputElement), _jsx("button", { type: "button", className: css.modelSave, disabled: !ready || modelValue.trim() === storedModel, onClick: () => { saveModel(); }, children: t('model.save') })] }), modelSaved && _jsx("span", { className: css.saved, children: t('model.applied') }), modelError && _jsx("span", { className: css.errorText, children: t('model.error') })] }), _jsxs("section", { className: css.block, children: [_jsxs("div", { className: css.row, children: [_jsxs("span", { className: css.rowLabel, children: [t('live.title'), _jsx(Tooltip, { label: t('live.info'), side: "bottom", maxWidth: 360, children: _jsx("button", { type: "button", className: css.info, "aria-label": t('live.info.aria'), children: "\u24D8" }) })] }), _jsx("button", { type: "button", role: "switch", "aria-checked": live, "aria-label": t('live.title'), className: live ? `${css.switch} ${css.switchOn}` : css.switch, disabled: !ready, onClick: () => { write('live', !live); }, children: _jsx("span", { className: css.knob }) })] }), snapshot.status === 'unavailable' && (_jsx("span", { className: css.hint, children: t('live.unavailable') }))] }), saved && _jsx("span", { className: css.saved, children: t('live.applied') }), error && _jsx("span", { className: css.errorText, children: t('live.error') })] }));
+}
+/**
+ * The dsh harness settings card in the 0.1.5 plugin configuration tab: the
+ * same collapsible chrome the official plugin cards use, re-implemented
+ * locally (the bundle-purity gate forbids value-importing the official chrome
+ * — the context-guard pattern), with the at-a-glance credential dot in the
+ * header. Explanation copy lives in hover/focus bubbles behind ⓘ anchors —
+ * the card's rows stay one line each.
+ * @param props - the injected scope/auth faces and copy.
+ * @returns the card.
+ */
+export function DshSettingsCard(props) {
+    const { useSettings, scope, auth, authT, renderModelPicker, harnessModel, useSessions, t } = props;
+    const [open, setOpen] = useState(false);
+    const state = useCardState(open, useSettings, scope, harnessModel, t);
+    // The at-a-glance credential dot in the collapsed header: every mount
+    // re-probes (a credential expiring mid-session must flip the dot at the
+    // next view); the bus dedupes identical results, so no re-render storm.
+    const authStatus = useHarnessAuthStatus('dsh', auth.status);
+    const dotLabel = authT(authStatus === 'authenticated' ? 'settings.authenticated'
+        : authStatus === 'anonymous' ? 'settings.notAuthenticated'
+            : authStatus === 'checking' ? 'loading' : 'error');
+    const title = t('card.title');
+    return (_jsxs("li", { className: open ? `${css.card} ${css.cardOpen}` : css.card, children: [_jsxs("button", { type: "button", className: css.header, "aria-expanded": open, "aria-label": `${t(open ? 'card.collapse' : 'card.expand')}: ${title}`, onClick: () => { setOpen(!open); }, children: [_jsxs("span", { className: css.headText, children: [_jsxs("span", { className: css.nameRow, children: [_jsx("span", { className: css.name, children: title }), _jsx(AuthStatusDot, { status: authStatus, label: dotLabel })] }), _jsx("span", { className: css.description, children: t('card.description') })] }), _jsx(IconChevronDownOutlineMedium, { className: open ? `${css.chevron} ${css.chevronOpen}` : css.chevron })] }), open && _jsx(CardBody, { state: state, auth: auth, authT: authT, renderModelPicker: renderModelPicker, useSessions: useSessions, t: t })] }));
+}
+/**
+ * The bundle's configuration on the alpha.2 Plugins page
+ * (`plugins.bundle.config`, keyed by package name): the page draws the title,
+ * the icon, and the crumb itself, so the entry renders the one-liner for the
+ * `summary` view and the bare form — with its own save control — for `page`.
+ * @param props - the owner view, the injected scope/auth faces, and copy.
+ * @returns the entry.
+ */
+export function DshBundleConfig({ view, useSettings, scope, auth, authT, renderModelPicker, harnessModel, useSessions, t }) {
+    const state = useCardState(view === 'page', useSettings, scope, harnessModel, t);
+    if (view === 'summary')
+        return _jsx("span", { className: css.description, children: t('card.description') });
+    return _jsx(CardBody, { state: state, auth: auth, authT: authT, renderModelPicker: renderModelPicker, useSessions: useSessions, t: t });
+}

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

@@ -0,0 +1,18 @@
+/**
+ * Generated by scripts/sync-icon-artwork.mts from @deepseek-ai/dsh-client-ui-primitives
+ * (v0.1.7-rc.1, harness 46a7f68b09) — do not edit by hand. The 0.1.5 and rc.1 host lines
+ * share no icon export name, so the rc.1 artwork is inlined here: pure SVG,
+ * no host runtime identity, identical on every line. Re-run the generator
+ * after adding an icon import or bumping the harness checkout.
+ *
+ * @module @khorsheed/dsh-local-agent-dsh/client
+ */
+/** Shared props for every product icon component (mirrors the upstream IconProps). */
+export interface IconProps {
+    /** Square edge in px; defaults to the glyph's own drawn size. */
+    size?: number | undefined;
+    /** Extra class for layout placement; color rides currentColor. */
+    className?: string | undefined;
+}
+export declare const IconChevronDownOutlineMedium: ({ size, className }: IconProps) => import("react").JSX.Element;
+//# sourceMappingURL=icons.d.ts.map

package/lib/types/client/icons.js

@@ -0,0 +1,2 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+export const IconChevronDownOutlineMedium = ({ size = 14, className }) => (_jsx("svg", { width: size, height: size, className: className, viewBox: "0 0 16 16", fill: "none", xmlns: "http://www.w3.org/2000/svg", "aria-hidden": "true", strokeWidth: 1.3, children: _jsx("path", { d: "M4 6L7.29289 9.29289C7.68342 9.68342 8.31658 9.68342 8.70711 9.29289L12 6", stroke: "currentColor" }) }));

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

@@ -0,0 +1,45 @@
+/**
+ * Local-agent-dsh plugin, browser half: the dsh settings surface, one face
+ * per install shape and host line — a standalone install renders the
+ * bundle's own configuration on its Plugins-page detail view
+ * (`plugins.bundle.config`, keyed by package name), a family-bundle install
+ * renders the same card through the row-level configure entry on the
+ * BUNDLE's detail view (`plugins.row.config`, keyed
+ * `@khorsheed/dsh-bundle-local-agent#local-agent-dsh`), and 0.1.5 renders
+ * the `settings.plugin.item` card (keyed to the `local-agent-dsh`
+ * settings namespace the host half registers) in the official
+ * Plugins → 可配置插件 tab. The card carries the family core's shared
+ * ProviderAuthBlock (dsh authenticates through the host credentials, so the
+ * block renders status only), the DeepSeek delegation switch — migrated from
+ * the core section's `local-agent.settings.row-action` seat, which this
+ * plugin no longer contributes to — and the resident-mode block (live switch)
+ * plus the default-model block (free-text input, the broker's effective-model
+ * line and suggestion vocabulary), whose writes ride the bound settingsScope:
+ * the host watcher hot-applies them, no reload. Every read degrades: an
+ * absent gateway renders the auth block's 'unavailable' state and drops the
+ * model surface to the bare input, an unregistered namespace disables the
+ * controls.
+ * @module @khorsheed/dsh-local-agent-dsh/client
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import { en, NS, zh, type LocalAgentDshKey } from './locales.ts';
+export { DshBundleConfig, DshSettingsCard } from './SettingsCard.tsx';
+export type { DshCardSettings, DshBundleConfigProps, DshSettingsCardInjected, DshSettingsCardProps, } from './SettingsCard.tsx';
+export { en, NS, zh };
+export type { LocalAgentDshKey };
+/**
+ * Required services: slot registry, command Remote, and locale registry. The
+ * settings scope is NOT a static inject — its service name differs per host
+ * line (`settingsScope` on 0.1.5, `configForms` on rc.1), so a static entry
+ * would pend the whole client plugin on the other line; bindSettingsScope
+ * probes the serving one instead (the settings client package is a declared
+ * client inject, so one of them is always already up).
+ */
+export declare const inject: string[];
+/**
+ * Client plugin body: register the dictionaries and the dsh settings surfaces
+ * bound to the local-agent-dsh namespace.
+ * @param ctx - client root context.
+ */
+export declare function apply(ctx: Context): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/client/index.js

@@ -0,0 +1,88 @@
+import { bindSettingsScope } from '@khorsheed/dsh-local-agent/src/client/settings-scope.ts';
+import { en, NS, zh } from './locales.js';
+import { DshBundleConfig, DshSettingsCard, } from './SettingsCard.js';
+export { DshBundleConfig, DshSettingsCard } from './SettingsCard.js';
+export { en, NS, zh };
+/**
+ * This bundle's package name — the key the Plugins page dispatches
+ * `plugins.bundle.config` entries on (identity triangle: cordis.patch.yml,
+ * tsdown.config.ts, invariant.ts).
+ */
+const PACKAGE_NAME = '@khorsheed/dsh-local-agent-dsh';
+/**
+ * Required services: slot registry, command Remote, and locale registry. The
+ * settings scope is NOT a static inject — its service name differs per host
+ * line (`settingsScope` on 0.1.5, `configForms` on rc.1), so a static entry
+ * would pend the whole client plugin on the other line; bindSettingsScope
+ * probes the serving one instead (the settings client package is a declared
+ * client inject, so one of them is always already up).
+ */
+export const inject = ['slots', 'remote', 'remote.commands', 'locale'];
+/**
+ * Client plugin body: register the dictionaries and the dsh settings surfaces
+ * bound to the local-agent-dsh namespace.
+ * @param ctx - client root context.
+ */
+export function apply(ctx) {
+    ctx.effect(() => ctx.locale.register(NS, { zh, en }), 'local-agent-dsh: dictionaries');
+    const scope = bindSettingsScope(ctx, 'local-agent-dsh');
+    // The auth block's copy lives in the family core's dictionary; binding is
+    // stable per namespace and late dictionary registration still resolves.
+    const authT = ctx.locale.bind('local-agent');
+    // The gateway namespace is mounted by the family core's client half; read it
+    // lazily from the global store so boot order between the two client plugins
+    // never matters, and degrade to the auth block's 'unavailable' state when
+    // the core client is absent.
+    const gateway = () => ctx.get('remote.localAgentGateway');
+    // Both settings surfaces inject the same face.
+    const cardInject = () => ({
+        scope,
+        hooks: { settings: scope },
+        authT,
+        renderModelPicker: props => ctx.get('localAgentUi')?.renderHarnessModelPicker('dsh', props),
+        // The harness's memberless model surface; absent gateway/broker
+        // degrades to the bare input with its recent-models suggestions.
+        harnessModel: () => gateway()?.harnessModel('dsh').then(result => (result.ok ? result.value : undefined))
+            ?? Promise.resolve(undefined),
+        auth: {
+            status: name => 
+            // The Remote declares (name, scope?) and the client enforces exact arity:
+            // pass the default scope explicitly (undefined reads as omitted host-side).
+            gateway()?.status(name, undefined).then(result => (result.ok ? result.value : undefined))
+                ?? Promise.resolve(undefined),
+            runCommand: (sessionId, line) => ctx.remote.commands.execute(sessionId, line, [])
+                .then(result => (result.ok ? result.value?.result.text : undefined)),
+        },
+    });
+    // The settings surface follows the host line AND the install shape — three
+    // tracks, all riding slots.inject so each fires only where its declaration
+    // exists. Standalone install: the package's own Plugins-page detail view
+    // (`plugins.bundle.config`, keyed by package name). Installed as a family
+    // member: the member is no longer the profile's direct dependency, so only
+    // the bundle gets a detail view — the card rides the row-level slot
+    // (`plugins.row.config`, keyed `<bundle package>#<row id>` with the row id
+    // the bundle's patch declares) and the bundle's page gains a configure
+    // entry opening it. 0.1.5: the legacy configurable-plugins tab card
+    // (`settings.plugin.item`, keyed by the settings namespace) through a
+    // string-keyed duck narrow of the same service (the slot name is gone from
+    // the alpha.2 SlotMap).
+    ctx.slots.inject('plugins.bundle.config', () => ctx.slots.register({
+        name: 'plugins.bundle.config',
+        key: PACKAGE_NAME,
+        locale: NS,
+        inject: cardInject,
+    }, DshBundleConfig));
+    ctx.slots.inject('plugins.row.config', () => ctx.slots.register({
+        name: 'plugins.row.config',
+        key: '@khorsheed/dsh-bundle-local-agent#local-agent-dsh',
+        locale: NS,
+        inject: cardInject,
+    }, DshBundleConfig));
+    const legacy = ctx.slots;
+    legacy.inject('settings.plugin.item', () => legacy.register({
+        name: 'settings.plugin.item',
+        key: 'local-agent-dsh',
+        locale: NS,
+        inject: cardInject,
+    }, DshSettingsCard));
+}