dsh-llm-fallbacks 0.2.1 → 0.3.0

package/dist/index.js

@@ -1,7 +1,7 @@
 import { createRequire } from "node:module";
 import { installSettingsSection, settingsNamespace } from "@deepseek-ai/dsh-settings";
-import * as dshSession from "@deepseek-ai/dsh-session";
 import z from "@deepseek-ai/schemastery";
+import { LlmAdapter, LlmError, createUserMessage } from "@deepseek-ai/dsh-llm";
 import { TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
 //#region .build/host/selectors.js
 var SelectorError = class extends Error {
@@ -35,6 +35,202 @@ function resolveWildcardEntry(failingModel, provider) {
 		raw: `${provider}/${failingModel}`
 	};
 }
+const PRESETS = {
+	"liang-peak": {
+		windows: [{
+			start: "09:00",
+			end: "12:00"
+		}, {
+			start: "14:00",
+			end: "18:00"
+		}],
+		complement: false,
+		label: "Liang Peak"
+	},
+	"liang-valley": {
+		windows: [{
+			start: "09:00",
+			end: "12:00"
+		}, {
+			start: "14:00",
+			end: "18:00"
+		}],
+		complement: true,
+		label: "Liang Valley"
+	},
+	"glm-peak": {
+		windows: [{
+			start: "14:00",
+			end: "18:00",
+			days: [
+				1,
+				2,
+				3,
+				4,
+				5
+			]
+		}],
+		complement: false,
+		label: "GLM Peak"
+	},
+	"glm-valley": {
+		windows: [{
+			start: "14:00",
+			end: "18:00",
+			days: [
+				1,
+				2,
+				3,
+				4,
+				5
+			]
+		}],
+		complement: true,
+		label: "GLM Valley"
+	}
+};
+const HHMM_RE = /^([01]\d|2[0-3]):[0-5]\d$/;
+const WEEKDAY_INDEX = {
+	Sun: 0,
+	Mon: 1,
+	Tue: 2,
+	Wed: 3,
+	Thu: 4,
+	Fri: 5,
+	Sat: 6
+};
+const warnedMalformedRows = new WeakSet();
+const warnedTimeZones = new Set();
+function warnMalformed(row, reason) {
+	if (typeof row !== "object" || row === null) {
+		console.warn(`llm-fallbacks: skipping malformed time-slot row (${reason})`);
+		return;
+	}
+	if (warnedMalformedRows.has(row)) return;
+	warnedMalformedRows.add(row);
+	console.warn(`llm-fallbacks: skipping malformed time-slot row (${reason}): ${JSON.stringify(row)}`);
+}
+function wallClock(now, tz) {
+	try {
+		const parts = new Intl.DateTimeFormat("en-US", {
+			timeZone: tz,
+			weekday: "short",
+			hour: "2-digit",
+			minute: "2-digit",
+			hourCycle: "h23"
+		}).formatToParts(now);
+		let weekday = 0;
+		let minutes = 0;
+		for (const part of parts) if (part.type === "weekday") weekday = WEEKDAY_INDEX[part.value] ?? 0;
+		else if (part.type === "hour") minutes += Number(part.value) * 60;
+		else if (part.type === "minute") minutes += Number(part.value);
+		return {
+			weekday,
+			minutes
+		};
+	} catch (error) {
+		if (!warnedTimeZones.has(tz)) {
+			warnedTimeZones.add(tz);
+			console.warn(`llm-fallbacks: invalid timezone "${tz}" (${error.message}) — slot matching falls back to UTC`);
+		}
+		return {
+			weekday: now.getUTCDay(),
+			minutes: now.getUTCHours() * 60 + now.getUTCMinutes()
+		};
+	}
+}
+function minutesOf(hhmm) {
+	const [hour, minute] = hhmm.split(":").map(Number);
+	return hour * 60 + minute;
+}
+function containsWindow(window, clock) {
+	if (!(window.days === void 0 || window.days.length === 0 || window.days.includes(clock.weekday))) return false;
+	const start = minutesOf(window.start);
+	const end = minutesOf(window.end);
+	return start <= end ? start <= clock.minutes && clock.minutes < end : start <= clock.minutes || clock.minutes < end;
+}
+function matchesAnyWindow(windows, clock) {
+	return windows.some((window) => containsWindow(window, clock));
+}
+function describeRow(row) {
+	if (!Array.isArray(row.chain) || row.chain.length === 0) {
+		warnMalformed(row, "empty chain");
+		return;
+	}
+	if (row.kind === "preset") {
+		const preset = row.preset;
+		if (typeof preset !== "string" || !Object.hasOwn(PRESETS, preset)) {
+			warnMalformed(row, `unknown preset ${JSON.stringify(preset)}`);
+			return;
+		}
+		if (row.start !== void 0 || row.end !== void 0 || row.days !== void 0 && row.days.length > 0) {
+			warnMalformed(row, `preset windows are fixed — row "${preset}" cannot carry start/end/days`);
+			return;
+		}
+		return PRESETS[preset];
+	}
+	if (row.kind === "custom") {
+		const { start, end } = row;
+		if (typeof start !== "string" || typeof end !== "string" || !HHMM_RE.test(start) || !HHMM_RE.test(end)) {
+			warnMalformed(row, `invalid custom window ${JSON.stringify(start)}-${JSON.stringify(end)} (expected HH:mm)`);
+			return;
+		}
+		return {
+			windows: [{
+				start,
+				end,
+				days: row.days
+			}],
+			complement: false
+		};
+	}
+	warnMalformed(row, `unknown kind ${JSON.stringify(row.kind)}`);
+}
+function labelOf(row) {
+	if (row.kind === "preset" && typeof row.preset === "string" && Object.hasOwn(PRESETS, row.preset)) return PRESETS[row.preset].label;
+	return row.name !== void 0 && row.name.trim() !== "" ? row.name : `custom ${row.start}-${row.end}`;
+}
+function isAllDayConforming(chain) {
+	if (chain.length < 1) return false;
+	const tail = chain[chain.length - 1];
+	return tail === "deepseek-official/deepseek-v4-flash" || tail === "deepseek-official/deepseek-v4-pro";
+}
+function resolveEffectiveChain(config, now, tz) {
+	const state = resolveSlotState(config, now, tz);
+	return state.winner === "all-day" ? config.rootChain : state.winner.chain;
+}
+function resolveSlotState(config, now, tz) {
+	if (!isAllDayConforming(config.rootChain)) return {
+		winner: "all-day",
+		label: "all-day"
+	};
+	const clock = wallClock(now, tz);
+	const seenPresets = new Set();
+	const rows = Array.isArray(config.timeSlots) ? config.timeSlots : [];
+	for (const row of rows) {
+		if (typeof row !== "object" || row === null) {
+			warnMalformed(row, "row is not an object");
+			continue;
+		}
+		if (row.kind === "preset" && typeof row.preset === "string") {
+			if (seenPresets.has(row.preset)) {
+				warnMalformed(row, `duplicate preset "${row.preset}" — only the first row takes effect`);
+				continue;
+			}
+			seenPresets.add(row.preset);
+		}
+		const descriptor = describeRow(row);
+		if (descriptor === void 0) continue;
+		if (descriptor.complement ? !matchesAnyWindow(descriptor.windows, clock) : matchesAnyWindow(descriptor.windows, clock)) return {
+			winner: row,
+			label: labelOf(row)
+		};
+	}
+	return {
+		winner: "all-day",
+		label: "all-day"
+	};
+}
 //#endregion
 //#region .build/host/config.js
 const defaultFallbacksConfig = {
@@ -53,7 +249,10 @@ const defaultFallbacksConfig = {
 	revertPolicy: "cooldown-expiry",
 	maxSwitchesPerStep: 8,
 	alwaysModeRetryCap: 5,
-	presets: "bundled"
+	presets: "bundled",
+	roleAutoMatch: true,
+	timeSlots: [],
+	tz: "Asia/Shanghai"
 };
 const INHERIT_ROLE_ID = "inherit";
 const ROLE_ID_PATTERN = /^[a-z0-9-]{1,32}$/;
@@ -73,6 +272,7 @@ function validateFallbacksConfig(config, logger) {
 		if ((role.chain ?? []).length === 0) logger.warn(`llm-fallbacks: role "${role.id}" has no model config — declare at least one chain entry, or use the built-in "inherit" rule target instead`);
 		if (role.fallback !== void 0 && role.fallback !== "inherit-root" && role.fallback !== "none") logger.warn(`llm-fallbacks: role "${role.id}" has invalid fallback "${String(role.fallback)}" — expected "inherit-root" or "none"`);
 	}
+	if (config.rootChain.length > 0 && !isAllDayConforming(config.rootChain)) logger.warn("llm-fallbacks: rootChain must end with exactly one official V4 model (deepseek-official/deepseek-v4-flash or deepseek-official/deepseek-v4-pro) — time-slot rows and the virtual picker row stay inert until the all-day chain tail conforms");
 	for (const entry of config.rootChain) try {
 		parseSelector(entry);
 	} catch (error) {
@@ -80,6 +280,23 @@ function validateFallbacksConfig(config, logger) {
 	}
 	const validTargets = new Set([...declaredIds, INHERIT_ROLE_ID]);
 	for (const rule of config.roles.rules) if (!validTargets.has(rule.role.trim())) logger.warn(`llm-fallbacks: rule references undeclared role "${rule.role}" — expected one of roles.list ids or "inherit"`);
+	if (Array.isArray(config.timeSlots)) {
+		const seenSlotPresets = new Set();
+		for (const row of config.timeSlots) {
+			if (row.kind !== "preset") continue;
+			const preset = row.preset;
+			if (typeof preset !== "string" || !Object.hasOwn(PRESETS, preset)) {
+				logger.warn(`llm-fallbacks: unknown time-slot preset ${JSON.stringify(preset)} — row ignored`);
+				continue;
+			}
+			if (seenSlotPresets.has(preset)) {
+				logger.warn(`llm-fallbacks: duplicate time-slot preset "${preset}" — only the first row takes effect`);
+				continue;
+			}
+			seenSlotPresets.add(preset);
+			if (row.start !== void 0 || row.end !== void 0 || row.days !== void 0 && row.days.length > 0) logger.warn(`llm-fallbacks: preset "${preset}" carries its own window/day fields — preset windows are fixed code constants; the row is ignored`);
+		}
+	}
 }
 function detectLegacyKeys(source) {
 	const keys = [];
@@ -139,8 +356,110 @@ const Config = z.object({
 	revertPolicy: z.union([z.const("cooldown-expiry"), z.const("never")]).default("cooldown-expiry"),
 	maxSwitchesPerStep: z.number().default(8),
 	alwaysModeRetryCap: z.number().default(5),
-	presets: z.union([z.const("bundled"), z.const("none")]).default("bundled")
+	presets: z.union([z.const("bundled"), z.const("none")]).default("bundled"),
+	roleAutoMatch: z.boolean().default(true),
+	timeSlots: z.array(z.object({
+		kind: z.string(),
+		preset: z.string(),
+		start: z.string(),
+		end: z.string(),
+		days: z.array(z.number()),
+		chain: z.array(z.string())
+	})).default([]),
+	tz: z.string().default("Asia/Shanghai")
 });
+function buildAutomatchPrompt(roles, agent) {
+	const lines = [
+		"You are assigning a subagent to its best-fit role from a declared taxonomy.",
+		"",
+		"Declared roles:",
+		...roles.map((role) => `- ${role.id.trim()}: ${role.persona}`),
+		"",
+		`Agent context — origin: ${agent.session?.header?.origin ?? "root"}`
+	];
+	const preset = agent.session?.header?.agentPreset?.trim();
+	if (preset !== void 0 && preset !== "") lines.push(`agentPreset: ${preset}`);
+	lines.push("", "Reply with EXACTLY ONE of the declared role ids above, or the literal \"none\" when no role fits.", "Do not add any explanation, punctuation, or other text.");
+	return lines.join("\n");
+}
+function parseAutomatchAnswer(answer, roleIds) {
+	const cleaned = answer.replace(/^[^a-zA-Z0-9-]+/, "").replace(/[^a-zA-Z0-9-]+$/, "");
+	if (cleaned === "") return null;
+	const key = cleaned.toLowerCase();
+	if (key === "none") return null;
+	return roleIds.get(key) ?? null;
+}
+async function pickRoleByLlm(ctx, roles, agent, opts) {
+	try {
+		const list = Array.isArray(roles.list) ? roles.list : [];
+		if (list.length === 0) return null;
+		const llm = ctx.get("llm");
+		if (llm === void 0) return null;
+		const route = pickJudgmentRoute(list, agent);
+		if (route === null) return null;
+		const roleIds = new Map(list.map((role) => [role.id.trim(), role.id]));
+		const answer = await streamRoleAnswer(llm, route, buildAutomatchPrompt(list, agent), opts);
+		if (answer === null) return null;
+		return parseAutomatchAnswer(answer, roleIds);
+	} catch (error) {
+		opts.warn(`llm-fallbacks: auto-match failed — falling back to "inherit": ${describeError(error)}`);
+		return null;
+	}
+}
+function pickJudgmentRoute(roles, agent) {
+	for (const role of roles) for (const entry of role.chain ?? []) try {
+		const selector = parseSelector(entry);
+		if (selector.model !== void 0) return {
+			provider: selector.provider,
+			model: selector.model
+		};
+	} catch {}
+	const provider = agent.options?.provider;
+	const model = agent.options?.model;
+	if (provider !== void 0 && model !== void 0) return {
+		provider,
+		model
+	};
+	return null;
+}
+async function streamRoleAnswer(llm, route, prompt, opts) {
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), opts.timeoutMs ?? 5e3);
+	let text = "";
+	let finishKind;
+	try {
+		for await (const chunk of llm.stream({
+			provider: route.provider,
+			model: route.model,
+			system: prompt,
+			messages: [createUserMessage({
+				content: [{
+					type: "text",
+					text: "Pick the best-fit role for this agent."
+				}],
+				source: { kind: "user" }
+			})],
+			maxTokens: 32,
+			signal: controller.signal
+		})) if (chunk.type === "text-delta") text += chunk.text;
+		else if (chunk.type === "finish") {
+			finishKind = chunk.reason.kind;
+			break;
+		}
+		if (controller.signal.aborted) return null;
+		if (finishKind === "error" || finishKind === "aborted") return null;
+		return text;
+	} catch (error) {
+		if (controller.signal.aborted) opts.warn("llm-fallbacks: auto-match timed out — falling back to \"inherit\"");
+		else opts.warn(`llm-fallbacks: auto-match call failed — falling back to "inherit": ${describeError(error)}`);
+		return null;
+	} finally {
+		clearTimeout(timer);
+	}
+}
+function describeError(error) {
+	return error instanceof Error ? error.message : String(error);
+}
 //#endregion
 //#region .build/host/chains.js
 function resolveCandidate(entry, failing, modelExists) {
@@ -247,9 +566,8 @@ function annotateCandidates(candidates, surviving, options) {
 //#endregion
 //#region .build/host/roles.js
 function resolveRole(agent, rules, roleIds, warn = console.warn) {
-	const origin = agent.session?.header?.origin ?? "root";
+	if ((agent.session?.header?.origin ?? "root") !== "subagent") return INHERIT_ROLE_ID;
 	for (const rule of rules) {
-		if (rule.origin && rule.origin !== origin) continue;
 		if (rule.provider && rule.provider !== agent.options?.provider) continue;
 		if (rule.model && rule.model !== agent.options?.model) continue;
 		const target = rule.role.trim();
@@ -264,6 +582,29 @@ function resolveRole(agent, rules, roleIds, warn = console.warn) {
 	return INHERIT_ROLE_ID;
 }
 //#endregion
+//#region .build/host/role-resolution.js
+async function resolveRoleAtDispatch(agent, rules, roleIds, opts) {
+	const preset = agent.session?.header?.agentPreset?.trim();
+	if (preset !== void 0 && preset !== "" && preset !== "inherit") {
+		const declared = roleIds.get(preset);
+		if (declared !== void 0) return declared;
+	}
+	const role = resolveRole(agent, rules, roleIds, opts.warn);
+	if (role !== "inherit") return role;
+	if (opts.automatchEnabled && opts.automatch !== void 0) {
+		const picked = await opts.automatch(agent);
+		if (picked !== null && picked !== void 0) {
+			const declared = roleIds.get(picked.trim());
+			if (declared !== void 0) return declared;
+			opts.warn(`llm-fallbacks: auto-match returned undeclared role "${picked}" — falling back to "inherit"`);
+		}
+	}
+	return INHERIT_ROLE_ID;
+}
+function firstExactCandidate(all, wildcard) {
+	for (let index = 0; index < all.length; index += 1) if (!wildcard[index]) return all[index];
+}
+//#endregion
 //#region .build/host/cooldown.js
 var CooldownStore = class {
 	entries = new Map();
@@ -399,12 +740,25 @@ const CONFIG_KEYS = {
 	revertPolicy: true,
 	maxSwitchesPerStep: true,
 	alwaysModeRetryCap: true,
-	presets: true
+	presets: true,
+	roleAutoMatch: true,
+	timeSlots: true,
+	tz: true
 };
 const ROLES_KEYS = {
 	list: true,
 	rules: true
 };
+const SLOT_ROW_KEYS = {
+	kind: true,
+	preset: true,
+	start: true,
+	end: true,
+	days: true,
+	name: true,
+	chain: true
+};
+const SLOT_HHMM_RE = /^([01]\d|2[0-3]):[0-5]\d$/;
 var FallbacksConfigGateway = class extends TypertRemoteService {
 	bridge;
 	seeds;
@@ -494,9 +848,44 @@ function validateConfigPatch(patch) {
 				for (const nestedKey of Object.keys(roles)) if (!Object.hasOwn(ROLES_KEYS, nestedKey)) throw new Error(`dsh-llm-fallbacks: unknown config key "roles.${nestedKey}"`);
 			}
 		}
+		if (key === "timeSlots") {
+			const rows = patch[key];
+			if (rows !== null && rows !== void 0) validateTimeSlotsPatch(rows);
+		}
+		if (key === "rootChain") {
+			const chain = patch[key];
+			if (chain !== null && chain !== void 0 && (!Array.isArray(chain) || !isAllDayConforming(chain))) throw new Error("dsh-llm-fallbacks: rootChain must end with exactly one official V4 model (deepseek-official/deepseek-v4-flash or deepseek-official/deepseek-v4-pro)");
+		}
 	}
 	Config(patch);
 }
+function validateTimeSlotsPatch(rows) {
+	if (!Array.isArray(rows)) throw new Error("dsh-llm-fallbacks: timeSlots must be an array of slot rows");
+	const seenPresets = new Set();
+	rows.forEach((row, index) => {
+		const at = `timeSlots[${index}]`;
+		if (row === null || typeof row !== "object" || Array.isArray(row)) throw new Error(`dsh-llm-fallbacks: ${at} must be a plain object`);
+		const record = row;
+		for (const nestedKey of Object.keys(record)) if (!Object.hasOwn(SLOT_ROW_KEYS, nestedKey)) throw new Error(`dsh-llm-fallbacks: unknown config key "${at}.${nestedKey}"`);
+		if (record.kind === "preset") {
+			const preset = record.preset;
+			if (typeof preset !== "string" || !Object.hasOwn(PRESETS, preset)) throw new Error(`dsh-llm-fallbacks: ${at}.preset must be one of the four frozen preset ids (got ${JSON.stringify(preset)})`);
+			if (seenPresets.has(preset)) throw new Error(`dsh-llm-fallbacks: ${at} duplicates preset "${preset}" — at most one row per preset`);
+			seenPresets.add(preset);
+			if (record.start !== void 0 || record.end !== void 0 || Array.isArray(record.days) && record.days.length > 0) throw new Error(`dsh-llm-fallbacks: ${at} preset "${preset}" cannot carry start/end/days — preset windows are frozen code constants`);
+			if (record.name !== void 0) throw new Error(`dsh-llm-fallbacks: ${at} preset "${preset}" cannot carry a name — preset rows are named by the frozen label`);
+		} else if (record.kind === "custom") {
+			const { start, end } = record;
+			if (typeof start !== "string" || typeof end !== "string" || !SLOT_HHMM_RE.test(start) || !SLOT_HHMM_RE.test(end)) throw new Error(`dsh-llm-fallbacks: ${at} custom row requires HH:mm start and end (got ${JSON.stringify(start)}-${JSON.stringify(end)})`);
+			if (record.days !== void 0) {
+				if (!Array.isArray(record.days) || record.days.some((day) => !Number.isInteger(day) || day < 0 || day > 6)) throw new Error(`dsh-llm-fallbacks: ${at}.days must be an array of integers 0–6`);
+			}
+			if (record.name !== void 0 && typeof record.name !== "string") throw new Error(`dsh-llm-fallbacks: ${at}.name must be a string`);
+		} else throw new Error(`dsh-llm-fallbacks: ${at}.kind must be "preset" or "custom" (got ${JSON.stringify(record.kind)})`);
+		const chain = record.chain;
+		if (!Array.isArray(chain) || chain.length === 0 || chain.some((entry) => typeof entry !== "string")) throw new Error(`dsh-llm-fallbacks: ${at}.chain must be a non-empty string array`);
+	});
+}
 function fallbacksTypertContribution() {
 	return {
 		package: "dsh-llm-fallbacks",
@@ -567,7 +956,7 @@ const CONFIG_SUBCOMMAND_DESCRIPTION = {
 const FALLBACKS_COMMAND_LOCALES = {
 	zh: {
 		title: "当前会话 fallback 诊断（只读）",
-		description: "查看当前会话的降级链、最近切换与冷却状态（只读）",
+		description: "查看当前会话的降级链、最近降级切换与冷却状态（只读）",
 		usageConfig: CONFIG_SUBCOMMAND_DESCRIPTION.zh,
 		usage: `  /fallbacks config   ${CONFIG_SUBCOMMAND_DESCRIPTION.zh}`,
 		origin: "会话来源",
@@ -575,7 +964,8 @@ const FALLBACKS_COMMAND_LOCALES = {
 		chain: "链",
 		inheritRoot: "（inherit-root）",
 		chainNone: "未配置",
-		switches: "最近切换",
+		slot: "分时",
+		switches: "最近降级切换",
 		switchesNone: "本会话暂无 fallback 切换",
 		switchLine: "{from} → {to}（role={role}，reason={reason}）",
 		cooldown: "冷却",
@@ -599,12 +989,13 @@ const FALLBACKS_COMMAND_LOCALES = {
 		configMaxSwitches: "单步最大切换",
 		configAlwaysCap: "always 上限",
 		configPresets: "预置",
+		configRoleAutoMatch: "角色自动匹配",
 		configEdit: "编辑：~/.dsh/profiles/<profile>/cordis.patch.yml（插件行）或 $DSH_HOME/settings.yaml（fallbacks: 分节）",
 		configEditHint: "TUI 无法修改配置——只能编辑文件"
 	},
 	en: {
 		title: "Session fallback diagnostics (read-only)",
-		description: "Inspect fallback chain, recent switches, and cooldown for this session (read-only)",
+		description: "Inspect fallback chain, recent fallback switches, and cooldown for this session (read-only)",
 		usageConfig: CONFIG_SUBCOMMAND_DESCRIPTION.en,
 		usage: `  /fallbacks config   ${CONFIG_SUBCOMMAND_DESCRIPTION.en}`,
 		origin: "Session origin",
@@ -612,7 +1003,8 @@ const FALLBACKS_COMMAND_LOCALES = {
 		chain: "Chain",
 		inheritRoot: " (inherit-root)",
 		chainNone: "not configured",
-		switches: "Recent switches",
+		slot: "Time slot",
+		switches: "Recent fallback switches",
 		switchesNone: "No fallback switches in this session",
 		switchLine: "{from} → {to} (role={role}, reason={reason})",
 		cooldown: "Cooldown",
@@ -636,6 +1028,7 @@ const FALLBACKS_COMMAND_LOCALES = {
 		configMaxSwitches: "Max switches/step",
 		configAlwaysCap: "Always-mode cap",
 		configPresets: "Presets",
+		configRoleAutoMatch: "Auto-match",
 		configEdit: "Edit: ~/.dsh/profiles/<profile>/cordis.patch.yml (plugin row) or $DSH_HOME/settings.yaml (fallbacks: section)",
 		configEditHint: "TUI cannot change config — edit files only"
 	}
@@ -709,6 +1102,7 @@ function fallbacksConfigText(summary, locale = "zh") {
 		`${t.configMaxSwitches}: ${summary.maxSwitchesPerStep}`,
 		`${t.configAlwaysCap}: ${summary.alwaysModeRetryCap}`,
 		`${t.configPresets}: ${summary.presets}`,
+		`${t.configRoleAutoMatch}: ${summary.roleAutoMatch ? t.configEnabled : t.configDisabled}`,
 		"",
 		t.configEdit,
 		t.configEditHint
@@ -724,6 +1118,7 @@ function fallbacksCommandText(snapshot, locale = "zh") {
 		const suffix = snapshot.inherit ? t.inheritRoot : "";
 		lines.push(`${t.chain}: ${snapshot.chain.join(" → ")}${suffix}`);
 	}
+	lines.push(`${t.slot}: ${snapshot.slot.label}`);
 	if (snapshot.switches.length === 0) lines.push(`${t.switches}: ${t.switchesNone}`);
 	else {
 		lines.push(`${t.switches} (${snapshot.switches.length}):`);
@@ -979,7 +1374,7 @@ function fallbacksChildren(canonicalPath) {
 	if (canonicalPath.length === 1) return [FALLBACKS_CONFIG_NODE];
 	return [];
 }
-const FALLBACKS_PROVIDER = {
+const FALLBACKS_PROVIDER$1 = {
 	root: FALLBACKS_TUI_ROOT,
 	descriptions: {
 		zh: FALLBACKS_COMMAND_LOCALES.zh.description,
@@ -993,7 +1388,7 @@ function installTuiClient(ctx, opts) {
 		const trees = tctx.tuiCommandTrees;
 		if (trees === void 0) return;
 		try {
-			return trees.register(FALLBACKS_PROVIDER);
+			return trees.register(FALLBACKS_PROVIDER$1);
 		} catch (error) {
 			if (!(error instanceof Error) || !error.message.includes("already registered")) throw error;
 			tctx.logger("llm-fallbacks").debug("llm-fallbacks: tui command tree already registered — no provider on this fiber");
@@ -1002,6 +1397,151 @@ function installTuiClient(ctx, opts) {
 	});
 }
 //#endregion
+//#region .build/host/virtual-adapter.js
+const FALLBACKS_PROVIDER = "FallbacksChain";
+const FALLBACKS_CHAIN_MODEL = "Auto";
+const EMPTY_EFFECTIVE_CHAIN_CODE = "EMPTY_EFFECTIVE_CHAIN";
+const UNDISPATCHABLE_HEAD_CODE = "UNDISPATCHABLE_EFFECTIVE_HEAD";
+const LLM_UNAVAILABLE_CODE = "LLM_UNAVAILABLE";
+function firstDispatchableExactHead(chain) {
+	for (const entry of chain) {
+		let selector;
+		try {
+			selector = parseSelector(entry);
+		} catch {
+			continue;
+		}
+		if (selector.model === void 0) continue;
+		if (selector.provider === "FallbacksChain") continue;
+		return {
+			provider: selector.provider,
+			model: selector.model
+		};
+	}
+}
+function effectiveHeadOf(config, now) {
+	if (!isAllDayConforming(config.rootChain)) return void 0;
+	return firstDispatchableExactHead(resolveEffectiveChain(config, now, config.tz ?? "Asia/Shanghai"));
+}
+function pickerDisplayName(config, now = new Date(), modelDisplayName) {
+	const head = effectiveHeadOf(config, now);
+	if (head === void 0) return FALLBACKS_CHAIN_MODEL;
+	const slot = resolveSlotState(config, now, config.tz ?? "Asia/Shanghai");
+	const model = modelDisplayName !== void 0 && modelDisplayName !== "" ? modelDisplayName : head.model;
+	return `${FALLBACKS_CHAIN_MODEL}: ${model}[${slot.label}]`;
+}
+async function resolveHeadDisplayName(llm, head) {
+	if (llm === void 0) return head.model;
+	try {
+		const row = (await llm.listModels(head.provider)).find((model) => model.id === head.model);
+		if (row !== void 0 && row.name !== "") return row.name;
+	} catch {}
+	try {
+		const info = await llm.resolveModelInfo(head.provider, head.model);
+		if (info.name !== "") return info.name;
+	} catch {}
+	return head.model;
+}
+var FallbacksChainAdapter = class extends LlmAdapter {
+	readConfig;
+	getLlm;
+	constructor(readConfig, getLlm) {
+		super();
+		this.readConfig = readConfig;
+		this.getLlm = getLlm;
+	}
+	providerInfo(provider) {
+		return {
+			id: provider,
+			name: FALLBACKS_PROVIDER
+		};
+	}
+	async listModels(provider) {
+		const config = this.readConfig();
+		const now = new Date();
+		const head = effectiveHeadOf(config, now);
+		const display = head === void 0 ? void 0 : await resolveHeadDisplayName(this.getLlm(), head);
+		return [{
+			provider,
+			id: FALLBACKS_CHAIN_MODEL,
+			name: pickerDisplayName(config, now, display)
+		}];
+	}
+	async resolveModel(provider, model, signal) {
+		const head = effectiveHeadOf(this.readConfig(), new Date());
+		const llm = this.getLlm();
+		if (head !== void 0 && llm !== void 0) try {
+			const info = await llm.resolveModelInfo(head.provider, head.model, signal);
+			return {
+				provider,
+				id: model,
+				name: info.name,
+				...info.description === void 0 ? {} : { description: info.description },
+				...info.inputModalities === void 0 ? {} : { inputModalities: info.inputModalities },
+				...info.context === void 0 ? {} : { context: info.context },
+				...info.defaultMaxTokens === void 0 ? {} : { defaultMaxTokens: info.defaultMaxTokens },
+				...info.reasoning === void 0 ? {} : { reasoning: info.reasoning }
+			};
+		} catch {}
+		return {
+			provider,
+			id: model,
+			name: model
+		};
+	}
+	stream(options) {
+		const config = this.readConfig();
+		const now = new Date();
+		if (resolveEffectiveChain(config, now, config.tz ?? "Asia/Shanghai").length === 0) throw new LlmError("llm-fallbacks: the effective chain is empty — the virtual FallbacksChain route has no head to delegate to", EMPTY_EFFECTIVE_CHAIN_CODE);
+		const head = effectiveHeadOf(config, now);
+		if (head === void 0) throw new LlmError("llm-fallbacks: the effective chain head cannot be dispatched (non-conforming all-day, wildcard, malformed, or self-route) — refusing to delegate", UNDISPATCHABLE_HEAD_CODE);
+		const llm = this.getLlm();
+		if (llm === void 0) throw new LlmError("llm-fallbacks: the llm runtime is unavailable — cannot delegate the FallbacksChain call", LLM_UNAVAILABLE_CODE);
+		return llm.stream({
+			...options,
+			provider: head.provider,
+			model: head.model
+		});
+	}
+};
+function installFallbacksAdapter(ctx, readConfig) {
+	let llm;
+	let disposeAdapter;
+	let registered = false;
+	const logger = ctx.logger("llm-fallbacks");
+	const adapter = new FallbacksChainAdapter(readConfig, () => llm);
+	const reconcile = () => {
+		const shouldRegister = readConfig().enabled;
+		if (shouldRegister && !registered) {
+			if (llm === void 0) return;
+			try {
+				disposeAdapter = llm.registerAdapter([FALLBACKS_PROVIDER], adapter);
+				registered = true;
+				logger.info("llm-fallbacks: virtual adapter registered — FallbacksChain/Auto is selectable in the model picker");
+			} catch (error) {
+				if (!(error instanceof Error) || !("code" in error) || error.code !== "DUPLICATE_ADAPTER") throw error;
+				logger.debug("llm-fallbacks: virtual adapter already registered — no route on this fiber (multi-fiber dedupe)");
+			}
+		} else if (!shouldRegister && registered) {
+			disposeAdapter?.();
+			disposeAdapter = void 0;
+			registered = false;
+			logger.info("llm-fallbacks: virtual adapter unregistered — FallbacksChain/Auto hidden from the model picker");
+		}
+	};
+	ctx.inject(["llm"], (llmCtx) => {
+		llm = llmCtx.llm;
+		reconcile();
+		return () => {
+			disposeAdapter?.();
+			disposeAdapter = void 0;
+			registered = false;
+			llm = void 0;
+		};
+	});
+	return reconcile;
+}
+//#endregion
 //#region .build/host/index.js
 const name = "llm-fallbacks";
 const provide = ["llm-fallbacks"];
@@ -1042,6 +1582,10 @@ function currentModel(agent, provider) {
 		model: agent.session.requestHeader()?.config.model ?? agent.options.model ?? ""
 	};
 }
+function slotWinnerKey(winner) {
+	if (winner === "all-day") return "all-day";
+	return winner.kind === "preset" ? `preset:${winner.preset}` : `custom:${winner.start}-${winner.end}`;
+}
 function overrideConfig(seed, to) {
 	const { reasoningEffort: _inherited, ...withoutInheritedEffort } = seed;
 	return {
@@ -1052,15 +1596,6 @@ function overrideConfig(seed, to) {
 }
 function apply(ctx, config = defaultFallbacksConfig) {
 	const logger = ctx.logger("llm-fallbacks");
-	const known = dshSession.KNOWN_SESSION_EVENT_TYPES;
-	let sessionEventRegistered = false;
-	if (known instanceof Set) try {
-		known.add("fallbacks/switch");
-		sessionEventRegistered = known.has("fallbacks/switch");
-	} catch {
-		sessionEventRegistered = false;
-	}
-	let sessionEventWarned = false;
 	const entry = Config(config);
 	const seeds = new FallbacksSeedManager(logger);
 	const seedsSettingsUnavailable = "llm-fallbacks: seeds: settings service is unavailable — seed roles cannot be written";
@@ -1099,6 +1634,7 @@ function apply(ctx, config = defaultFallbacksConfig) {
 		ctx.logger("llm-fallbacks").debug("fallbacks service already registered — no service on this fiber (multi-fiber dedupe)");
 	}
 	let source = () => entry;
+	const reconcileFallbacksAdapter = installFallbacksAdapter(ctx, () => source());
 	validateFallbacksConfig(entry, logger);
 	const legacyKeys = detectLegacyKeys(source());
 	if (legacyKeys.length > 0) logger.warn("llm-fallbacks: legacy config keys detected (chains/roles.default/undeclared role refs); see docs/configuration.md migration table — %o", legacyKeys);
@@ -1112,6 +1648,8 @@ function apply(ctx, config = defaultFallbacksConfig) {
 			const current = source();
 			roleIds = new Map(current.roles.list.map((role) => [role.id.trim(), role.id]));
 			hasChains = current.rootChain.length > 0 || current.roles.list.some((role) => (role.chain?.length ?? 0) > 0);
+			reconcileFallbacksAdapter();
+			slotWinners.clear();
 		}
 	});
 	const bridge = { source: () => source() };
@@ -1132,6 +1670,8 @@ function apply(ctx, config = defaultFallbacksConfig) {
 	});
 	const states = new FallbackStateStore();
 	stateStores.set(ctx, states);
+	const dispatchInjected = new Set();
+	const slotWinners = new Map();
 	async function decide(agent, turn, step, current, reason, state) {
 		const config = source();
 		if (state !== void 0) {
@@ -1139,9 +1679,10 @@ function apply(ctx, config = defaultFallbacksConfig) {
 			if (state.stepFailures.switchCount >= config.maxSwitchesPerStep) return null;
 		}
 		const role = resolveRole(agent, config.roles.rules, roleIds, logger.warn);
-		const { all, wildcard } = resolveChainViews(config.roles.list, config.rootChain, role, current.provider, current.model, logger.warn);
+		const rootTail = agent.session?.header?.origin === "subagent" ? config.rootChain : resolveEffectiveChain(config, new Date(), config.tz ?? "Asia/Shanghai");
+		const { all, wildcard } = resolveChainViews(config.roles.list, rootTail, role, current.provider, current.model, logger.warn);
 		if (all.length === 0) return null;
-		const modelExists = hasWildcardEntry(config.roles.list, config.rootChain, role) ? await makeModelExists(ctx, [...new Set(all.map((candidate) => candidate.provider))]) : void 0;
+		const modelExists = hasWildcardEntry(config.roles.list, rootTail, role) ? await makeModelExists(ctx, [...new Set(all.map((candidate) => candidate.provider))]) : void 0;
 		const cooldown = { isSuppressed: (key) => state !== void 0 && states.isSuppressed(state, key) };
 		const failed = { has: (key) => state !== void 0 && state.stepFailures.failed.has(key) };
 		const surviving = selectCandidates(all, wildcard, createCandidateFilter({
@@ -1151,7 +1692,7 @@ function apply(ctx, config = defaultFallbacksConfig) {
 		}), modelExists);
 		const target = surviving[0];
 		if (target === void 0 || target.model === void 0) return null;
-		logger.info("llm-fallbacks: agent \"%s\" switch %s/%s -> %s/%s (role=%s, reason=%s, candidates=%o)", agent.id, current.provider, current.model, target.provider, target.model, role, reason, annotateCandidates(all, surviving, {
+		logger.info("llm-fallbacks: agent \"%s\" fallback switch (降级切换) %s/%s -> %s/%s (role=%s, reason=%s, candidates=%o)", agent.id, current.provider, current.model, target.provider, target.model, role, reason, annotateCandidates(all, surviving, {
 			current,
 			cooldown,
 			failed
@@ -1169,7 +1710,7 @@ function apply(ctx, config = defaultFallbacksConfig) {
 			reason
 		};
 	}
-	function commit(agent, state, pending, turn, step) {
+	function commit(state, pending, turn, step) {
 		const config = source();
 		const fromKey = selectorKey(pending.from.provider, pending.from.model);
 		const until = config.revertPolicy === "never" ? Number.POSITIVE_INFINITY : Date.now() + config.cooldownMs;
@@ -1178,21 +1719,6 @@ function apply(ctx, config = defaultFallbacksConfig) {
 		states.suppress(state, fromKey, until);
 		states.recordFailure(state, fromKey);
 		states.recordSwitch(state);
-		if (!sessionEventRegistered) {
-			if (!sessionEventWarned) {
-				sessionEventWarned = true;
-				logger.warn("llm-fallbacks: session event type \"fallbacks/switch\" is not registered with this harness — skipping the durable event (the switch itself is applied)");
-			}
-			return;
-		}
-		agent.session.append("fallbacks/switch", {
-			turn,
-			step,
-			from: pending.from,
-			to: pending.to,
-			role: pending.role,
-			reason: pending.reason
-		});
 	}
 	ctx.on("agent/request-error", async ({ agent, turn, step, provider, failure }, next) => {
 		const config = source();
@@ -1202,7 +1728,7 @@ function apply(ctx, config = defaultFallbacksConfig) {
 		try {
 			const pending = await decide(agent, turn, step, current, "trigger-code", states.peek(agent.id));
 			if (pending === null) return next();
-			commit(agent, states.get(agent.id), pending, turn, step);
+			commit(states.get(agent.id), pending, turn, step);
 			return { kind: "retry" };
 		} catch (error) {
 			logger.warn("llm-fallbacks: decision path failed, passing the original failure through: %s", error?.message ?? String(error));
@@ -1215,6 +1741,51 @@ function apply(ctx, config = defaultFallbacksConfig) {
 		const applied = state === void 0 ? void 0 : states.applyPending(state, turn, step);
 		if (applied !== void 0) return overrideConfig(seed, applied.to);
 		const config = source();
+		if (config.enabled && isAllDayConforming(config.rootChain) && (config.timeSlots?.length ?? 0) > 0 && agent.session?.header?.origin !== "subagent") {
+			const slot = resolveSlotState(config, new Date(), config.tz ?? "Asia/Shanghai");
+			const key = slotWinnerKey(slot.winner);
+			const previous = slotWinners.get(agent.id);
+			if (previous !== void 0 && previous.key !== key) logger.info("llm-fallbacks: agent \"%s\" time-slot switch (分时切换): %s -> %s", agent.id, previous.label, slot.label);
+			slotWinners.set(agent.id, {
+				key,
+				label: slot.label
+			});
+		}
+		if (config.enabled && seed.provider === "FallbacksChain" && seed.model === "Auto" && agent.session?.header?.origin !== "subagent") {
+			if (!isAllDayConforming(config.rootChain)) logger.warn("llm-fallbacks: FallbacksChain/Auto selected but the all-day rootChain is not conforming (exactly one official V4 model) — no primary override");
+			else {
+				const head = firstDispatchableExactHead(resolveEffectiveChain(config, new Date(), config.tz ?? "Asia/Shanghai"));
+				if (head === void 0) logger.warn("llm-fallbacks: FallbacksChain/Auto selected but the effective chain has no exact head (empty, wildcard-only, or self-route) — no primary override");
+				else {
+					logger.info("llm-fallbacks: FallbacksChain/Auto selection overrides to the effective head %s/%s", head.provider, head.model);
+					return overrideConfig(seed, head);
+				}
+			}
+		}
+		if (config.enabled && hasChains && agent.session?.header?.origin === "subagent" && !dispatchInjected.has(agent.id)) {
+			dispatchInjected.add(agent.id);
+			try {
+				const role = await resolveRoleAtDispatch(agent, config.roles.rules, roleIds, {
+					automatchEnabled: config.roleAutoMatch ?? true,
+					automatch: (agent) => pickRoleByLlm(ctx, config.roles, agent, { warn: logger.warn }),
+					warn: logger.warn
+				});
+				if (role !== "inherit") {
+					const { all, wildcard } = resolveChainViews(config.roles.list, config.rootChain, role, seed.provider, seed.model, logger.warn);
+					const head = firstExactCandidate(all, wildcard);
+					if (head !== void 0 && head.model !== void 0 && !(head.provider === seed.provider && head.model === seed.model)) {
+						const to = {
+							provider: head.provider,
+							model: head.model
+						};
+						logger.info("llm-fallbacks: agent \"%s\" role-inject role=%s model=%s/%s", agent.id, role, head.provider, head.model);
+						return overrideConfig(seed, to);
+					}
+				}
+			} catch (error) {
+				logger.warn("llm-fallbacks: dispatch role-injection failed, proceeding with the request unchanged: %s", error?.message ?? String(error));
+			}
+		}
 		if (hasChains && config.enabled && config.alwaysModeRetryCap > 0 && countRetryEvents(agent.session, turn, step, seed.provider) >= config.alwaysModeRetryCap) {
 			const decisionState = states.peek(agent.id);
 			const pending = await decide(agent, turn, step, {
@@ -1223,7 +1794,7 @@ function apply(ctx, config = defaultFallbacksConfig) {
 			}, "always-cap", decisionState);
 			if (pending !== null) {
 				const commitState = states.get(agent.id);
-				commit(agent, commitState, pending, turn, step);
+				commit(commitState, pending, turn, step);
 				const appliedCap = states.applyPending(commitState, turn, step);
 				if (appliedCap !== void 0) return overrideConfig(seed, appliedCap.to);
 			}
@@ -1237,9 +1808,13 @@ function apply(ctx, config = defaultFallbacksConfig) {
 	});
 	ctx.on("agent/disposed", ({ agent }) => {
 		states.delete(agent.id);
+		dispatchInjected.delete(agent.id);
+		slotWinners.delete(agent.id);
 	});
 	ctx.effect(() => () => {
 		states.clear();
+		dispatchInjected.clear();
+		slotWinners.clear();
 	}, "llm-fallbacks: clear per-agent state");
 	const fallbacksCommandController = {
 		getSnapshot(agent) {
@@ -1250,6 +1825,7 @@ function apply(ctx, config = defaultFallbacksConfig) {
 				origin: agent.session.header?.origin ?? "root",
 				role,
 				...resolveChainForDiagnostic(config.roles.list, config.rootChain, role, logger.warn),
+				slot: resolveSlotState(config, new Date(), config.tz ?? "Asia/Shanghai"),
 				switches: recentFallbacksSwitches(agent.session.events, 5),
 				cooldown: state === void 0 ? [] : state.cooldown.snapshot()
 			};
@@ -1268,7 +1844,8 @@ function apply(ctx, config = defaultFallbacksConfig) {
 				revertPolicy: config.revertPolicy,
 				maxSwitchesPerStep: config.maxSwitchesPerStep,
 				alwaysModeRetryCap: config.alwaysModeRetryCap,
-				presets: config.presets ?? "bundled"
+				presets: config.presets ?? "bundled",
+				roleAutoMatch: config.roleAutoMatch ?? true
 			};
 		}
 	};