dsh-llm-fallbacks 0.4.4 → 0.5.1

package/dist/index.js

@@ -1,6 +1,6 @@
 import { createRequire } from "node:module";
 import z from "@deepseek-ai/schemastery";
-import { LlmAdapter, LlmError, createUserMessage } from "@deepseek-ai/dsh-llm";
+import { LlmAdapter, LlmError, boundContextSummary, createUserMessage } from "@deepseek-ai/dsh-llm";
 import { TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
 //#region .build/host/selectors.js
 var SelectorError = class extends Error {
@@ -668,11 +668,15 @@ function annotateCandidates(candidates, surviving, options) {
 }
 //#endregion
 //#region .build/host/roles.js
-function resolveRole(agent, rules, roleIds, warn = console.warn) {
+function resolveRole(agent, rules, roleIds, warn = console.warn, servedRoute) {
 	if ((agent.session?.header?.origin ?? "root") !== "subagent") return INHERIT_ROLE_ID;
+	const recordedRoute = {
+		provider: agent.options?.provider,
+		model: agent.options?.model
+	};
 	for (const rule of rules) {
-		if (rule.provider && rule.provider !== agent.options?.provider) continue;
-		if (rule.model && rule.model !== agent.options?.model) continue;
+		const matchesPair = (pair) => (!rule.provider || rule.provider === pair.provider) && (!rule.model || rule.model === pair.model);
+		if (!matchesPair(recordedRoute) && !(servedRoute !== void 0 && matchesPair(servedRoute))) continue;
 		const target = rule.role.trim();
 		if (target === "inherit") return INHERIT_ROLE_ID;
 		const declared = roleIds.get(target);
@@ -692,7 +696,7 @@ async function resolveRoleAtDispatch(agent, rules, roleIds, opts) {
 		const declared = roleIds.get(preset);
 		if (declared !== void 0) return declared;
 	}
-	const role = resolveRole(agent, rules, roleIds, opts.warn);
+	const role = resolveRole(agent, rules, roleIds, opts.warn, opts.servedRoute);
 	if (role !== "inherit") return role;
 	if (opts.automatchEnabled && opts.automatch !== void 0) {
 		const picked = await opts.automatch(agent);
@@ -800,6 +804,549 @@ function effectivePolicy(event, settings) {
 	};
 }
 //#endregion
+//#region .build/host/role-notice.js
+const ROLE_NOTICE_PLUGIN = "dsh-llm-fallbacks";
+const ROLE_NOTICE_SOURCE_KIND = "plugin";
+const ROLE_NOTICE_PERSONA_SKIPPED_SUFFIX = " (persona not applied)";
+function markNoticeEmitted(emitted, childSessionId) {
+	if (!emitted.has(childSessionId) && emitted.size >= 256) {
+		const oldest = emitted.values().next().value;
+		if (oldest !== void 0) emitted.delete(oldest);
+	}
+	emitted.add(childSessionId);
+}
+function buildRoleNotice(role, personaNotApplied) {
+	return createUserMessage({
+		content: [{
+			type: "text",
+			text: personaNotApplied ? `[role: ${role}]${ROLE_NOTICE_PERSONA_SKIPPED_SUFFIX}` : `[role: ${role}]`
+		}],
+		source: {
+			kind: ROLE_NOTICE_SOURCE_KIND,
+			plugin: ROLE_NOTICE_PLUGIN,
+			form: "notice",
+			summary: boundContextSummary(`role: ${role}`)
+		}
+	});
+}
+function errorMessage$2(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function installRoleNotice(ctx, options) {
+	const buildNotice = options.buildNotice ?? buildRoleNotice;
+	const debug = (message) => {
+		try {
+			options.debug?.(message);
+		} catch {}
+	};
+	return ctx.on("agent/pre-step", async ({ agent, signal }, next) => {
+		const decision = await next();
+		try {
+			if (decision.kind === "reject" || signal.aborted) return decision;
+			if (decision.messages.length === 0) return decision;
+			if (agent.session?.header?.origin !== "subagent") return decision;
+			if (options.emitted.has(agent.id)) return decision;
+			const record = options.records.get(agent.id);
+			if (record === void 0 || !record.firstNoticePending) return decision;
+			const notice = buildNotice(record.role, record.personaNotApplied === true);
+			markNoticeEmitted(options.emitted, agent.id);
+			record.firstNoticePending = false;
+			return {
+				...decision,
+				messages: [...decision.messages, notice]
+			};
+		} catch (error) {
+			debug(`llm-fallbacks: role notice for agent "${agent.id}" skipped (contained, the step is unchanged): ${errorMessage$2(error)}`);
+			return decision;
+		}
+	}, { prepend: true });
+}
+//#endregion
+//#region .build/host/role-projection-key.js
+const ROLE_PROJECTION_KEY = "fallbacksSubagentRole";
+const ROLE_STATE_SCHEMA = { parse(value) {
+	if (value === null) return null;
+	if (typeof value === "object") {
+		const { role, inheritedEventCount } = value;
+		if (isInheritedEventCount(inheritedEventCount)) {
+			if (role === void 0) return { inheritedEventCount };
+			if (typeof role === "string" && role.trim() !== "") return {
+				inheritedEventCount,
+				role
+			};
+		}
+	}
+	throw new TypeError(`role projection: expected null or a non-blank role id with its fork boundary, got ${describeValue(value)}`);
+} };
+function isInheritedEventCount(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+const ROLE_WIRE_SCHEMA = { parse(value) {
+	if (value === null) return null;
+	if (typeof value === "string" && value.trim() !== "") return value;
+	throw new TypeError(`role projection: expected null or a non-blank role id on the wire, got ${describeValue(value)}`);
+} };
+function describeValue(value) {
+	if (value === void 0) return "undefined";
+	try {
+		return JSON.stringify(value) ?? String(value);
+	} catch {
+		return String(value);
+	}
+}
+const ROLE_NOTICE_TEXT_RE = new RegExp(`^\\[role: ([\\s\\S]+)\\](?:${ROLE_NOTICE_PERSONA_SKIPPED_SUFFIX.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")})?$`);
+function roleFromNoticeText(text) {
+	const role = ROLE_NOTICE_TEXT_RE.exec(text)?.[1];
+	return role === void 0 || role.trim() === "" ? void 0 : role;
+}
+function roleFromContent(content) {
+	if (!Array.isArray(content)) return void 0;
+	for (const block of content) {
+		if (typeof block !== "object" || block === null) continue;
+		const { type, text } = block;
+		if (type !== "text" || typeof text !== "string") continue;
+		const role = roleFromNoticeText(text);
+		if (role !== void 0) return role;
+	}
+}
+function roleFromEvent(event) {
+	if (typeof event !== "object" || event === null) return void 0;
+	const { type, data } = event;
+	if (type !== "user/message") return void 0;
+	if (typeof data !== "object" || data === null) return void 0;
+	const { content, source } = data;
+	if (typeof source !== "object" || source === null) return void 0;
+	const { kind, plugin } = source;
+	if (kind !== "plugin" || plugin !== "dsh-llm-fallbacks") return void 0;
+	return roleFromContent(content);
+}
+const roleProjectionUnit = {
+	key: ROLE_PROJECTION_KEY,
+	stateSchema: ROLE_STATE_SCHEMA,
+	stateVersion: 2,
+	init: (_header, inheritedEventCount) => ({ inheritedEventCount }),
+	apply: (state, event) => {
+		if (typeof event !== "object" || event === null) return state;
+		const inheritedEventCount = state?.inheritedEventCount ?? 0;
+		const { seq } = event;
+		if (typeof seq === "number" && seq < inheritedEventCount) return state;
+		const role = roleFromEvent(event);
+		if (role === void 0 || role === state?.role) return state;
+		return {
+			inheritedEventCount,
+			role
+		};
+	},
+	wire: {
+		viewSchema: ROLE_WIRE_SCHEMA,
+		view: (state) => state === null ? null : state.role ?? null
+	}
+};
+function errorMessage$1(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function installRoleProjection(ctx, options = {}) {
+	const debug = (message) => {
+		try {
+			options.debug?.(message);
+		} catch {}
+	};
+	let child;
+	try {
+		child = ctx.inject(["sessionProjections"], (projectionCtx) => {
+			try {
+				const { sessionProjections: registry } = projectionCtx;
+				if (registry === void 0 || typeof registry.register !== "function") {
+					debug("llm-fallbacks: role projection not registered — the resolved sessionProjections service is not a registry (the badge shows no role on this composition)");
+					return () => {};
+				}
+				return registry.register(roleProjectionUnit);
+			} catch (error) {
+				debug(`llm-fallbacks: role projection not registered (contained): ${errorMessage$1(error)}`);
+				return () => {};
+			}
+		});
+	} catch (error) {
+		debug(`llm-fallbacks: role projection install skipped (contained): ${errorMessage$1(error)}`);
+	}
+	return () => {
+		try {
+			child?.dispose();
+		} catch {}
+	};
+}
+//#endregion
+//#region .build/host/subagents-seam.js
+const SUBAGENT_SEAM_EVENT = "internal/get";
+const SUBAGENT_SEAM_SERVICE = "subagents";
+const SUBAGENT_CATALOG_EVENT = "subagent/catalog";
+const ASSIGNMENT_BODY_START_RE = /^(?:#{1,6}[ \t]+Task\b|-{3,}[ \t]*$|#[ \t])/m;
+const EXECUTE_AS_BOLD_LINE_RE = /^[ \t]*(?:[-*][ \t]+)?\*\*\s*Execute as\s*\*\*\s*:\s*(.*)$/;
+const EXECUTE_AS_PLAIN_LINE_RE = /^[ \t]*(?:[-*][ \t]+)?Execute as\s*:\s*(.*)$/;
+const ASSIGNMENT_HEADER_OPEN_RE = /^(?:#{1,6}[ \t]|-{3,}[ \t]*\r?$|[ \t]*(?:[-*][ \t]+)?\*\*|[ \t]*(?:[-*][ \t]+)?\*{0,2}[A-Za-z][A-Za-z /_-]{0,29}\*{0,2}[ \t]*:[ \t]*\S)/;
+function assignmentHeaderRegion(prompt) {
+	const marker = prompt.match(ASSIGNMENT_BODY_START_RE);
+	return marker !== null && marker.index !== void 0 ? prompt.slice(0, marker.index) : leadingHeaderBlock(prompt);
+}
+function leadingHeaderBlock(prompt) {
+	let end = 0;
+	let offset = 0;
+	let atParagraphStart = true;
+	for (const line of prompt.split("\n")) {
+		offset += line.length + 1;
+		if (line.trim() === "") {
+			atParagraphStart = true;
+			continue;
+		}
+		if (atParagraphStart && !ASSIGNMENT_HEADER_OPEN_RE.test(line.replace(/\r$/, ""))) break;
+		atParagraphStart = false;
+		end = offset;
+	}
+	return end === 0 ? "" : prompt.slice(0, end);
+}
+function declaredExecuteAsValues(prompt) {
+	const values = [];
+	for (const line of assignmentHeaderRegion(prompt).split(/\r?\n/)) {
+		const match = line.match(EXECUTE_AS_BOLD_LINE_RE) ?? line.match(EXECUTE_AS_PLAIN_LINE_RE);
+		if (match !== null && match[1] !== void 0) values.push(match[1].trim());
+	}
+	return values;
+}
+function canonicalizeRoleReference(raw) {
+	const trimmed = raw.trim();
+	const id = (trimmed.startsWith("@") ? trimmed.slice(1) : trimmed).trim();
+	if (id === "" || id === "inherit") return void 0;
+	return id;
+}
+function lookupDeclaredRole(id, roleIds) {
+	const direct = roleIds.get(id);
+	if (direct !== void 0) return direct;
+	const lower = id.toLowerCase();
+	for (const [trimmedId, declared] of roleIds) if (trimmedId.toLowerCase() === lower) return declared;
+}
+function resolveDeclaredRoleFromAssignment(prompt, roleIds) {
+	const declared = new Set();
+	for (const raw of declaredExecuteAsValues(prompt)) {
+		const id = canonicalizeRoleReference(raw);
+		if (id === void 0) continue;
+		const resolved = lookupDeclaredRole(id, roleIds);
+		if (resolved !== void 0) declared.add(resolved);
+	}
+	if (declared.size !== 1) return void 0;
+	return declared.values().next().value;
+}
+function promptTextOf(blocks) {
+	if (!Array.isArray(blocks)) return "";
+	return blocks.filter((block) => block?.type === "text").map((block) => block.text ?? "").join("\n");
+}
+function personaForRole(roles, roleId) {
+	for (const role of roles) {
+		if (role.id !== roleId) continue;
+		const persona = role.persona?.trim() ?? "";
+		return persona === "" ? void 0 : persona;
+	}
+}
+function childSessionIdOf(result) {
+	if (typeof result !== "object" || result === null) return void 0;
+	const value = result;
+	for (const key of [
+		"subagentId",
+		"runId",
+		"childId",
+		"id"
+	]) {
+		const candidate = value[key];
+		if (typeof candidate === "string" && candidate !== "") return candidate;
+	}
+}
+function parentSessionIdOf(request) {
+	const id = request?.parent?.session?.id;
+	return typeof id === "string" && id !== "" ? id : void 0;
+}
+function correlationKey(parentSessionId, label) {
+	return `${parentSessionId}\u0000${label}`;
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+const subagentSeamStores = new WeakMap();
+const subagentSeamStates = new WeakMap();
+function seamStateFor(root) {
+	const existing = subagentSeamStates.get(root);
+	if (existing !== void 0) return existing;
+	const created = {
+		records: new Map(),
+		noticeEmitted: new Set()
+	};
+	subagentSeamStates.set(root, created);
+	return created;
+}
+const subagentSeamRoots = new WeakSet();
+function installSubagentSeam(ctx, options) {
+	const root = ctx.root;
+	const state = seamStateFor(root);
+	const records = state.records;
+	const noticeEmitted = state.noticeEmitted;
+	const ownsWrapper = !subagentSeamRoots.has(root);
+	if (ownsWrapper) subagentSeamRoots.add(root);
+	const pending = new Map();
+	const wrappers = new WeakMap();
+	const disposers = [];
+	let unreadableServiceLogged = false;
+	let noRoleLogged = false;
+	const debug = (message) => {
+		try {
+			options.debug?.(message);
+		} catch {}
+	};
+	const reportDegrade = (error) => {
+		debug(`llm-fallbacks: subagent role seam degraded to the native path (start unaffected): ${errorMessage(error)}`);
+	};
+	const recordChild = (childSessionId, role, at, personaNotApplied) => {
+		const existing = records.get(childSessionId);
+		records.set(childSessionId, {
+			role,
+			at,
+			firstNoticePending: existing?.firstNoticePending ?? true,
+			...personaNotApplied || existing?.personaNotApplied === true ? { personaNotApplied: true } : {}
+		});
+	};
+	const beginCorrelation = (request, role, personaNotApplied) => {
+		const parentSessionId = parentSessionIdOf(request);
+		const label = typeof request?.label === "string" ? request.label : void 0;
+		if (parentSessionId === void 0 || label === void 0 || label === "") return void 0;
+		const key = correlationKey(parentSessionId, label);
+		if (!pending.has(key) && pending.size >= 64) {
+			const oldest = pending.keys().next().value;
+			if (oldest !== void 0) pending.delete(oldest);
+		}
+		pending.delete(key);
+		pending.set(key, {
+			role,
+			at: Date.now(),
+			personaNotApplied
+		});
+		return key;
+	};
+	const endCorrelation = (key) => {
+		if (key !== void 0) pending.delete(key);
+	};
+	const resolveRoleAtSeam = (request) => {
+		try {
+			const prompt = promptTextOf(request?.prompt);
+			if (prompt.trim() === "") return void 0;
+			const role = resolveDeclaredRoleFromAssignment(prompt, options.roleIds());
+			if (role === void 0 && !noRoleLogged) {
+				noRoleLogged = true;
+				debug(`llm-fallbacks: subagent role seam — no role resolved from the Assignment prompt (absent or undeclared '**Execute as**: <id>'); the dispatch is unchanged`);
+			}
+			return role;
+		} catch (error) {
+			reportDegrade(error);
+			return;
+		}
+	};
+	const observeStartResult = (result, onChildId, onNoChildId, onRejected) => {
+		const onValue = (value) => {
+			try {
+				const childSessionId = childSessionIdOf(value);
+				if (childSessionId === void 0) onNoChildId();
+				else onChildId(childSessionId);
+			} catch (error) {
+				reportDegrade(error);
+			}
+		};
+		if (typeof result === "object" && result !== null && typeof result.then === "function") {
+			result.then(onValue, () => {
+				try {
+					onRejected();
+				} catch (error) {
+					reportDegrade(error);
+				}
+			});
+			return;
+		}
+		onValue(result);
+	};
+	const personaGate = (service, providerName, surface) => {
+		if (typeof service.getProvider !== "function") return "unavailable";
+		const provider = service.getProvider(providerName);
+		if (provider === void 0) return "unknown";
+		if (surface === "one-shot") return provider.capabilities?.persona === true ? "ok" : "unsupported";
+		return typeof provider.prepareContinuable === "function" ? "ok" : "unsupported";
+	};
+	const withRolePersona = (service, providerName, request, role, surface) => {
+		if (request.persona !== void 0) return {
+			request,
+			personaNotApplied: false
+		};
+		const readRoles = options.roles;
+		if (readRoles === void 0) return {
+			request,
+			personaNotApplied: false
+		};
+		const persona = personaForRole(readRoles(), role);
+		if (persona === void 0) return {
+			request,
+			personaNotApplied: false
+		};
+		const gate = personaGate(service, providerName, surface);
+		if (gate === "unknown") {
+			debug(`llm-fallbacks: no subagent provider '${providerName}' is registered on the ${surface} start — role persona for '${role}' not delivered (the native start fails loud its own way)`);
+			return {
+				request,
+				personaNotApplied: true
+			};
+		}
+		if (gate === "unavailable") {
+			debug(`llm-fallbacks: role persona for '${role}' skipped on the ${surface} start — the '${SUBAGENT_SEAM_SERVICE}' runtime exposes no provider lookup, so the persona capability cannot be verified (the start proceeds unchanged)`);
+			return {
+				request,
+				personaNotApplied: true
+			};
+		}
+		if (gate === "unsupported") {
+			debug(surface === "one-shot" ? `llm-fallbacks: subagent provider '${providerName}' lacks the persona capability on the ${surface} start — role persona for '${role}' skipped (the start proceeds unchanged)` : `llm-fallbacks: subagent provider '${providerName}' does not support continuable children on the ${surface} surface — role persona for '${role}' skipped (the native continuable start fails loud its own way)`);
+			return {
+				request,
+				personaNotApplied: true
+			};
+		}
+		debug(`llm-fallbacks: role persona delivered via the native subagent persona channel for role '${role}' (${surface} start on provider '${providerName}')`);
+		return {
+			request: {
+				...request,
+				persona
+			},
+			personaNotApplied: false
+		};
+	};
+	const mergePersonaAtSeam = (service, providerName, request, role, surface) => {
+		try {
+			return withRolePersona(service, providerName, request, role, surface);
+		} catch (error) {
+			reportDegrade(error);
+			return {
+				request,
+				personaNotApplied: false
+			};
+		}
+	};
+	const wrapService = (value) => {
+		if (typeof value !== "object" || value === null) {
+			if (value === void 0 && !unreadableServiceLogged) {
+				unreadableServiceLogged = true;
+				debug(`llm-fallbacks: subagent role seam inactive — '${SUBAGENT_SEAM_SERVICE}' did not resolve a service on this read`);
+			}
+			return value;
+		}
+		const service = value;
+		if (typeof service.start !== "function") {
+			if (!unreadableServiceLogged) {
+				unreadableServiceLogged = true;
+				debug(`llm-fallbacks: subagent role seam skipped — '${SUBAGENT_SEAM_SERVICE}' is not a start-capable runtime`);
+			}
+			return value;
+		}
+		const cached = wrappers.get(value);
+		if (cached !== void 0) return cached;
+		const wrapper = Object.create(value);
+		wrapper.start = (name, request) => {
+			const role = resolveRoleAtSeam(request);
+			if (role === void 0) return service.start(name, request);
+			const persona = mergePersonaAtSeam(service, name, request, role, "one-shot");
+			let pendingKey;
+			try {
+				pendingKey = beginCorrelation(request, role, persona.personaNotApplied);
+			} catch (error) {
+				reportDegrade(error);
+			}
+			let result;
+			try {
+				result = service.start(name, persona.request);
+			} catch (error) {
+				endCorrelation(pendingKey);
+				throw error;
+			}
+			try {
+				observeStartResult(result, (childSessionId) => {
+					endCorrelation(pendingKey);
+					recordChild(childSessionId, role, Date.now(), persona.personaNotApplied);
+				}, () => {}, () => endCorrelation(pendingKey));
+			} catch (error) {
+				endCorrelation(pendingKey);
+				reportDegrade(error);
+			}
+			return result;
+		};
+		const startContinuable = service.startContinuable;
+		if (typeof startContinuable === "function") wrapper.startContinuable = (spec) => {
+			const role = resolveRoleAtSeam(spec?.request) ?? (typeof spec?.childId === "string" ? records.get(spec.childId)?.role : void 0);
+			if (role === void 0) return startContinuable.call(service, spec);
+			const outcome = mergePersonaAtSeam(service, spec.provider, spec.request, role, "continuable");
+			const effectiveSpec = outcome.request === spec.request ? spec : {
+				...spec,
+				request: outcome.request
+			};
+			const result = startContinuable.call(service, effectiveSpec);
+			try {
+				observeStartResult(result, (childSessionId) => recordChild(childSessionId, role, Date.now(), outcome.personaNotApplied), () => {}, () => {});
+			} catch (error) {
+				reportDegrade(error);
+			}
+			return result;
+		};
+		wrappers.set(value, wrapper);
+		return wrapper;
+	};
+	if (ownsWrapper) {
+		disposers.push(ctx.on(SUBAGENT_SEAM_EVENT, (_readCtx, name, _error, next) => {
+			const value = next();
+			if (name !== "subagents") return value;
+			try {
+				return wrapService(value);
+			} catch (error) {
+				reportDegrade(error);
+				return value;
+			}
+		}));
+		disposers.push(ctx.on("session/event", (session, event) => {
+			try {
+				if (event.type !== SUBAGENT_CATALOG_EVENT) return;
+				const data = event.data;
+				const childSessionId = data?.childId;
+				const label = data?.label;
+				if (typeof childSessionId !== "string" || childSessionId === "") return;
+				if (typeof label !== "string" || label === "") return;
+				const key = correlationKey(session.id, label);
+				const claim = pending.get(key);
+				if (claim === void 0) return;
+				pending.delete(key);
+				recordChild(childSessionId, claim.role, claim.at, claim.personaNotApplied);
+			} catch (error) {
+				reportDegrade(error);
+			}
+		}));
+	}
+	disposers.push(installRoleNotice(ctx, {
+		records,
+		emitted: noticeEmitted,
+		debug
+	}));
+	disposers.push(installRoleProjection(ctx, { debug }));
+	const seam = {
+		records,
+		noticeEmitted,
+		ownsWrapper,
+		dispose: () => {
+			if (ownsWrapper) subagentSeamRoots.delete(root);
+			for (const dispose of disposers.splice(0)) dispose();
+		}
+	};
+	subagentSeamStores.set(ctx, seam);
+	return seam;
+}
+//#endregion
 //#region .build/host/cooldown.js
 var CooldownStore = class {
 	entries = new Map();
@@ -968,7 +1515,6 @@ function overrideConfigWithRouteRule(seed, to, explicitEffort) {
 //#endregion
 //#region .build/host/gateway.js
 const FALLBACKS_SETTINGS_NAMESPACE = "fallbacks";
-const SUBAGENT_ROLES_MAX_IDS = 256;
 const CONFIG_KEYS = {
 	enabled: true,
 	triggerCodes: true,
@@ -1003,13 +1549,11 @@ var FallbacksConfigGateway = class extends TypertRemoteService {
 	seeds;
 	settings;
 	subagentPolicy;
-	subagentRolesSnapshot;
-	constructor(ctx, bridge, seeds, subagentPolicy, subagentRoles) {
+	constructor(ctx, bridge, seeds, subagentPolicy) {
 		super(ctx, "fallbacks");
 		this.bridge = bridge;
 		this.seeds = seeds;
 		this.subagentPolicy = subagentPolicy;
-		this.subagentRolesSnapshot = subagentRoles;
 		ctx.inject(["settings"], (sctx) => {
 			this.settings = sctx.settings;
 			return () => {
@@ -1044,23 +1588,6 @@ var FallbacksConfigGateway = class extends TypertRemoteService {
 			outcome
 		};
 	}
-	subagentRoles(ids) {
-		if (!Array.isArray(ids) || ids.some((id) => typeof id !== "string")) throw new TypeError("dsh-llm-fallbacks: subagent-roles ids must be an array of strings");
-		if (ids.length > SUBAGENT_ROLES_MAX_IDS) throw new TypeError(`dsh-llm-fallbacks: subagent-roles ids batch exceeds ${SUBAGENT_ROLES_MAX_IDS} entries`);
-		if (this.subagentRolesSnapshot === void 0) return {};
-		let records;
-		try {
-			records = this.subagentRolesSnapshot();
-		} catch {
-			return {};
-		}
-		const projected = new Map();
-		for (const id of ids) {
-			const record = records.get(id);
-			if (record !== void 0) projected.set(id, projectSubagentRoleRecord(record));
-		}
-		return Object.fromEntries(projected);
-	}
 	readConfig(source = this.bridge.source()) {
 		const wire = {};
 		for (const key of Object.keys(CONFIG_KEYS)) {
@@ -1127,17 +1654,6 @@ function projectSubagentPolicy(snapshot) {
 	};
 	return wire;
 }
-function projectSubagentRoleRecord(record) {
-	const wire = {
-		role: record.role,
-		at: record.at
-	};
-	if (record.model !== void 0) wire.model = {
-		provider: record.model.provider,
-		model: record.model.model
-	};
-	return wire;
-}
 function normalizeRoles(value) {
 	if (typeof value !== "object" || value === null || Array.isArray(value)) return value;
 	const roles = {};
@@ -1252,21 +1768,6 @@ function fallbacksTypertContribution() {
 					codec: { mode: "src-json" }
 				}],
 				result: { mode: "src-json" }
-			},
-			{
-				id: "dsh-llm-fallbacks#fallbacks/subagent-roles",
-				service: "fallbacks",
-				namespace: "fallbacks",
-				method: "subagent-roles",
-				implementation: "subagentRoles",
-				invocation: { kind: "direct" },
-				parameters: [{
-					name: "ids",
-					wire: "ids",
-					source: "json",
-					codec: { mode: "src-json" }
-				}],
-				result: { mode: "src-json" }
 			}
 		]
 	};
@@ -1601,6 +2102,7 @@ function registerFallbacksCommands(registry, controller, locale = "zh") {
 var FallbacksSeedManager = class {
 	logger;
 	registry = new Map();
+	declareSeq = 0;
 	constructor(logger) {
 		this.logger = logger;
 	}
@@ -1646,28 +2148,69 @@ var FallbacksSeedManager = class {
 		const config = io.read();
 		const currentList = roleRows(config);
 		const currentRules = roleRules(config);
-		const newList = materialize(currentList, personaView(entries), personaView(this.registry), outcome.conflicts);
+		const candidate = new Map(this.registry);
+		if (entries.size === 0) candidate.delete(source);
+		else candidate.set(source, {
+			seq: this.declareSeq + 1,
+			entries
+		});
+		const prior = new Map();
+		const incoming = new Map();
+		for (const id of entries.keys()) {
+			const before = this.resolveDeclared(id)?.persona;
+			const after = this.resolveDeclared(id, candidate)?.persona;
+			if (before !== void 0) prior.set(id, before);
+			if (after !== void 0) incoming.set(id, after);
+		}
+		const newList = materialize(currentList, incoming, prior, outcome.conflicts);
 		for (const conflict of outcome.conflicts) this.logger.warn(`llm-fallbacks: seeds: persona-source conflict for seed id ${JSON.stringify(conflict.id)} — operator row persona kept (never overwritten)`);
 		const computed = {
 			list: newList,
 			rules: currentRules
 		};
 		if (!deepEqual(newList, currentList)) await io.writeRoles(computed);
-		this.registry = entries;
+		if (entries.size === 0) this.registry.delete(source);
+		else this.registry.set(source, {
+			seq: ++this.declareSeq,
+			entries
+		});
 		return outcome;
 	}
+	resolveDeclared(id, registry = this.registry) {
+		const bundled = registry.get("bundled")?.entries.get(id);
+		if (bundled !== void 0) return {
+			persona: bundled.persona,
+			source: "bundled"
+		};
+		let winner;
+		for (const [label, slice] of registry) {
+			if (label === "bundled") continue;
+			const entry = slice.entries.get(id);
+			if (entry === void 0) continue;
+			if (winner === void 0 || slice.seq > winner.seq) winner = {
+				persona: entry.persona,
+				source: label,
+				seq: slice.seq
+			};
+		}
+		if (winner === void 0) return void 0;
+		return {
+			persona: winner.persona,
+			source: winner.source
+		};
+	}
 	effectiveRoles(io) {
 		return { roles: roleRows(io.read()).map((row) => {
-			const entry = this.registry.get(row.id.trim());
-			const seeded = entry !== void 0;
+			const declared = this.resolveDeclared(row.id.trim());
+			const seeded = declared !== void 0;
 			const effective = {
 				id: row.id,
 				persona: row.persona,
 				seeded,
-				personaOverridden: seeded && row.persona !== entry.persona,
-				source: seeded ? entry.set : "user"
+				personaOverridden: seeded && row.persona !== declared.persona,
+				source: seeded ? declared.source : "user"
 			};
-			if (seeded) effective.seedPersona = entry.persona;
+			if (seeded) effective.seedPersona = declared.persona;
 			if (row.chain !== void 0) effective.chain = row.chain;
 			if (row.fallback !== void 0) effective.fallback = row.fallback;
 			return effective;
@@ -1676,20 +2219,20 @@ var FallbacksSeedManager = class {
 	wireStatus(io) {
 		const status = [];
 		for (const row of roleRows(io.read())) {
-			const entry = this.registry.get(row.id.trim());
-			if (entry === void 0) continue;
+			const declared = this.resolveDeclared(row.id.trim());
+			if (declared === void 0) continue;
 			status.push({
 				id: row.id,
-				overridden: row.persona !== entry.persona,
-				source: entry.set
+				overridden: row.persona !== declared.persona,
+				source: declared.source
 			});
 		}
 		return status;
 	}
 	async revert(id, io) {
 		const seedId = id.trim();
-		const entry = this.registry.get(seedId);
-		if (entry === void 0) return {
+		const declared = this.resolveDeclared(seedId);
+		if (declared === void 0) return {
 			reverted: false,
 			reason: "not-seeded"
 		};
@@ -1701,13 +2244,13 @@ var FallbacksSeedManager = class {
 			reverted: false,
 			reason: "row-absent"
 		};
-		if (rows[index].persona === entry.persona) return {
+		if (rows[index].persona === declared.persona) return {
 			reverted: true,
-			persona: entry.persona
+			persona: declared.persona
 		};
 		const nextList = rows.map((row, i) => i === index ? {
 			...row,
-			persona: entry.persona
+			persona: declared.persona
 		} : row);
 		await io.writeRoles({
 			list: nextList,
@@ -1715,7 +2258,7 @@ var FallbacksSeedManager = class {
 		});
 		return {
 			reverted: true,
-			persona: entry.persona
+			persona: declared.persona
 		};
 	}
 	warnSkip(id, reason) {
@@ -1740,43 +2283,38 @@ function resolveSource(options, logger) {
 	logger.warn(`llm-fallbacks: seeds: ignoring declare set name ${shown} — invalid (empty after trim, non-string, or a reserved label ${reserved}); provenance degrades to "external", the seeds still apply`);
 	return "external";
 }
-function personaView(entries) {
-	const personas = new Map();
-	for (const [id, entry] of entries) personas.set(id, entry.persona);
-	return personas;
-}
-function materialize(rows, registry, previous, conflicts) {
+function materialize(rows, incoming, prior, conflicts) {
 	const next = [];
 	for (const row of rows) {
 		const seedId = row.id.trim();
-		const incoming = registry.get(seedId);
-		if (incoming === void 0) {
+		const inc = incoming.get(seedId);
+		if (inc === void 0) {
 			next.push(row);
 			continue;
 		}
-		const prior = previous.get(seedId);
-		if (prior === void 0) {
-			if (row.persona !== incoming) conflicts.push({
+		const before = prior.get(seedId);
+		if (before === void 0) {
+			if (row.persona !== inc) conflicts.push({
 				id: seedId,
 				kind: "persona-source"
 			});
 			next.push(row);
 			continue;
 		}
-		if (row.persona === prior) {
+		if (row.persona === before && inc !== before) {
 			next.push({
 				...row,
-				persona: incoming
+				persona: inc
 			});
 			continue;
 		}
-		if (row.persona !== incoming) conflicts.push({
+		if (row.persona !== inc) conflicts.push({
 			id: seedId,
 			kind: "persona-source"
 		});
 		next.push(row);
 	}
-	for (const [id, persona] of registry) if (!rows.some((row) => row.id.trim() === id)) next.push({
+	for (const [id, persona] of incoming) if (!rows.some((row) => row.id.trim() === id)) next.push({
 		id,
 		persona
 	});
@@ -2230,6 +2768,37 @@ async function resolveHeadDisplayName(llm, head) {
 	} catch {}
 	return head.model;
 }
+function envelopeProvenance(replayState) {
+	if (typeof replayState !== "object" || replayState === null) return void 0;
+	const response = replayState.response;
+	if (typeof response !== "object" || response === null) return void 0;
+	const { provider, model } = response;
+	if (typeof provider !== "string" || provider === "" || provider === "FallbacksChain") return void 0;
+	if (typeof model !== "string" || model === "") return void 0;
+	return {
+		provider,
+		model
+	};
+}
+function restoreEnvelopeProvenance(messages) {
+	let changed = false;
+	const restored = messages.map((message) => {
+		const source = message.source;
+		if (message.role !== "assistant" || source.kind !== "model") return message;
+		if (source.provider !== "FallbacksChain" || source.model !== "Auto") return message;
+		const provenance = envelopeProvenance(source.replayState);
+		if (provenance === void 0) return message;
+		changed = true;
+		return {
+			...message,
+			source: {
+				...source,
+				...provenance
+			}
+		};
+	});
+	return changed ? restored : messages;
+}
 var FallbacksChainAdapter = class extends LlmAdapter {
 	readConfig;
 	getLlm;
@@ -2277,6 +2846,15 @@ var FallbacksChainAdapter = class extends LlmAdapter {
 			name: model
 		};
 	}
+	providerRetryPolicy(_provider) {
+		try {
+			const head = effectiveHeadOf(this.readConfig(), new Date());
+			if (head === void 0 || head.provider === "FallbacksChain") return void 0;
+			return this.getLlm()?.providerRetryPolicy(head.provider);
+		} catch {
+			return;
+		}
+	}
 	imageRequestPricing(_provider, _model) {
 		try {
 			const head = effectiveHeadOf(this.readConfig(), new Date());
@@ -2297,7 +2875,8 @@ var FallbacksChainAdapter = class extends LlmAdapter {
 		return llm.stream({
 			...options,
 			provider: head.provider,
-			model: head.model
+			model: head.model,
+			messages: restoreEnvelopeProvenance(options.messages)
 		});
 	}
 };
@@ -2357,10 +2936,6 @@ const chainHeadStores = new WeakMap();
 function chainHeads(ctx) {
 	return chainHeadStores.get(ctx);
 }
-const subagentRoleRecordStores = new WeakMap();
-function subagentRoleRecords(ctx) {
-	return subagentRoleRecordStores.get(ctx);
-}
 function latestByAt(map) {
 	let latest;
 	for (const value of map.values()) if (latest === void 0 || value.at >= latest.at) latest = value;
@@ -2412,11 +2987,29 @@ function countRetryEvents(session, turn, step, provider) {
 	}
 	return count;
 }
-function currentModel(agent, provider) {
-	return {
+function anchorServedRoute(config, route, now) {
+	if (route.provider !== "FallbacksChain" || route.model !== "Auto") return route;
+	const head = effectiveHeadOf(config, now);
+	return head === void 0 ? route : {
+		provider: head.provider,
+		model: head.model
+	};
+}
+function servedRouteFor(agent, config) {
+	const provider = agent.options?.provider;
+	const model = agent.options?.model;
+	if (provider === void 0 || model === void 0) return void 0;
+	const anchored = anchorServedRoute(config, {
+		provider,
+		model
+	}, new Date());
+	return anchored.provider === provider && anchored.model === model ? void 0 : anchored;
+}
+function currentModel(agent, provider, config, now) {
+	return anchorServedRoute(config, {
 		provider,
 		model: agent.session.requestHeader()?.config.model ?? agent.options.model ?? ""
-	};
+	}, now);
 }
 function slotWinnerKey(winner) {
 	if (winner === "all-day") return "all-day";
@@ -2532,8 +3125,12 @@ function apply(ctx, config = defaultFallbacksConfig) {
 	chainHeadStores.set(ctx, chainHeadMap);
 	const blockedAttemptMap = new Map();
 	blockedAttemptStores.set(ctx, blockedAttemptMap);
-	const subagentRoleRecordMap = new Map();
-	subagentRoleRecordStores.set(ctx, subagentRoleRecordMap);
+	const subagentSeam = installSubagentSeam(ctx, {
+		roleIds: () => roleIds,
+		roles: () => source().roles.list,
+		debug: (message) => logger.debug(message)
+	});
+	if (!subagentSeam.ownsWrapper) ctx.logger("llm-fallbacks").debug("subagent role seam wrapper already installed on this context root — this fiber registers the notice emitter and the projection unit only (multi-fiber dedupe)");
 	try {
 		new FallbacksConfigGateway(ctx, bridge, seeds, () => {
 			try {
@@ -2548,7 +3145,7 @@ function apply(ctx, config = defaultFallbacksConfig) {
 			} catch {
 				return { policy: { state: "unprovable" } };
 			}
-		}, () => subagentRoleRecordMap);
+		});
 	} catch (error) {
 		if (!(error instanceof Error) || !error.message.includes("has been registered")) throw error;
 		ctx.logger("llm-fallbacks").debug("fallbacks gateway already registered — no gateway on this fiber (multi-fiber dedupe)");
@@ -2573,7 +3170,7 @@ function apply(ctx, config = defaultFallbacksConfig) {
 			states.syncStep(state, turn, step);
 			if (state.stepFailures.switchCount >= config.maxSwitchesPerStep) return null;
 		}
-		const role = resolveRole(agent, config.roles.rules, roleIds, logger.warn);
+		const role = resolveRole(agent, config.roles.rules, roleIds, logger.warn, servedRouteFor(agent, config));
 		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;
@@ -2671,7 +3268,7 @@ function apply(ctx, config = defaultFallbacksConfig) {
 	ctx.on("agent/request-error", async ({ agent, turn, step, provider, failure }, next) => {
 		const config = source();
 		if (!config.enabled || !config.triggerCodes.includes(failure.code)) return next();
-		const current = currentModel(agent, provider);
+		const current = currentModel(agent, provider, config, new Date());
 		if (!current.model) return next();
 		try {
 			const pending = await decide(agent, turn, step, current, "trigger-code", states.peek(agent.id), failure.code);
@@ -2706,17 +3303,6 @@ function apply(ctx, config = defaultFallbacksConfig) {
 				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 model: deepseek-official/deepseek-flash or deepseek-official/deepseek-pro) — 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 {
@@ -2739,7 +3325,8 @@ function apply(ctx, config = defaultFallbacksConfig) {
 						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
+							warn: logger.warn,
+							servedRoute: servedRouteFor(agent, config)
 						});
 						if (role !== "inherit") {
 							const { all, wildcard } = resolveChainViews(config.roles.list, config.rootChain, role, seed.provider, seed.model, logger.warn);
@@ -2755,14 +3342,6 @@ function apply(ctx, config = defaultFallbacksConfig) {
 									model: head.model
 								};
 							}
-							subagentRoleRecordMap.set(agent.id, {
-								role,
-								model: to ?? {
-									provider: seed.provider,
-									model: seed.model
-								},
-								at: Date.now()
-							});
 							if (to !== void 0 && !(to.provider === seed.provider && to.model === seed.model)) {
 								if (policy.state === "enabled") chainHeadMap.set(agent.id, {
 									at: Date.now(),
@@ -2784,19 +3363,17 @@ function apply(ctx, config = defaultFallbacksConfig) {
 		}
 		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, {
+			const capRoute = anchorServedRoute(config, {
 				provider: seed.provider,
 				model: seed.model
-			}, "always-cap", decisionState);
+			}, new Date());
+			const pending = await decide(agent, turn, step, capRoute, "always-cap", decisionState);
 			if (pending !== null) {
 				const commitState = states.get(agent.id);
 				commit(commitState, pending, turn, step);
 				const appliedCap = states.applyPending(commitState, turn, step);
 				if (appliedCap !== void 0) return overrideConfig(seed, appliedCap.to);
-			} else failHalfOpenProbe(agent.id, {
-				provider: seed.provider,
-				model: seed.model
-			});
+			} else failHalfOpenProbe(agent.id, capRoute);
 		}
 		return seed;
 	});
@@ -2811,18 +3388,23 @@ function apply(ctx, config = defaultFallbacksConfig) {
 		slotWinners.delete(agent.id);
 		blockedAttemptMap.delete(agent.id);
 		chainHeadMap.delete(agent.id);
-		subagentRoleRecordMap.delete(agent.id);
+		subagentSeam.records.delete(agent.id);
 		lastKnownPolicySettings.delete(agent.id);
 	});
 	ctx.on("session/event", (session, event) => {
 		if (event.type !== "assistant/message") return;
-		if ((source().recovery ?? "timer") !== "half-open") return;
+		const config = source();
+		if ((config.recovery ?? "timer") !== "half-open") return;
 		if (event.data.interrupted === true) return;
 		const message = event.data.message;
 		if (message.source.kind !== "model") return;
 		const state = states.peek(session.id);
 		if (state === void 0) return;
-		states.observeSuccess(state, selectorKey(message.source.provider, message.source.model));
+		const observed = anchorServedRoute(config, {
+			provider: message.source.provider,
+			model: message.source.model
+		}, new Date());
+		states.observeSuccess(state, selectorKey(observed.provider, observed.model));
 	});
 	ctx.effect(() => () => {
 		states.clear();
@@ -2830,13 +3412,15 @@ function apply(ctx, config = defaultFallbacksConfig) {
 		slotWinners.clear();
 		blockedAttemptMap.clear();
 		chainHeadMap.clear();
-		subagentRoleRecordMap.clear();
+		subagentSeam.records.clear();
+		subagentSeam.noticeEmitted.clear();
+		subagentSeam.dispose();
 		lastKnownPolicySettings.clear();
 	}, "llm-fallbacks: clear per-agent state");
 	const fallbacksCommandController = {
 		getSnapshot(agent) {
 			const config = source();
-			const role = resolveRole(agent, config.roles.rules, roleIds, logger.warn);
+			const role = resolveRole(agent, config.roles.rules, roleIds, logger.warn, servedRouteFor(agent, config));
 			const state = states.peek(agent.id);
 			const recovery = config.recovery ?? "timer";
 			if (state !== void 0 && recovery === "half-open") states.syncRecovery(state, Date.now(), recovery);
@@ -2909,4 +3493,4 @@ function apply(ctx, config = defaultFallbacksConfig) {
 	});
 }
 //#endregion
-export { Config, FallbacksSeedManager, INHERIT_ROLE_ID, ROLE_ID_PATTERN, SelectorError, annotateCandidates, apply, blockedAttempts, chainHeads, countRetryEvents, createCandidateFilter, defaultFallbacksConfig, detectLegacyKeys, hasWildcardEntry, name, parseSelector, presetRoles, provide, resolveCandidate, resolveChain, resolveChainViews, resolveRole, selectCandidates, stateStore, subagentRoleRecords, validateFallbacksConfig };
+export { Config, FallbacksSeedManager, INHERIT_ROLE_ID, ROLE_ID_PATTERN, SelectorError, annotateCandidates, apply, blockedAttempts, chainHeads, countRetryEvents, createCandidateFilter, defaultFallbacksConfig, detectLegacyKeys, hasWildcardEntry, name, parseSelector, presetRoles, provide, resolveCandidate, resolveChain, resolveChainViews, resolveRole, selectCandidates, stateStore, validateFallbacksConfig };