dsh-llm-fallbacks 0.5.0 → 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 {
@@ -804,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();
@@ -972,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,
@@ -1007,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 () => {
@@ -1048,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)) {
@@ -1131,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 = {};
@@ -1256,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" }
 			}
 		]
 	};
@@ -2439,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;
@@ -2632,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 {
@@ -2648,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)");
@@ -2845,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(),
@@ -2899,7 +3388,7 @@ 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) => {
@@ -2923,7 +3412,9 @@ 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 = {
@@ -3002,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 };