@morlay/dsh-session-mode 0.0.8 → 0.0.10

package/dist/client.mjs

@@ -0,0 +1,1612 @@
+import { createSnapshotStore } from "@deepseek-ai/dsh-client-store";
+import { Button, DisclosureRow, IconAgentPresetOutlineRegular, IconButton, IconChevronDownOutlineRegular, IconPlusOutlineRegular, IconTrashOutlineRegular, Input, Menu, Modal, ModelRouteList, MultilineField, Row, SchemaFormController, SearchSelect, SeatButton, SegmentedControl, SettingsFieldRow, SettingsForm, Stack, Switch, TagInput, Text, failureOf, projectRoot } from "@morlay/dsh-client-ui-primitives";
+import { useEffect, useId, useMemo, useState } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+//#region src/catalog-remote.ts
+const CATALOG_NS = "sessionModeCatalog";
+const SESSION_MODE_CATALOG_REMOTE = {
+	package: "@morlay/dsh-session-mode",
+	descriptors: [{
+		id: "@morlay/dsh-session-mode#sessionModeCatalog/list",
+		service: CATALOG_NS,
+		namespace: CATALOG_NS,
+		method: "list",
+		implementation: "remoteExportList",
+		invocation: { kind: "direct" },
+		parameters: [],
+		result: { mode: "src-json" }
+	}]
+};
+//#endregion
+//#region src/shared.ts
+const SESSION_MODE_PATH = "/session-mode";
+const POLICY_NAMES = ["fs/write-intent", "fs/edit-intent"];
+//#endregion
+//#region src/client/llm-directory.ts
+function routeKey(provider, model) {
+	return `${provider}\u0000${model}`;
+}
+function remoteNamespace(scope, namespace) {
+	try {
+		return scope.get(`remote.${namespace}`);
+	} catch {
+		return;
+	}
+}
+function readAt(root, path) {
+	return path.reduce((node, segment) => {
+		if (Array.isArray(node)) return node[Number(segment)];
+		if (typeof node !== "object" || node === null) return void 0;
+		return Reflect.get(node, segment);
+	}, root);
+}
+function modelsOf(entry, forms) {
+	if (entry.settingsNs === "") return [];
+	const profile = readAt(forms.get(entry.settingsNs).getSnapshot().value, entry.settingsPath);
+	const models = typeof profile === "object" && profile !== null ? Reflect.get(profile, "models") : void 0;
+	if (!Array.isArray(models)) return [];
+	return models.flatMap((model) => {
+		if (typeof model !== "object" || model === null) return [];
+		const id = Reflect.get(model, "id");
+		if (typeof id !== "string") return [];
+		const name = Reflect.get(model, "name");
+		return [{
+			value: id,
+			label: typeof name === "string" && name !== "" ? name : id
+		}];
+	});
+}
+async function loadLlmProviders(scope) {
+	const llm = remoteNamespace(scope, "llm");
+	const forms = scope.get("configForms");
+	if (llm === void 0 || forms === void 0) return [];
+	const [routes, directory] = await Promise.all([llm.listProviders(), llm.listConfigurableProviders()]);
+	if (!routes.ok || !directory.ok) return [];
+	const merged = /* @__PURE__ */ new Map();
+	for (const entry of directory.value) merged.set(entry.provider, {
+		value: entry.provider,
+		label: entry.displayName,
+		settingsNs: entry.settingsNs,
+		settingsPath: [...entry.settingsPath]
+	});
+	for (const route of routes.value) if (!merged.has(route.id)) merged.set(route.id, {
+		value: route.id,
+		label: route.name,
+		settingsNs: "",
+		settingsPath: []
+	});
+	return [...merged.values()].map((entry) => ({
+		value: entry.value,
+		label: entry.label,
+		models: modelsOf(entry, forms)
+	}));
+}
+function routesOf(providers) {
+	return providers.flatMap((provider) => provider.models.map((model) => ({
+		key: routeKey(provider.value, model.value),
+		provider: provider.value,
+		providerName: provider.label,
+		model: model.value,
+		modelName: model.label
+	})));
+}
+//#endregion
+//#region src/client/bundle-config.ts
+const SESSION_MODE_NS = "session-mode";
+const BUNDLE_CONFIG_KEY = "@morlay/session-mode-profile";
+const PROTECTED_MODE_IDS = ["noop"];
+const ROLE_VALUES = ["main", "subagent"];
+const GROUPS = [
+	{
+		key: "identity",
+		labelKey: "group.identity"
+	},
+	{
+		key: "persona",
+		labelKey: "group.persona"
+	},
+	{
+		key: "tools",
+		labelKey: "group.tools"
+	},
+	{
+		key: "rules",
+		labelKey: "group.rules"
+	},
+	{
+		key: "injections",
+		labelKey: "group.injections"
+	},
+	{
+		key: "model",
+		labelKey: "group.model"
+	}
+];
+const MODE_FIELDS = [
+	{
+		path: ["name"],
+		control: "text",
+		labelKey: "field.name",
+		hintKey: "hint.name",
+		group: "identity"
+	},
+	{
+		path: ["description"],
+		control: "text",
+		labelKey: "field.description",
+		hintKey: "hint.description",
+		group: "identity"
+	},
+	{
+		path: ["role"],
+		control: "roles",
+		labelKey: "field.role",
+		hintKey: "hint.role",
+		group: "identity"
+	},
+	{
+		path: ["presetsOnly"],
+		control: "tags",
+		labelKey: "field.presetsOnly",
+		hintKey: "hint.presetsOnly",
+		group: "identity"
+	},
+	{
+		path: ["persona", "prefix"],
+		control: "multiline",
+		labelKey: "field.prefix",
+		hintKey: "hint.prefix",
+		group: "persona"
+	},
+	{
+		path: ["persona", "suffix"],
+		control: "multiline",
+		labelKey: "field.suffix",
+		hintKey: "hint.suffix",
+		group: "persona"
+	},
+	{
+		path: ["allowTools"],
+		control: "tags",
+		labelKey: "field.allowTools",
+		hintKey: "hint.allowTools",
+		group: "tools"
+	},
+	{
+		path: ["denyTools"],
+		control: "tags",
+		labelKey: "field.denyTools",
+		hintKey: "hint.denyTools",
+		group: "tools"
+	},
+	{
+		path: ["allowSkills"],
+		control: "tags",
+		labelKey: "field.allowSkills",
+		hintKey: "hint.allowSkills",
+		group: "tools"
+	},
+	{
+		path: ["denySkills"],
+		control: "tags",
+		labelKey: "field.denySkills",
+		hintKey: "hint.denySkills",
+		group: "tools"
+	},
+	{
+		path: ["allowPolicies"],
+		control: "tags",
+		labelKey: "field.allowPolicies",
+		hintKey: "hint.allowPolicies",
+		group: "rules"
+	},
+	{
+		path: ["denyPolicies"],
+		control: "tags",
+		labelKey: "field.denyPolicies",
+		hintKey: "hint.denyPolicies",
+		group: "rules"
+	},
+	{
+		path: ["instructions"],
+		control: "switch",
+		labelKey: "field.instructions",
+		hintKey: "hint.instructions",
+		group: "injections"
+	},
+	{
+		path: ["skills"],
+		control: "tri",
+		labelKey: "field.skills",
+		hintKey: "hint.skills",
+		group: "injections"
+	},
+	{
+		path: ["runtimeContext"],
+		control: "switch",
+		labelKey: "field.runtimeContext",
+		hintKey: "hint.runtimeContext",
+		group: "injections"
+	},
+	{
+		path: ["defaultModel", "reasoningEffort"],
+		control: "text",
+		labelKey: "field.reasoningEffort",
+		hintKey: "hint.reasoningEffort",
+		group: "model"
+	}
+];
+function unwrapService(value) {
+	if (value === void 0) return void 0;
+	return value[Symbol.for("cordis.original")] ?? value;
+}
+function fieldKey(path) {
+	return JSON.stringify(path);
+}
+function createBundleConfigFace(ctx, t, hintsOf = () => void 0) {
+	const forms = ctx.configForms;
+	const hints = () => unwrapService(hintsOf());
+	const deps = () => ({
+		form: forms.get(SESSION_MODE_NS),
+		describe: forms.describe(),
+		rehydrate: (serialized) => ctx.settingsSchema.rehydrate(serialized),
+		validate: (schema, value) => validateSection(schema, value, t),
+		t: ctx.locale.bind("settings.schema-form"),
+		hints: {
+			keysFor: () => [],
+			textFor: (path) => hints()?.textFor("session-mode", path) ?? {},
+			selectFor: (path) => hints()?.selectFor(SESSION_MODE_NS, path),
+			sourceFor: (name) => hints()?.sourceFor(name)
+		}
+	});
+	const controller = new SchemaFormController(SESSION_MODE_NS, deps());
+	const face = controller.face();
+	const form = forms.get(SESSION_MODE_NS);
+	const statusStore = createSnapshotStore(form.getSnapshot().status);
+	const unsubscribeStatus = form.subscribe(() => {
+		statusStore.set(form.getSnapshot().status);
+	});
+	const modelsStore = createSnapshotStore({
+		status: "loading",
+		routes: []
+	});
+	const loadModels = async () => {
+		try {
+			const providers = await loadLlmProviders(ctx);
+			modelsStore.set({
+				status: "ready",
+				routes: routesOf(providers)
+			});
+		} catch {
+			modelsStore.set({
+				status: "error",
+				routes: []
+			});
+		}
+	};
+	const remote = ctx.get("remote");
+	const unsubscribeModels = typeof remote?.$on !== "function" ? [] : [remote.$on("llm/adapters-updated", () => {
+		loadModels();
+	}), remote.$on("settings/document-updated", () => {
+		loadModels();
+	})];
+	loadModels();
+	const diagnose = () => {
+		const view = forms.describe().getSnapshot().view;
+		const namespaces = view?.namespaces.map((row) => row.ns) ?? [];
+		const live = controller.face().hooks.schemaForm.getSnapshot();
+		const controllerSummary = `store configured=${String(live.configured)} walked=${String(live.walked.length)}`;
+		const own = view?.namespaces.find((row) => row.ns === SESSION_MODE_NS);
+		if (own === void 0) return {
+			namespaces,
+			controller: controllerSummary,
+			problem: `describe has no namespace "${SESSION_MODE_NS}"`
+		};
+		try {
+			const schema = ctx.settingsSchema.rehydrate(own.schema);
+			const renderable = projectRoot(own.schema, (serialized) => ctx.settingsSchema.rehydrate(serialized)) !== void 0;
+			let probe;
+			try {
+				const rebuilt = new SchemaFormController(SESSION_MODE_NS, deps());
+				probe = `probe configured=${String(rebuilt.face().hooks.schemaForm.getSnapshot().configured)}`;
+				rebuilt.dispose();
+			} catch (error) {
+				probe = `probe threw: ${error instanceof Error ? error.message : String(error)}`;
+			}
+			return {
+				namespaces,
+				controller: `${controllerSummary}; ${probe}`,
+				problem: renderable ? "renderable" : `schema root is "${String(schema.type)}"`
+			};
+		} catch (error) {
+			return {
+				namespaces,
+				controller: controllerSummary,
+				problem: `schema rehydrate failed: ${error instanceof Error ? error.message : String(error)}`
+			};
+		}
+	};
+	const resync = () => {
+		statusStore.set(form.getSnapshot().status);
+		controller.refresh();
+	};
+	return {
+		face: {
+			hooks: {
+				bundleConfig: face.hooks.schemaForm,
+				bundleStatus: statusStore,
+				bundleModels: modelsStore
+			},
+			diagnose,
+			resync,
+			set: (path, value) => {
+				face.set(path, value);
+			},
+			editText: (path, text) => {
+				if (text === "") face.clear(path);
+				else face.setText(path, text, (raw) => ({
+					kind: "value",
+					value: raw
+				}));
+			},
+			clear: (path) => {
+				face.clear(path);
+			},
+			appendItem: (path) => {
+				face.appendItem(path);
+			},
+			removeItem: (path, index) => {
+				face.removeItem(path, index);
+			},
+			addMode: (id) => {
+				const trimmed = id.trim();
+				if (trimmed === "") return;
+				face.addKey(["modes"], trimmed);
+				face.setText([
+					"modes",
+					trimmed,
+					"name"
+				], trimmed, (raw) => ({
+					kind: "value",
+					value: raw
+				}));
+			},
+			removeMode: (id) => {
+				if (PROTECTED_MODE_IDS.includes(id)) return;
+				face.removeKey(["modes"], id);
+			},
+			save: () => {
+				face.save();
+			},
+			discard: () => {
+				face.discard();
+			}
+		},
+		refresh: resync,
+		dispose: () => {
+			unsubscribeStatus();
+			for (const off of unsubscribeModels) off?.();
+			controller.dispose();
+		}
+	};
+}
+function validateSection(schema, value, t) {
+	try {
+		schema(value);
+	} catch (error) {
+		return failureOf(error);
+	}
+	return rosterProblem(value, t);
+}
+function rosterProblem(value, t) {
+	if (typeof value !== "object" || value === null) return void 0;
+	const modes = Reflect.get(value, "modes");
+	if (typeof modes !== "object" || modes === null || Array.isArray(modes)) return {
+		message: t("violation.modesEmpty"),
+		path: ["modes"]
+	};
+	const ids = Object.keys(modes);
+	if (ids.length === 0) return {
+		message: t("violation.modesEmpty"),
+		path: ["modes"]
+	};
+	const selected = Reflect.get(value, "default");
+	if (typeof selected === "string" && selected !== "" && !ids.includes(selected)) return {
+		message: t("violation.defaultMissing"),
+		path: ["default"]
+	};
+	for (const id of ids) {
+		const mode = Reflect.get(modes, id);
+		const model = typeof mode === "object" && mode !== null ? Reflect.get(mode, "defaultModel") : void 0;
+		if (typeof model !== "object" || model === null) continue;
+		const provider = Reflect.get(model, "provider");
+		const name = Reflect.get(model, "model");
+		if (provider === void 0 && name === void 0) continue;
+		if (typeof provider === "string" && provider !== "" && typeof name === "string" && name !== "") continue;
+		return {
+			message: t("violation.modelPair"),
+			path: [
+				"modes",
+				id,
+				"defaultModel"
+			]
+		};
+	}
+}
+function projectBundleConfig(state, t, status = "ready") {
+	const read = (path) => state.fields.get(fieldKey(path));
+	const optionsAt = (path) => state.options.get(fieldKey(path)) ?? [];
+	const invalidAt = (path) => state.invalidAt.get(fieldKey(path)) ?? read(path)?.invalid;
+	const modes = collectModeIds(state);
+	const selected = textOf(read(["default"]));
+	return {
+		available: state.available,
+		writable: state.writable,
+		dirty: state.dirty,
+		invalid: state.invalid,
+		saving: state.saving,
+		failed: state.failed,
+		configured: state.configured,
+		readiness: state.configured ? "ready" : status === "loading" ? "loading" : status === "ready" ? "unreadable" : "missing",
+		defaultMode: {
+			value: selected,
+			options: modes.map((id) => ({
+				value: id,
+				label: labelOf(id, read)
+			})),
+			invalid: invalidAt(["default"]) ?? (selected === "" || modes.includes(selected) ? void 0 : t("violation.defaultMissing"))
+		},
+		modes: modes.map((id) => ({
+			id,
+			title: labelOf(id, read),
+			role: arrayOf(read([
+				"modes",
+				id,
+				"role"
+			])),
+			summary: summaryOf(id, read, t),
+			model: modelOf(id, read),
+			deletable: !PROTECTED_MODE_IDS.includes(id),
+			staged: MODE_FIELDS.some((spec) => read([
+				"modes",
+				id,
+				...spec.path
+			])?.staged === true),
+			groups: GROUPS.map((group) => ({
+				key: group.key,
+				label: t(group.labelKey),
+				fields: MODE_FIELDS.filter((spec) => spec.group === group.key).map((spec) => fieldView(id, spec, read, optionsAt, invalidAt, t))
+			}))
+		})),
+		violation: state.violation?.message
+	};
+}
+function labelOf(id, read) {
+	const name = textOf(read([
+		"modes",
+		id,
+		"name"
+	]));
+	return name === "" ? id : name;
+}
+function collectModeIds(state) {
+	const ids = [];
+	for (const item of state.walked) {
+		if (item.path.length < 2 || item.path[0] !== "modes") continue;
+		const id = item.path[1];
+		if (id === void 0 || ids.includes(id)) continue;
+		ids.push(id);
+	}
+	return ids;
+}
+function modelOf(id, read) {
+	if (read([
+		"modes",
+		id,
+		"defaultModel"
+	]) === void 0) return void 0;
+	return {
+		provider: textOf(read([
+			"modes",
+			id,
+			"defaultModel",
+			"provider"
+		])),
+		model: textOf(read([
+			"modes",
+			id,
+			"defaultModel",
+			"model"
+		]))
+	};
+}
+function fieldView(id, spec, read, optionsAt, invalidAt, t) {
+	const path = [
+		"modes",
+		id,
+		...spec.path
+	];
+	const field = read(path);
+	const common = {
+		key: fieldKey(path),
+		path,
+		control: spec.control,
+		label: t(spec.labelKey),
+		hint: t(spec.hintKey),
+		present: field !== void 0,
+		overridden: field?.overridden === true,
+		options: optionsAt(path),
+		invalid: invalidAt(path)
+	};
+	if (spec.control === "tags" || spec.control === "roles") return {
+		...common,
+		text: "",
+		value: arrayOf(field)
+	};
+	if (spec.control === "switch") return {
+		...common,
+		text: "",
+		value: field?.value === true
+	};
+	if (spec.control === "tri") return {
+		...common,
+		text: "",
+		value: triOf(field)
+	};
+	return {
+		...common,
+		text: textOf(field),
+		value: field?.value
+	};
+}
+function triOf(field) {
+	if (field === void 0 || field.value === void 0) return "unset";
+	return field.value === true ? "on" : "off";
+}
+function summaryOf(id, read, t) {
+	const allowed = arrayOf(read([
+		"modes",
+		id,
+		"allowTools"
+	]));
+	const denied = arrayOf(read([
+		"modes",
+		id,
+		"denyTools"
+	]));
+	const provider = read([
+		"modes",
+		id,
+		"defaultModel",
+		"provider"
+	])?.value;
+	const model = read([
+		"modes",
+		id,
+		"defaultModel",
+		"model"
+	])?.value;
+	return `${allowed.length > 0 ? t("summary.tools", { n: String(allowed.length) }) : denied.length > 0 ? t("summary.denyTools", { n: String(denied.length) }) : t("summary.allTools")} · ${typeof model === "string" && model !== "" ? `${typeof provider === "string" && provider !== "" ? `${provider} / ` : ""}${model}` : t("summary.globalModel")}`;
+}
+function textOf(field) {
+	if (field === void 0) return "";
+	if (typeof field.text === "string") return field.text;
+	return typeof field.value === "string" ? field.value : "";
+}
+function arrayOf(field) {
+	const value = field?.value;
+	return Array.isArray(value) ? value.map((item) => String(item)) : [];
+}
+const ROLES = ROLE_VALUES;
+//#endregion
+//#region src/client/BundleConfigPage.tsx
+function BundleConfigPage(props) {
+	const { t, view } = props;
+	const face = {
+		set: props.set,
+		editText: props.editText,
+		clear: props.clear,
+		appendItem: props.appendItem,
+		removeItem: props.removeItem,
+		addMode: props.addMode,
+		removeMode: props.removeMode,
+		save: props.save,
+		discard: props.discard
+	};
+	const snapshot = props.useBundleConfig((current) => current);
+	const status = props.useBundleStatus((current) => current);
+	const models = props.useBundleModels((current) => current);
+	const state = useMemo(() => projectBundleConfig(snapshot, t, status), [
+		snapshot,
+		t,
+		status
+	]);
+	const [expanded, setExpanded] = useState(() => /* @__PURE__ */ new Set());
+	const [addingId, setAddingId] = useState("");
+	const [addingOpen, setAddingOpen] = useState(false);
+	const [removing, setRemoving] = useState(null);
+	const resync = props.resync;
+	useEffect(() => {
+		resync();
+	}, [resync]);
+	if (view !== "page") return null;
+	if (state.readiness !== "ready") {
+		const diagnosis = props.diagnose();
+		const message = state.readiness === "loading" ? t("configured.loading") : state.readiness === "missing" ? t("configured.missing") : t("configured.unreadable", { problem: diagnosis.problem });
+		return /* @__PURE__ */ jsxs("div", {
+			"data-bundle-config": state.readiness,
+			"data-namespace": SESSION_MODE_NS,
+			children: [/* @__PURE__ */ jsx(Text, {
+				as: "p",
+				size: "sm",
+				tone: "tertiary",
+				"data-namespaces": diagnosis.namespaces.join(","),
+				"data-problem": diagnosis.problem,
+				"data-controller": diagnosis.controller,
+				children: message
+			}), state.readiness !== "unreadable" ? null : /* @__PURE__ */ jsx(Text, {
+				as: "p",
+				size: "xs",
+				tone: "tertiary",
+				mono: true,
+				"data-diagnosis": "true",
+				children: `${diagnosis.problem} · ${diagnosis.controller} · namespaces=[${diagnosis.namespaces.join(", ")}]`
+			})]
+		});
+	}
+	const labels = {
+		unavailable: t("unavailable"),
+		readOnly: t("readOnly"),
+		saveFailed: t("saveFailed"),
+		save: t("save"),
+		saving: t("saving")
+	};
+	const toggle = (id) => {
+		setExpanded((previous) => {
+			const next = new Set(previous);
+			if (next.has(id)) next.delete(id);
+			else next.add(id);
+			return next;
+		});
+	};
+	return /* @__PURE__ */ jsxs(SettingsForm, {
+		labels,
+		state,
+		onSave: face.save,
+		onDiscard: face.discard,
+		children: [
+			/* @__PURE__ */ jsxs(Stack, {
+				gap: 16,
+				"data-bundle-config": "page",
+				children: [/* @__PURE__ */ jsx(Stack, {
+					as: "section",
+					gap: 8,
+					"data-section": "default",
+					children: /* @__PURE__ */ jsx(SettingsFieldRow, {
+						label: t("default.label"),
+						hint: t("default.hint"),
+						layout: "inline",
+						...state.defaultMode.invalid === void 0 ? {} : { invalid: state.defaultMode.invalid },
+						"data-field": "default",
+						"data-control": "choice",
+						children: /* @__PURE__ */ jsx(SearchSelect, {
+							label: t("default.label"),
+							value: state.defaultMode.value,
+							emptyLabel: t("tri.unset"),
+							options: state.defaultMode.options.map((option) => ({
+								value: String(option.value),
+								...option.label === void 0 ? {} : { label: option.label }
+							})),
+							searchLabel: t("select.search"),
+							noMatchLabel: t("select.noMatch"),
+							disabled: !state.writable,
+							onSelect: (next) => {
+								if (next === "") face.clear(["default"]);
+								else face.set(["default"], next);
+							}
+						})
+					})
+				}), /* @__PURE__ */ jsxs(Stack, {
+					as: "section",
+					gap: 8,
+					"data-section": "modes",
+					children: [/* @__PURE__ */ jsxs(Row, {
+						gap: 8,
+						justify: "between",
+						children: [/* @__PURE__ */ jsxs(Stack, {
+							gap: 2,
+							grow: true,
+							children: [/* @__PURE__ */ jsx(Text, {
+								as: "h4",
+								size: "md",
+								tone: "primary",
+								weight: "strong",
+								children: t("modes.label")
+							}), /* @__PURE__ */ jsx(Text, {
+								as: "p",
+								size: "sm",
+								tone: "tertiary",
+								children: t("modes.hint")
+							})]
+						}), /* @__PURE__ */ jsx(IconButton, {
+							label: t("add.label"),
+							"data-action": "open-add-mode",
+							disabled: !state.writable,
+							onClick: () => {
+								setAddingId("");
+								setAddingOpen(true);
+							},
+							children: /* @__PURE__ */ jsx(IconPlusOutlineRegular, {})
+						})]
+					}), state.modes.map((mode) => /* @__PURE__ */ jsx(ModeCard, {
+						mode,
+						models,
+						open: expanded.has(mode.id),
+						writable: state.writable,
+						t,
+						face,
+						onRequestRemove: () => {
+							setRemoving(mode);
+						},
+						onToggle: () => {
+							toggle(mode.id);
+						}
+					}, mode.id))]
+				})]
+			}),
+			/* @__PURE__ */ jsx(Modal, {
+				open: addingOpen,
+				onClose: () => {
+					setAddingOpen(false);
+				},
+				title: t("add.label"),
+				closeLabel: t("add.close"),
+				description: t("add.hint"),
+				footer: /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(Button, {
+					variant: "outline",
+					onClick: () => {
+						setAddingOpen(false);
+					},
+					children: t("add.cancel")
+				}), /* @__PURE__ */ jsx(Button, {
+					variant: "primary",
+					"data-action": "add-mode",
+					disabled: addingId.trim() === "",
+					onClick: () => {
+						const id = addingId.trim();
+						face.addMode(id);
+						setAddingId("");
+						setAddingOpen(false);
+						setExpanded((previous) => new Set(previous).add(id));
+					},
+					children: t("add.confirm")
+				})] }),
+				children: /* @__PURE__ */ jsx(Input, {
+					"data-field": "new-mode",
+					"data-modal-autofocus": true,
+					value: addingId,
+					placeholder: t("add.placeholder"),
+					"aria-label": t("add.label"),
+					onChange: (event) => {
+						setAddingId(event.currentTarget.value);
+					}
+				})
+			}),
+			/* @__PURE__ */ jsx(Modal, {
+				open: removing !== null,
+				onClose: () => {
+					setRemoving(null);
+				},
+				title: t("remove.title"),
+				closeLabel: t("remove.close"),
+				description: t("remove.description", { name: removing?.title ?? "" }),
+				footer: /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(Button, {
+					variant: "outline",
+					onClick: () => {
+						setRemoving(null);
+					},
+					children: t("remove.cancel")
+				}), /* @__PURE__ */ jsx(Button, {
+					variant: "primary",
+					tone: "danger",
+					"data-action": "confirm-remove",
+					onClick: () => {
+						if (removing !== null) face.removeMode(removing.id);
+						setRemoving(null);
+					},
+					children: t("remove.confirm")
+				})] })
+			})
+		]
+	});
+}
+function ModeCard({ mode, models, open, writable, t, face, onRequestRemove, onToggle }) {
+	const hasModel = mode.model !== void 0;
+	return /* @__PURE__ */ jsx(Stack, {
+		boxed: true,
+		pad: "card",
+		"data-mode": mode.id,
+		"data-deletable": mode.deletable ? "true" : "false",
+		children: /* @__PURE__ */ jsx(DisclosureRow, {
+			icon: /* @__PURE__ */ jsx(IconAgentPresetOutlineRegular, {}),
+			title: mode.title,
+			open,
+			expandable: true,
+			expandOnRowClick: true,
+			onToggle,
+			keepContentWhenOpen: true,
+			collapsedContent: /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(Text, {
+				as: "code",
+				size: "sm",
+				tone: "tertiary",
+				"data-mode-id": true,
+				children: mode.id
+			}), /* @__PURE__ */ jsxs(Row, {
+				gap: 8,
+				push: true,
+				children: [/* @__PURE__ */ jsx(Text, {
+					as: "span",
+					size: "sm",
+					tone: "tertiary",
+					children: mode.summary
+				}), mode.deletable ? /* @__PURE__ */ jsx(IconButton, {
+					size: "sm",
+					"data-action": "remove-mode",
+					disabled: !writable,
+					label: t("removeNamed", { name: mode.title }),
+					onClick: (event) => {
+						event.stopPropagation();
+						onRequestRemove();
+					},
+					children: /* @__PURE__ */ jsx(IconTrashOutlineRegular, {})
+				}) : /* @__PURE__ */ jsx(Text, {
+					as: "span",
+					size: "sm",
+					tone: "tertiary",
+					"data-protected": "true",
+					children: t("protected")
+				})]
+			})] }),
+			children: /* @__PURE__ */ jsx(Stack, {
+				gap: 14,
+				pad: "body",
+				children: mode.groups.map((group) => /* @__PURE__ */ jsxs(Stack, {
+					gap: 0,
+					"data-group": group.key,
+					children: [/* @__PURE__ */ jsx(Row, {
+						gap: 8,
+						justify: "between",
+						children: /* @__PURE__ */ jsx(Text, {
+							size: "sm",
+							tone: "secondary",
+							weight: "strong",
+							children: group.label
+						})
+					}), group.key === "model" ? /* @__PURE__ */ jsxs(Fragment, { children: [
+						/* @__PURE__ */ jsx(SettingsFieldRow, {
+							label: t("field.defaultModel"),
+							hint: t("hint.defaultModel"),
+							layout: "inline",
+							"data-control": "default-model",
+							children: /* @__PURE__ */ jsx(Switch, {
+								checked: hasModel,
+								label: t("field.defaultModel"),
+								disabled: !writable,
+								onChange: (next) => {
+									if (next) face.set([
+										"modes",
+										mode.id,
+										"defaultModel"
+									], {
+										provider: "",
+										model: ""
+									});
+									else face.clear([
+										"modes",
+										mode.id,
+										"defaultModel"
+									]);
+								}
+							})
+						}),
+						!hasModel ? null : /* @__PURE__ */ jsx(SettingsFieldRow, {
+							label: t("field.modelRoute"),
+							hint: t("hint.modelRoute"),
+							divider: true,
+							"data-control": "model-routes",
+							children: /* @__PURE__ */ jsx(ModelRouteList, {
+								label: t("field.modelRoute"),
+								candidates: models.routes,
+								selectedKey: mode.model === void 0 || mode.model.provider === "" ? void 0 : routeKey(mode.model.provider, mode.model.model),
+								disabled: !writable,
+								status: models.status,
+								loadingLabel: t("model.loading"),
+								errorLabel: t("model.error"),
+								emptyLabel: t("model.empty"),
+								onSelect: (candidate) => {
+									face.set([
+										"modes",
+										mode.id,
+										"defaultModel"
+									], {
+										provider: candidate.provider,
+										model: candidate.model
+									});
+								}
+							})
+						}),
+						group.fields.map((field, index) => /* @__PURE__ */ jsx(FieldRow, {
+							field,
+							writable,
+							t,
+							face,
+							divider: index > 0 || hasModel
+						}, field.key))
+					] }) : group.fields.map((field, index) => /* @__PURE__ */ jsx(FieldRow, {
+						field,
+						writable,
+						t,
+						face,
+						divider: index > 0
+					}, field.key))]
+				}, group.key))
+			})
+		})
+	});
+}
+function FieldRow({ field, writable, divider, t, face }) {
+	if (field.control === "choice" && !field.present) return null;
+	return /* @__PURE__ */ jsx(SettingsFieldRow, {
+		label: field.label,
+		hint: field.hint,
+		divider,
+		layout: field.control === "switch" || field.control === "tri" || field.control === "roles" ? "inline" : "stack",
+		...field.overridden ? { overriddenLabel: t("overridden") } : {},
+		...field.control === "text" ? {
+			resetLabel: t("field.reset"),
+			onReset: () => {
+				face.clear(field.path);
+			}
+		} : {},
+		...field.invalid === void 0 ? {} : { invalid: field.invalid },
+		"data-field": field.path.join("."),
+		"data-control": field.control,
+		children: /* @__PURE__ */ jsx(FieldControl, {
+			field,
+			writable,
+			t,
+			face
+		})
+	});
+}
+function FieldControl({ field, writable, t, face }) {
+	const disabled = !writable;
+	const id = useId();
+	switch (field.control) {
+		case "multiline": return /* @__PURE__ */ jsx(MultilineField, {
+			value: field.text,
+			rows: 3,
+			disabled,
+			"aria-label": field.label,
+			onChange: (event) => {
+				face.editText(field.path, event.currentTarget.value);
+			}
+		});
+		case "choice": return /* @__PURE__ */ jsx(SearchSelect, {
+			label: field.label,
+			value: field.text,
+			emptyLabel: t("tri.unset"),
+			options: field.options.map((option) => ({
+				value: String(option.value),
+				...option.label === void 0 ? {} : { label: option.label }
+			})),
+			searchLabel: t("select.search"),
+			noMatchLabel: t("select.noMatch"),
+			disabled,
+			onSelect: (next) => {
+				if (next === "") face.clear(field.path);
+				else face.set(field.path, next);
+			}
+		});
+		case "switch": return /* @__PURE__ */ jsx(Switch, {
+			checked: field.value === true,
+			label: field.label,
+			disabled,
+			onChange: (next) => {
+				face.set(field.path, next);
+			}
+		});
+		case "tri": return /* @__PURE__ */ jsx(SegmentedControl, {
+			id: `${id}-tri`,
+			label: field.label,
+			value: triValue(field),
+			disabled,
+			options: [
+				{
+					value: "unset",
+					label: t("tri.unset")
+				},
+				{
+					value: "on",
+					label: t("tri.on")
+				},
+				{
+					value: "off",
+					label: t("tri.off")
+				}
+			],
+			onChange: (next) => {
+				if (next === "unset") face.clear(field.path);
+				else face.set(field.path, next === "on");
+			}
+		});
+		case "roles": return /* @__PURE__ */ jsx(Row, {
+			gap: 6,
+			wrap: true,
+			"data-control": "roles",
+			children: ROLES.map((role) => {
+				const active = Array.isArray(field.value) && field.value.includes(role);
+				return /* @__PURE__ */ jsx(Button, {
+					variant: active ? "primary" : "outline",
+					size: "sm",
+					"data-mode-role": role,
+					disabled,
+					"aria-pressed": active,
+					onClick: () => {
+						const current = Array.isArray(field.value) ? field.value.map(String) : [];
+						const wanted = active ? current.filter((value) => value !== role) : [...current.filter((value) => value !== role), role];
+						face.set(field.path, wanted);
+					},
+					children: t(`role.${role}`)
+				}, role);
+			})
+		});
+		case "tags": return /* @__PURE__ */ jsx(TagInput, {
+			value: Array.isArray(field.value) ? field.value.map(String) : [],
+			options: field.options.map((option) => ({
+				value: String(option.value),
+				...option.label === void 0 ? {} : { label: option.label }
+			})),
+			placeholder: t("tags.placeholder"),
+			label: field.label,
+			noMatchLabel: t("select.noMatch"),
+			removeLabel: (name) => t("tags.remove", { name }),
+			disabled,
+			onChange: (next) => {
+				face.set(field.path, next);
+			}
+		});
+		case "text": return /* @__PURE__ */ jsx(Input, {
+			value: field.text,
+			"aria-label": field.label,
+			disabled,
+			onChange: (event) => {
+				face.editText(field.path, event.currentTarget.value);
+			}
+		});
+	}
+}
+function triValue(field) {
+	return field.value === "unset" || field.value === "on" || field.value === "off" ? field.value : "unset";
+}
+//#endregion
+//#region src/client/bundle-locales.ts
+const BUNDLE_NS = "session-mode-bundle";
+const bundleZh = {
+	"default.label": "新会话的默认模式",
+	"default.hint": "还没选过模式的会话从这里开始。",
+	"modes.label": "模式",
+	"modes.hint": "展开一个模式，改它的提示词、工具与技能、上游规则和注入内容。",
+	"add.label": "添加模式",
+	"add.placeholder": "模式 id",
+	"add.confirm": "添加",
+	"add.cancel": "取消",
+	"add.close": "关闭",
+	"add.hint": "给新模式一个 id（选择器与列表里也显示它，加好后可以再改名称）。",
+	removeNamed: "删除模式 {name}",
+	protected: "内置模式，不提供删除",
+	untitled: "（未命名）",
+	overridden: "已覆盖",
+	"group.identity": "基本信息",
+	"group.persona": "提示词",
+	"group.tools": "工具与技能",
+	"group.rules": "上游规则",
+	"group.injections": "请求里注入什么",
+	"group.model": "默认模型",
+	"role.main": "会话可选",
+	"role.subagent": "子代理可用",
+	"field.name": "名称",
+	"field.description": "一句话说明",
+	"field.role": "角色",
+	"field.presetsOnly": "允许挂的 preset",
+	"field.prefix": "提示词前缀",
+	"field.suffix": "提示词后缀",
+	"field.allowTools": "允许的工具",
+	"field.denyTools": "禁用的工具",
+	"field.allowSkills": "允许的技能",
+	"field.denySkills": "禁用的技能",
+	"field.allowPolicies": "生效的规则",
+	"field.denyPolicies": "禁用的规则",
+	"field.instructions": "工作区指令",
+	"field.skills": "技能目录",
+	"field.runtimeContext": "动态快照",
+	"field.defaultModel": "设默认模型",
+	"field.modelRoute": "用哪个模型",
+	"field.reasoningEffort": "思考档位",
+	"field.reset": "恢复默认",
+	"hint.name": "选择器和列表里显示的名字。",
+	"hint.description": "一句话说明这个模式做什么。",
+	"hint.role": "「会话可选」= 用户能在会话里选它；「子代理可用」= 可以把子代理跑在这个模式下。",
+	"hint.presetsOnly": "只允许这个模式挂这些 preset（行清单由挂着的那份提供）；不填 = 允许全部（哪份 preset 都行，切模式也不动它）。有值时切到这个模式，会话当前那份不在名单里就换成名单第一个。",
+	"hint.prefix": "加在系统提示词开头的一段话。",
+	"hint.suffix": "加在系统提示词结尾的一段话。",
+	"hint.allowTools": "只允许这些工具；不填 = 不限制（用会话当前 preset 的全部工具）。",
+	"hint.denyTools": "从上面那份里去掉这些工具。",
+	"hint.allowSkills": "只允许这些技能；不填 = 不限制。",
+	"hint.denySkills": "这些技能不列进技能目录，`skill` 工具也加载不了。",
+	"hint.allowPolicies": "只让这些上游规则生效；不填 = 全部生效。",
+	"hint.denyPolicies": "禁用这些上游规则，它的判断连拒绝一起丢掉。",
+	"hint.instructions": "每步都把工作区指令（AGENTS.md 之类）发给模型；关掉就不发。",
+	"hint.skills": "每步都把技能目录发给模型；默认按这个模式的工具名单自动判断。",
+	"hint.runtimeContext": "每步都把沙箱与审批策略发给模型。",
+	"hint.defaultModel": "开 = 这个模式自带一个默认模型（会话还没选过模型时用它）；关 = 跟随全局模型。",
+	"hint.modelRoute": "从部署里已设置的模型里挑一条：服务商与模型是一对，选它等于两个一起定。",
+	"hint.reasoningEffort": "思考档位；不填用服务商默认。",
+	"model.loading": "正在读部署里已设置的模型…",
+	"model.error": "读不出部署里已设置的模型。",
+	"model.empty": "部署里还没有已设置的模型。",
+	"tags.placeholder": "加一个后回车，或粘贴一串",
+	"tags.add": "添加",
+	"tags.remove": "移除 {name}",
+	"select.search": "搜索候选",
+	"select.noMatch": "没有匹配的候选",
+	"tri.unset": "默认",
+	"tri.on": "开",
+	"tri.off": "关",
+	"remove.title": "删除模式",
+	"remove.description": "删除 {name}？删除只在保存之后生效，保存之前还可以丢弃。",
+	"remove.confirm": "删除",
+	"remove.cancel": "取消",
+	"remove.close": "关闭",
+	"model.set": "设置默认模型",
+	"model.follow": "改为跟随全局",
+	save: "保存",
+	saving: "保存中…",
+	saveFailed: "保存没有生效，请重试。",
+	readOnly: "这份部署的配置是只读的。",
+	unavailable: "这一行当前不可写。",
+	notSaved: "没有保存：{message}",
+	"configured.loading": "正在读取这一行的配置…",
+	"configured.missing": "设置面里没有 `session-mode` 这一行：没装、被禁用，或者还没装配成功（依赖没到齐时会一直 PENDING）。",
+	"configured.unreadable": "`session-mode` 这一行在跑，但这份配置读不出来（{problem}）。",
+	"violation.modesEmpty": "至少要有一种模式。",
+	"violation.defaultMissing": "默认模式不在模式清单里。",
+	"violation.modelPair": "默认模型要同时给出服务商与模型。",
+	"summary.allTools": "全部工具",
+	"summary.tools": "{n} 件工具",
+	"summary.denyTools": "禁 {n} 件",
+	"summary.globalModel": "跟随全局模型"
+};
+const bundleEn = {
+	"default.label": "Mode for new sessions",
+	"default.hint": "Sessions that never picked a mode start here.",
+	"modes.label": "Modes",
+	"modes.hint": "Expand a mode to edit its prompt, tools and skills, upstream rules, and injected content.",
+	"add.label": "Add a mode",
+	"add.placeholder": "mode id",
+	"add.confirm": "Add",
+	"add.cancel": "Cancel",
+	"add.close": "Close",
+	"add.hint": "Give the new mode an id (it also shows in pickers and lists; rename it after adding).",
+	removeNamed: "Delete mode {name}",
+	protected: "Built-in mode: no delete",
+	untitled: "(untitled)",
+	overridden: "Overridden",
+	"group.identity": "Basics",
+	"group.persona": "Prompt",
+	"group.tools": "Tools and skills",
+	"group.rules": "Upstream rules",
+	"group.injections": "Injected into requests",
+	"group.model": "Default model",
+	"role.main": "Selectable in sessions",
+	"role.subagent": "Usable for subagents",
+	"field.name": "Name",
+	"field.description": "One-line description",
+	"field.role": "Roles",
+	"field.presetsOnly": "Presets it may ride on",
+	"field.prefix": "Prompt prefix",
+	"field.suffix": "Prompt suffix",
+	"field.allowTools": "Allowed tools",
+	"field.denyTools": "Denied tools",
+	"field.allowSkills": "Allowed skills",
+	"field.denySkills": "Denied skills",
+	"field.allowPolicies": "Rules in force",
+	"field.denyPolicies": "Rules disabled",
+	"field.instructions": "Workspace instructions",
+	"field.skills": "Skill catalog",
+	"field.runtimeContext": "Runtime snapshot",
+	"field.defaultModel": "Default model",
+	"field.modelRoute": "Which model",
+	"field.reasoningEffort": "Reasoning effort",
+	"field.reset": "Reset",
+	"hint.name": "Shown in the picker and in lists.",
+	"hint.description": "One line saying what this mode is for.",
+	"hint.role": "Selectable in sessions = the user can pick it; usable for subagents = subagents may run in it.",
+	"hint.presetsOnly": "Only these presets may back this mode (the one it rides on supplies the row list); empty = every preset is allowed (and selecting the mode switches nothing). When set, selecting the mode switches to the first entry if the session's current preset is not listed.",
+	"hint.prefix": "Text prepended to the system prompt.",
+	"hint.suffix": "Text appended to the system prompt.",
+	"hint.allowTools": "Only these tools; empty = no restriction (every tool of the session's preset).",
+	"hint.denyTools": "Those tools are removed from the list above.",
+	"hint.allowSkills": "Only these skills; empty = no restriction.",
+	"hint.denySkills": "Those skills leave the catalog, and the `skill` tool cannot load them.",
+	"hint.allowPolicies": "Only these upstream rules stay in force; empty = all of them.",
+	"hint.denyPolicies": "Those upstream rules are disabled, rejection included.",
+	"hint.instructions": "Sends the workspace instructions (AGENTS.md and friends) with every step; off means it is not sent.",
+	"hint.skills": "Sends the skill catalog with every step; default decides from this mode's tool lists.",
+	"hint.runtimeContext": "Sends the sandbox and approval policies with every step.",
+	"hint.defaultModel": "On = this mode carries a default model (used while a session has picked none); off = follow the global model.",
+	"hint.modelRoute": "Pick one model already set up in this deployment: a provider and a model come as one route, so choosing it sets both.",
+	"hint.reasoningEffort": "Reasoning effort; empty uses the provider default.",
+	"model.loading": "Reading the models set up in this deployment…",
+	"model.error": "Could not read the models set up in this deployment.",
+	"model.empty": "No model is set up in this deployment yet.",
+	"tags.placeholder": "Add one and press Enter, or paste a list",
+	"tags.add": "Add",
+	"tags.remove": "Remove {name}",
+	"select.search": "Search candidates",
+	"select.noMatch": "No matching candidate",
+	"tri.unset": "Default",
+	"tri.on": "On",
+	"tri.off": "Off",
+	"remove.title": "Delete mode",
+	"remove.description": "Delete {name}? The deletion applies on save; until then you can discard it.",
+	"remove.confirm": "Delete",
+	"remove.cancel": "Cancel",
+	"remove.close": "Close",
+	"model.set": "Set a default model",
+	"model.follow": "Follow the global model",
+	save: "Save",
+	saving: "Saving…",
+	saveFailed: "The save did not take effect; try again.",
+	readOnly: "This deployment stores settings read-only.",
+	unavailable: "This row is not writable right now.",
+	notSaved: "Not saved: {message}",
+	"configured.loading": "Reading this row's configuration…",
+	"configured.missing": "The settings surface has no `session-mode` row: not installed, disabled, or not composed yet (it stays PENDING while a dependency is missing).",
+	"configured.unreadable": "The `session-mode` row is running, but its configuration cannot be read ({problem}).",
+	"violation.modesEmpty": "At least one mode is required.",
+	"violation.defaultMissing": "The default mode is not in the mode list.",
+	"violation.modelPair": "A default model needs both a provider and a model.",
+	"summary.allTools": "every tool",
+	"summary.tools": "{n} tools",
+	"summary.denyTools": "{n} denied",
+	"summary.globalModel": "global model"
+};
+//#endregion
+//#region src/client/api.ts
+async function fetchRoster() {
+	const response = await fetch(SESSION_MODE_PATH, {
+		method: "GET",
+		headers: { accept: "application/json" }
+	});
+	if (!response.ok) throw new Error(`HTTP ${String(response.status)}`);
+	return await response.json();
+}
+async function selectMode(sessionId, mode) {
+	const response = await fetch(SESSION_MODE_PATH, {
+		method: "POST",
+		headers: {
+			accept: "application/json",
+			"content-type": "application/json"
+		},
+		body: JSON.stringify({
+			sessionId,
+			mode
+		})
+	});
+	const value = await response.json().catch(() => void 0);
+	if (!response.ok) {
+		const error = value?.["error"];
+		throw new Error(typeof error === "string" ? error : `HTTP ${String(response.status)}`);
+	}
+	return value?.mode ?? mode;
+}
+//#endregion
+//#region src/client/use-roster.ts
+let pending;
+function useRoster() {
+	const [roster, setRoster] = useState(void 0);
+	useEffect(() => {
+		let alive = true;
+		pending ??= fetchRoster();
+		pending.then((value) => {
+			if (alive) setRoster(value);
+		}, () => {
+			pending = void 0;
+		});
+		return () => {
+			alive = false;
+		};
+	}, []);
+	return roster;
+}
+//#endregion
+//#region src/client/SessionModeSeat.tsx
+function SessionModeSeat({ sessionId, useSessions, t }) {
+	const roster = useRoster();
+	const selected = useSessions((state) => {
+		const value = sessionId === void 0 ? void 0 : state.byId[sessionId]?.projectionValues?.sessionMode;
+		return typeof value === "string" ? value : void 0;
+	});
+	const editable = useSessions((state) => {
+		const value = sessionId === void 0 ? void 0 : state.byId[sessionId]?.projectionValues?.sessionModeEditable;
+		return typeof value === "boolean" ? value : void 0;
+	});
+	const [open, setOpen] = useState(false);
+	const [busy, setBusy] = useState(false);
+	const [error, setError] = useState(null);
+	if (roster === void 0) return null;
+	const current = selected ?? roster.default;
+	const label = roster.modes.find((mode) => mode.id === current)?.name ?? current;
+	if (editable === false) return /* @__PURE__ */ jsx(SeatButton, {
+		disabled: true,
+		title: t("lockedHint"),
+		icon: /* @__PURE__ */ jsx(IconAgentPresetOutlineRegular, {}),
+		label
+	});
+	return /* @__PURE__ */ jsx(Menu, {
+		open,
+		onClose: () => {
+			setOpen(false);
+		},
+		items: roster.modes.map((mode) => ({
+			id: mode.id,
+			label: /* @__PURE__ */ jsxs(Stack, {
+				gap: 2,
+				children: [/* @__PURE__ */ jsx(Text, {
+					size: "md",
+					children: mode.name
+				}), /* @__PURE__ */ jsx(Text, {
+					size: "sm",
+					tone: "tertiary",
+					children: mode.description ?? t("noDescription")
+				})]
+			})
+		})),
+		selectedId: current,
+		onSelect: (id) => {
+			setOpen(false);
+			if (sessionId === void 0 || id === current) return;
+			setBusy(true);
+			setError(null);
+			selectMode(sessionId, id).catch((cause) => {
+				setError(cause instanceof Error ? cause.message : String(cause));
+			}).finally(() => {
+				setBusy(false);
+			});
+		},
+		align: "start",
+		portal: true,
+		anchor: /* @__PURE__ */ jsx(SeatButton, {
+			"aria-haspopup": "menu",
+			"aria-expanded": open,
+			title: error ?? t("seatHint"),
+			disabled: busy,
+			icon: /* @__PURE__ */ jsx(IconAgentPresetOutlineRegular, {}),
+			label,
+			chevron: /* @__PURE__ */ jsx(IconChevronDownOutlineRegular, {}),
+			onClick: () => {
+				setOpen((value) => !value);
+			}
+		})
+	});
+}
+//#endregion
+//#region src/client/locales.ts
+const zh = {
+	seatHint: "选择这个会话的模式",
+	lockedHint: "这个会话已经开始：换模式请新开一个会话",
+	noDescription: "（无说明）",
+	provider: "服务商",
+	providerHint: "服务商 id：部署里注册的任意路由——不论哪个适配器插件注册的（官方的、我们自己的都算）。",
+	model: "模型",
+	modelHint: "模型 id。",
+	reasoningEffort: "思考档位",
+	reasoningEffortHint: "默认就跟服务商自己的默认。"
+};
+const en = {
+	seatHint: "Pick the mode for this session",
+	lockedHint: "This session has started: start a new one to pick a mode",
+	noDescription: "(no description)",
+	provider: "Provider",
+	providerHint: "Provider id: any route registered in this deployment, whichever adapter plugin supplies it.",
+	model: "Model",
+	modelHint: "Model id.",
+	reasoningEffort: "Reasoning effort",
+	reasoningEffortHint: "Default keeps the provider's own default."
+};
+//#endregion
+//#region src/client/index.ts
+const NS = "session-mode";
+const FIELDS = [
+	"provider",
+	"model",
+	"reasoningEffort"
+];
+const POLICY_FIELDS = ["allowPolicies", "denyPolicies"];
+const DYNAMIC = "*";
+const inject = ["slots", "locale"];
+function unwrapHintService(scope) {
+	return unwrapService(scope.schemaFormHints);
+}
+function apply(ctx) {
+	const t = ctx.locale.bind(NS);
+	ctx.effect(() => ctx.locale.register(NS, {
+		zh,
+		en
+	}), "session-mode: dictionaries");
+	ctx.inject(["schemaFormHints"], (scope) => scope.effect(() => {
+		const hints = unwrapHintService(scope);
+		const offs = FIELDS.map((key) => hints.describe(SESSION_MODE_NS, [
+			"modes",
+			DYNAMIC,
+			"defaultModel",
+			key
+		], () => ({
+			label: t(key),
+			hint: t(`${key}Hint`)
+		})));
+		return () => {
+			for (const off of offs) off();
+		};
+	}, "session-mode: field wording"));
+	ctx.inject(["schemaFormHints"], (scope) => scope.effect(() => {
+		const offs = POLICY_FIELDS.map((key) => unwrapHintService(scope).select(SESSION_MODE_NS, [
+			"modes",
+			DYNAMIC,
+			key,
+			DYNAMIC
+		], { options: () => POLICY_NAMES.map((value) => ({ value })) }));
+		return () => {
+			for (const off of offs) off();
+		};
+	}, "session-mode: policy candidates"));
+	ctx.inject(["schemaFormHints"], (scope) => scope.effect(() => {
+		const hints = unwrapHintService(scope);
+		const remote = scope.get("remote");
+		if (remote === void 0) return () => {};
+		let providers = [];
+		const load = async () => {
+			providers = await loadLlmProviders(scope);
+			hints.refresh();
+		};
+		const offs = [
+			hints.source("llm-providers", { options: () => providers.map((entry) => ({
+				value: entry.value,
+				label: entry.label
+			})) }),
+			hints.source("llm-models", {
+				dependsOn: [["provider"]],
+				options: (read) => {
+					const provider = read(["provider"]);
+					return typeof provider === "string" ? providers.find((entry) => entry.value === provider)?.models ?? [] : [];
+				}
+			}),
+			remote.$on("llm/adapters-updated", () => {
+				load();
+			}),
+			remote.$on("settings/document-updated", () => {
+				load();
+			})
+		];
+		load();
+		return () => {
+			for (const off of offs) off();
+		};
+	}, "session-mode: model candidates"));
+	ctx.inject(["schemaFormHints"], (scope) => scope.effect(() => {
+		const hints = unwrapHintService(scope);
+		const remote = scope.get("remote");
+		if (remote === void 0) return () => {};
+		const roster = remoteNamespace(scope, "agentPresets");
+		if (roster === void 0) return () => {};
+		let presets = [];
+		const load = async () => {
+			const listed = await roster.list();
+			if (!listed.ok) return;
+			presets = listed.value.presets.map((preset) => ({
+				value: preset.id,
+				label: preset.name ?? preset.id
+			}));
+			hints.refresh();
+		};
+		const offs = [hints.source("agent-presets", { options: () => presets }), remote.$on("settings/document-updated", () => {
+			load();
+		})];
+		load();
+		return () => {
+			for (const off of offs) off();
+		};
+	}, "session-mode: preset candidates"));
+	ctx.inject(["schemaFormHints", "remote"], (scope) => scope.effect(() => {
+		const hints = unwrapHintService(scope);
+		let tools = [];
+		let skills = [];
+		const offs = [
+			hints.source("catalog-tools", { options: () => tools.map((value) => ({ value })) }),
+			hints.source("catalog-skills", { options: () => skills.map((value) => ({ value })) }),
+			hints.source("policies", { options: () => POLICY_NAMES.map((value) => ({ value })) })
+		];
+		let disposeMount;
+		if (typeof scope.remote.$mount !== "function") return () => {
+			for (const off of offs) off();
+		};
+		scope.remote.$mount(SESSION_MODE_CATALOG_REMOTE).then(async (dispose) => {
+			disposeMount = dispose;
+			const listed = await remoteNamespace(scope, CATALOG_NS)?.list();
+			if (listed?.ok !== true) return;
+			tools = listed.value.tools;
+			skills = listed.value.skills;
+			hints.refresh();
+		}).catch(() => {});
+		return () => {
+			for (const off of offs) off();
+			disposeMount?.();
+		};
+	}, "session-mode: catalog candidates"));
+	ctx.inject(["slots", "conversation"], (scope) => {
+		scope.effect(() => {
+			const seat = scope.slots.register({
+				name: "conversation.input.left",
+				id: "session-mode",
+				order: 0,
+				locale: NS
+			}, SessionModeSeat);
+			return () => {
+				seat();
+			};
+		}, "session-mode: composer chip");
+	});
+	let refreshPage;
+	let hints;
+	ctx.inject(["schemaFormHints"], (scope) => scope.effect(() => {
+		const service = unwrapHintService(scope);
+		hints = service;
+		const off = service.subscribe(() => {
+			refreshPage?.();
+		});
+		return () => {
+			off();
+			hints = void 0;
+		};
+	}, "session-mode: bundle page candidates"));
+	ctx.inject([
+		"slots",
+		"locale",
+		"configForms",
+		"settingsSchema"
+	], (scope) => {
+		scope.effect(() => {
+			const { face, refresh, dispose } = createBundleConfigFace(scope, scope.locale.bind(BUNDLE_NS), () => hints);
+			refreshPage = refresh;
+			const bundleDictionary = scope.locale.register(BUNDLE_NS, {
+				zh: bundleZh,
+				en: bundleEn
+			});
+			const off = scope.slots.inject("plugins.bundle.config", () => scope.slots.register({
+				name: "plugins.bundle.config",
+				key: BUNDLE_CONFIG_KEY,
+				locale: BUNDLE_NS,
+				inject: () => face
+			}, BundleConfigPage));
+			return () => {
+				off();
+				bundleDictionary();
+				refreshPage = void 0;
+				dispose();
+			};
+		}, "session-mode: bundle configuration page");
+	});
+}
+//#endregion
+export { SESSION_MODE_NS, apply, inject };