dsh-llm-fallbacks 0.1.3 → 0.1.5

package/dist/client/locales.d.ts

@@ -35,6 +35,8 @@ export declare const zh: {
     'alwaysModeRetryCap.hint': string;
     'alwaysModeRetryCap.tooltip': string;
     'advanced.label': string;
+    'advanced.expand': string;
+    'advanced.collapse': string;
     'rootChain.label': string;
     'rootChain.hint': string;
     'rootChain.tooltip': string;
@@ -42,8 +44,7 @@ export declare const zh: {
     'chains.selector.remove': string;
     'chains.selector.providerPlaceholder': string;
     'chains.selector.modelPlaceholder': string;
-    'chains.selector.wildcard': string;
-    'chains.selector.noModels': string;
+    'chains.selector.wildcardLegacy': string;
     'chains.selector.noModelsStrict': string;
     'roles.list.label': string;
     'roles.list.hint': string;
@@ -53,6 +54,10 @@ export declare const zh: {
     'roles.idPlaceholder': string;
     'roles.persona': string;
     'roles.personaPlaceholder': string;
+    'roles.seedDefault': string;
+    'roles.seedOverride': string;
+    'roles.revertPersona': string;
+    'roles.seedChainOptional': string;
     'roles.fallback': string;
     'roles.fallback.inherit-root': string;
     'roles.fallback.none': string;
@@ -166,6 +171,8 @@ export declare const en: {
     'alwaysModeRetryCap.hint': string;
     'alwaysModeRetryCap.tooltip': string;
     'advanced.label': string;
+    'advanced.expand': string;
+    'advanced.collapse': string;
     'rootChain.label': string;
     'rootChain.hint': string;
     'rootChain.tooltip': string;
@@ -173,8 +180,7 @@ export declare const en: {
     'chains.selector.remove': string;
     'chains.selector.providerPlaceholder': string;
     'chains.selector.modelPlaceholder': string;
-    'chains.selector.wildcard': string;
-    'chains.selector.noModels': string;
+    'chains.selector.wildcardLegacy': string;
     'chains.selector.noModelsStrict': string;
     'roles.list.label': string;
     'roles.list.hint': string;
@@ -184,6 +190,10 @@ export declare const en: {
     'roles.idPlaceholder': string;
     'roles.persona': string;
     'roles.personaPlaceholder': string;
+    'roles.seedDefault': string;
+    'roles.seedOverride': string;
+    'roles.revertPersona': string;
+    'roles.seedChainOptional': string;
     'roles.fallback': string;
     'roles.fallback.inherit-root': string;
     'roles.fallback.none': string;

package/dist/gateway.d.ts

@@ -1,7 +1,8 @@
 /**
- * T1 (plan llm-fallbacks-settings-gateway) — host-side `fallbacks` config
- * gateway: the `/api/fallbacks/get` + `/api/fallbacks/set` +
- * `/api/fallbacks/reset` endpoints.
+ * T1 (plan llm-fallbacks-settings-gateway) + T3 (plan fallbacks-role-seeds) —
+ * host-side `fallbacks` config gateway: the `/api/fallbacks/get` +
+ * `/api/fallbacks/set` + `/api/fallbacks/reset` + `/api/fallbacks/revert-seed`
+ * endpoints.
  *
  * Transport: the typertGateway `/api` interceptor is the single host-wide RPC
  * slot (a plugin must NOT `connection.rpc.intercept('/api')` again — it would
@@ -37,7 +38,11 @@
  * method — advisor has only get/set) clears the user layer via
  * `ctx.settings.replace(ns, {})`: `set` is merge-only and cannot express
  * "reset to composition defaults" (sending default VALUES as a patch would
- * pin stale defaults into the user layer).
+ * pin stale defaults into the user layer). Every read response (get/set/reset)
+ * carries the additive `seeds: SeedsWireStatus[]` badge state (spec §9.4) and
+ * `revert-seed` exposes revert-to-current-seed-default for one id — both
+ * delegate to the per-apply `FallbacksSeedManager` passed into the
+ * constructor (single point of truth, no copied manager logic).
  *
  * The settings service is OPTIONAL (no settings service → the bridge source
  * stays the entry, `get` still works; `set`/`reset` fail with a clear
@@ -57,6 +62,7 @@ import type { Context } from '@deepseek-ai/cordis';
 import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
 import type { TypertContribution } from '@deepseek-ai/dsh-typert-registry';
 import type { FallbacksConfig } from './config';
+import type { FallbacksSeedManager, SeedRevertOutcome, SeedsWireStatus } from './seeds';
 /** The `fallbacks` settings namespace (registered when a settings service exists). */
 export declare const FALLBACKS_SETTINGS_NAMESPACE: import("@deepseek-ai/dsh-settings").SettingsNamespace;
 /**
@@ -72,6 +78,20 @@ export interface FallbacksSettingsBridge {
 }
 /** Patch shape accepted by `fallbacks.set` — any subset of the config keys. */
 export type FallbacksConfigPatch = Partial<FallbacksConfig>;
+/**
+ * The wire response of every read (get/set/reset — W-1/F-1): the normalized
+ * config plus `legacyKeys` plus the additive `seeds` badge state (spec §9.4,
+ * legacyKeys precedent — old clients ignore it).
+ */
+export interface FallbacksReadResult {
+    config: FallbacksConfig;
+    legacyKeys: string[];
+    seeds: SeedsWireStatus[];
+}
+/** The `fallbacks/revert-seed` response — a read result plus the revert outcome. */
+export interface FallbacksRevertResult extends FallbacksReadResult {
+    outcome: SeedRevertOutcome;
+}
 /**
  * The host-side `fallbacks` config gateway (`/api/fallbacks/get` +
  * `/api/fallbacks/set` + `/api/fallbacks/reset`). Registered as the cordis
@@ -86,14 +106,19 @@ export type FallbacksConfigPatch = Partial<FallbacksConfig>;
  */
 export declare class FallbacksConfigGateway extends TypertRemoteService {
     private readonly bridge;
+    /** The per-apply seed manager — single point of truth for seed state (spec §9.4). */
+    private readonly seeds;
     /** The live settings service once the optional inject child activates. */
     private settings;
     /**
      * @param ctx - owning context (the plugin fiber's ctx inside `apply`).
      * @param bridge - the same `FallbacksSettingsBridge` the runtime reads, so
      *   get/set/reset always operate on the live composed config.
+     * @param seeds - the per-apply `FallbacksSeedManager` constructed in
+     *   `apply()` — the gateway delegates badge state and revert to it (no
+     *   copied manager logic), through the io seam built over this bridge.
      */
-    constructor(ctx: Context, bridge: FallbacksSettingsBridge);
+    constructor(ctx: Context, bridge: FallbacksSettingsBridge, seeds: FallbacksSeedManager);
     /**
      * Read the current composed config (schema defaults → entry base → settings
      * user layer). No hard-gate resolver (ADR-2): the raw composed config is
@@ -102,12 +127,11 @@ export declare class FallbacksConfigGateway extends TypertRemoteService {
      *   two-block-era fields (`chains` / `roles.default` / undeclared rule
      *   role refs) detected on the composed source (schemastery retains them,
      *   plan Task 1 Step 1), so the client can show a migration banner (spec
-     *   §9, incremental field — old clients ignore it).
+     *   §9, incremental field — old clients ignore it) — plus the additive
+     *   `seeds` badge state (spec §9.4, legacyKeys precedent — old clients
+     *   ignore it).
      */
-    get(): {
-        config: FallbacksConfig;
-        legacyKeys: string[];
-    };
+    get(): FallbacksReadResult;
     /**
      * Validate a config patch and write it to the settings USER layer (live —
      * the runtime re-reads the same bridge source; no restart needed).
@@ -117,28 +141,42 @@ export declare class FallbacksConfigGateway extends TypertRemoteService {
      *   POST-WRITE composed source (W-1/F-1): `set` is a settings MERGE, so a
      *   legacy user layer (`chains` / `roles.default`) survives a new-shape
      *   save — the response must keep reporting it, or the client banner
-     *   would clear against server truth. Same shape as `get`.
+     *   would clear against server truth — plus the post-write `seeds` badge
+     *   state (same W-1/F-1 rule as `legacyKeys`). Same shape as `get`.
      * @throws when the patch fails `Config` validation, or when no settings
      *   service is composed (KD-G5: the write channel is unavailable).
      */
-    set(patch: FallbacksConfigPatch): Promise<{
-        config: FallbacksConfig;
-        legacyKeys: string[];
-    }>;
+    set(patch: FallbacksConfigPatch): Promise<FallbacksReadResult>;
     /**
      * Clear the fallbacks settings USER layer so the composition defaults
      * reapply (`settings.replace(ns, {})` — the in-process removal path a
      * merge-only `set` cannot express).
      * @returns the new composed config plus `legacyKeys` on the post-write
      *   source — `replace` drops the user layer, but legacy keys carried by
-     *   the entry base survive and are correctly re-reported (W-1/F-1).
+     *   the entry base survive and are correctly re-reported (W-1/F-1) — plus
+     *   the post-write `seeds` badge state (clearing the user layer also
+     *   clears the materialized seed rows, so the honest response reports the
+     *   emptied state; the registry survives and the next declare re-materializes).
      * @throws when no settings service is composed (KD-G5: the write channel
      *   is unavailable).
      */
-    reset(): Promise<{
-        config: FallbacksConfig;
-        legacyKeys: string[];
-    }>;
+    reset(): Promise<FallbacksReadResult>;
+    /**
+     * Revert one seeded role to its CURRENT declared seed default (AC-3, spec
+     * §9.4) — the gateway half of surface (c), delegating to the same manager
+     * the service method uses (single point of truth). Business failures are
+     * values, never throws: a non-seeded id or a deleted row returns
+     * `{ reverted: false, reason }` without writing. The only throw is the
+     * KD-G5 settings-unavailable path, and only when a write is actually
+     * needed (an idempotent revert at the default needs no channel).
+     * @param id - the seeded role id; matched by trimmed id against the
+     *   registry (row matching, spec §9.3).
+     * @returns the post-write read result (config / legacyKeys / seeds — the
+     *   write happened before this read, W-1/F-1) plus the revert `outcome`.
+     * @throws TypeError when `id` is not a string; Error when the settings
+     *   write channel is unavailable (KD-G5).
+     */
+    revertSeed(id: string): Promise<FallbacksRevertResult>;
     /**
      * Read the live composed config and normalize it to the typertGateway JSON
      * wire boundary. Containment (guide §10): a malformed stored user layer
@@ -156,11 +194,25 @@ export declare class FallbacksConfigGateway extends TypertRemoteService {
     /**
      * The wire response of every read (get/set/reset — W-1/F-1): the
      * normalized config plus `legacyKeys` detected on the live composed
-     * source. set/reset must report the POST-WRITE source: the settings
-     * merge retains legacy user-layer keys, so a save cannot clear them —
-     * the honest response keeps the migration banner until a get agrees.
+     * source plus the additive `seeds` badge state. set/reset must report the
+     * POST-WRITE source: the settings merge retains legacy user-layer keys,
+     * so a save cannot clear them — the honest response keeps the migration
+     * banner until a get agrees; `seeds` follows the same rule (post-write
+     * badge state, W-1/F-1).
      */
     private readResult;
+    /**
+     * The io seam the seed manager writes through (spec §9.1): `read` walks
+     * the same live bridge source the gateway reads; `writeRoles` persists a
+     * full `{ list, rules }` to the settings user layer — both arrays always
+     * computed from a fresh composed read, so the write stays correct under
+     * dsh-settings `mergeLayers` array-replace semantics and never touches
+     * operator rules. The write channel fails with the same KD-G5 message as
+     * set/reset when no settings service is composed. Built fresh per call so
+     * the mutable settings capture is read at call time (the inject child
+     * swaps it when the settings service appears/disappears).
+     */
+    private seedsIo;
 }
 /**
  * The explicit typert contribution for the `fallbacks` gateway endpoints —

package/dist/index.d.ts

@@ -34,6 +34,7 @@ import { Config } from './schema.ts';
 import { resolveChain } from './chains.ts';
 import { resolveRole } from './roles.ts';
 import { FallbackStateStore } from './state.ts';
+import { type EffectiveRolesReadback, type SeedDeclaration, type SeedDeclareOutcome, type SeedRevertOutcome } from './seeds.ts';
 /** The plugin row id mounted by the profile bundle patch. */
 export declare const name = "llm-fallbacks";
 /**
@@ -46,9 +47,11 @@ export declare const provide: readonly ["llm-fallbacks"];
 /**
  * The named cordis service `ctx.get('llm-fallbacks')` exposes while the
  * plugin is applied: the pure-function library surface + `name`/`version`
- * metadata. Deliberately NO runtime state (no stateStore, no event
- * emitters, no filter helpers) — state stays observable via `fallbacks/switch`
- * events and the library API.
+ * metadata, plus the three ADDITIVE role-seed methods (spec §9.1, plan
+ * fallbacks-role-seeds T2). Deliberately no state BEARING FIELDS (no
+ * stateStore, no event emitters, no filter helpers) — the seed methods are
+ * closures over the per-apply `FallbacksSeedManager`, so state stays behind
+ * the closure and dies with the fiber (spec §9.5).
  */
 export interface FallbacksService {
     /** Matches the plugin `name`. */
@@ -59,6 +62,12 @@ export interface FallbacksService {
     resolveChain: typeof resolveChain;
     validateFallbacksConfig: typeof validateFallbacksConfig;
     detectLegacyKeys: typeof detectLegacyKeys;
+    /** (a) Declare the companion's FULL current seed set (replacement semantics, spec §9.1). */
+    declareSeeds(seeds: readonly SeedDeclaration[]): Promise<SeedDeclareOutcome>;
+    /** (b) Sync readback — effective taxonomy with seed annotations. */
+    getEffectiveRoles(): EffectiveRolesReadback;
+    /** (c) Revert one id to the CURRENT declared seed default. */
+    revertSeededPersona(id: string): Promise<SeedRevertOutcome>;
 }
 declare module '@deepseek-ai/cordis' {
     interface Context {
@@ -75,6 +84,7 @@ export { resolveRole, type AgentLike, type Origin, } from './roles.ts';
 export { annotateCandidates, createCandidateFilter, hasWildcardEntry, resolveCandidate, resolveChain, resolveChainViews, selectCandidates, type AnnotatedCandidate, type CandidateFilterOptions, type CandidateSkipReason, type FailingModel, } from './chains.ts';
 export { defaultFallbacksConfig, detectLegacyKeys, INHERIT_ROLE_ID, ROLE_ID_PATTERN, validateFallbacksConfig, type FallbacksConfig, type FallbacksConfigLogger, type FallbacksRole, type FallbacksRoles, type FallbacksRoleRule, type FallbackStrategy, type RevertPolicy, } from './config.ts';
 export { parseSelector, SelectorError, type Selector, } from './selectors.ts';
+export { FallbacksSeedManager, type EffectiveRole, type EffectiveRolesReadback, type SeedConflict, type SeedDeclaration, type SeedDeclareOutcome, type SeedRevertFailReason, type SeedRevertOutcome, type SeedSkipReason, type SeedsIo, type SeedsWireStatus, } from './seeds.ts';
 /**
  * @internal Test seam (T3 review Minor 3): the per-agent fallback state store
  * of the plugin applied to `ctx` — last apply wins. Not part of the plugin's

package/dist/index.js

@@ -403,10 +403,12 @@ const ROLES_KEYS = {
 };
 var FallbacksConfigGateway = class extends TypertRemoteService {
 	bridge;
+	seeds;
 	settings;
-	constructor(ctx, bridge) {
+	constructor(ctx, bridge, seeds) {
 		super(ctx, "fallbacks");
 		this.bridge = bridge;
+		this.seeds = seeds;
 		ctx.inject(["settings"], (sctx) => {
 			this.settings = sctx.settings;
 			return () => {
@@ -433,6 +435,14 @@ var FallbacksConfigGateway = class extends TypertRemoteService {
 		await settings.replace(FALLBACKS_SETTINGS_NAMESPACE, {});
 		return this.readResult();
 	}
+	async revertSeed(id) {
+		if (typeof id !== "string") throw new TypeError("dsh-llm-fallbacks: seed revert id must be a string");
+		const outcome = await this.seeds.revert(id, this.seedsIo());
+		return {
+			...this.readResult(),
+			outcome
+		};
+	}
 	readConfig(source = this.bridge.source()) {
 		const wire = {};
 		for (const key of Object.keys(CONFIG_KEYS)) {
@@ -446,7 +456,18 @@ var FallbacksConfigGateway = class extends TypertRemoteService {
 		const source = this.bridge.source();
 		return {
 			config: this.readConfig(source),
-			legacyKeys: detectLegacyKeys(source)
+			legacyKeys: detectLegacyKeys(source),
+			seeds: this.seeds.wireStatus(this.seedsIo())
+		};
+	}
+	seedsIo() {
+		const settings = this.settings;
+		return {
+			read: () => this.bridge.source(),
+			writeRoles: (roles) => {
+				if (settings === void 0) throw new Error("fallbacks: settings service is unavailable — configuration cannot be written");
+				return settings.update(FALLBACKS_SETTINGS_NAMESPACE, { roles });
+			}
 		};
 	}
 };
@@ -514,6 +535,21 @@ function fallbacksTypertContribution() {
 				invocation: { kind: "direct" },
 				parameters: [],
 				result: { mode: "src-json" }
+			},
+			{
+				id: "dsh-llm-fallbacks#fallbacks/revert-seed",
+				service: "fallbacks",
+				namespace: "fallbacks",
+				method: "revert-seed",
+				implementation: "revertSeed",
+				invocation: { kind: "direct" },
+				parameters: [{
+					name: "id",
+					wire: "id",
+					source: "json",
+					codec: { mode: "src-json" }
+				}],
+				result: { mode: "src-json" }
 			}
 		]
 	};
@@ -644,6 +680,188 @@ function registerFallbacksCommands(registry, controller, locale = "zh") {
 	});
 }
 //#endregion
+//#region .build/host/seeds.js
+var FallbacksSeedManager = class {
+	logger;
+	registry = new Map();
+	constructor(logger) {
+		this.logger = logger;
+	}
+	async declare(seeds, io) {
+		const outcome = {
+			applied: [],
+			skipped: [],
+			conflicts: []
+		};
+		const registry = new Map();
+		for (const seed of seeds) {
+			if (typeof seed.id !== "string" || !ROLE_ID_PATTERN.test(seed.id)) {
+				outcome.skipped.push({
+					id: String(seed.id),
+					reason: "invalid-id"
+				});
+				this.warnSkip(seed.id, "invalid-id");
+				continue;
+			}
+			if (seed.id === "inherit") {
+				outcome.skipped.push({
+					id: seed.id,
+					reason: "reserved-id"
+				});
+				this.warnSkip(seed.id, "reserved-id");
+				continue;
+			}
+			if (registry.has(seed.id)) {
+				outcome.skipped.push({
+					id: seed.id,
+					reason: "duplicate-in-batch"
+				});
+				this.warnSkip(seed.id, "duplicate-in-batch");
+				continue;
+			}
+			registry.set(seed.id, seed.persona);
+			outcome.applied.push(seed.id);
+		}
+		const config = io.read();
+		const currentList = roleRows(config);
+		const currentRules = roleRules(config);
+		const newList = materialize(currentList, registry, this.registry, 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 = registry;
+		return outcome;
+	}
+	effectiveRoles(io) {
+		return { roles: roleRows(io.read()).map((row) => {
+			const seedPersona = this.registry.get(row.id.trim());
+			const seeded = seedPersona !== void 0;
+			const effective = {
+				id: row.id,
+				persona: row.persona,
+				seeded,
+				personaOverridden: seeded && row.persona !== seedPersona
+			};
+			if (seeded) effective.seedPersona = seedPersona;
+			if (row.chain !== void 0) effective.chain = row.chain;
+			if (row.fallback !== void 0) effective.fallback = row.fallback;
+			return effective;
+		}) };
+	}
+	wireStatus(io) {
+		const status = [];
+		for (const row of roleRows(io.read())) {
+			const seedPersona = this.registry.get(row.id.trim());
+			if (seedPersona === void 0) continue;
+			status.push({
+				id: row.id,
+				overridden: row.persona !== seedPersona
+			});
+		}
+		return status;
+	}
+	async revert(id, io) {
+		const seedId = id.trim();
+		const seedPersona = this.registry.get(seedId);
+		if (seedPersona === void 0) return {
+			reverted: false,
+			reason: "not-seeded"
+		};
+		const config = io.read();
+		const rows = roleRows(config);
+		const rules = roleRules(config);
+		const index = rows.findIndex((row) => row.id.trim() === seedId);
+		if (index === -1) return {
+			reverted: false,
+			reason: "row-absent"
+		};
+		if (rows[index].persona === seedPersona) return {
+			reverted: true,
+			persona: seedPersona
+		};
+		const nextList = rows.map((row, i) => i === index ? {
+			...row,
+			persona: seedPersona
+		} : row);
+		await io.writeRoles({
+			list: nextList,
+			rules
+		});
+		return {
+			reverted: true,
+			persona: seedPersona
+		};
+	}
+	warnSkip(id, reason) {
+		const shown = typeof id === "string" ? JSON.stringify(id) : String(id);
+		if (reason === "invalid-id") this.logger.warn(`llm-fallbacks: seeds: skipping seed id ${shown} — invalid-id (must match ${String(ROLE_ID_PATTERN)} as declared)`);
+		else if (reason === "reserved-id") this.logger.warn(`llm-fallbacks: seeds: skipping seed id ${shown} — reserved-id ("${INHERIT_ROLE_ID}" is not a legal seed target)`);
+		else this.logger.warn(`llm-fallbacks: seeds: skipping seed id ${shown} — duplicate-in-batch (first wins)`);
+	}
+};
+function materialize(rows, registry, previous, conflicts) {
+	const next = [];
+	for (const row of rows) {
+		const seedId = row.id.trim();
+		const incoming = registry.get(seedId);
+		if (incoming === void 0) {
+			next.push(row);
+			continue;
+		}
+		const prior = previous.get(seedId);
+		if (prior === void 0) {
+			if (row.persona !== incoming) conflicts.push({
+				id: seedId,
+				kind: "persona-source"
+			});
+			next.push(row);
+			continue;
+		}
+		if (row.persona === prior) {
+			next.push({
+				...row,
+				persona: incoming
+			});
+			continue;
+		}
+		if (row.persona !== incoming) 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({
+		id,
+		persona
+	});
+	return next;
+}
+function roleRows(config) {
+	const list = config.roles?.list;
+	return Array.isArray(list) ? list : [];
+}
+function roleRules(config) {
+	const rules = config.roles?.rules;
+	return Array.isArray(rules) ? rules : [];
+}
+function deepEqual(a, b) {
+	if (a === b) return true;
+	if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+	if (Array.isArray(a) !== Array.isArray(b)) return false;
+	if (Array.isArray(a)) {
+		const aa = a;
+		const bb = b;
+		return aa.length === bb.length && aa.every((item, index) => deepEqual(item, bb[index]));
+	}
+	const aKeys = Object.keys(a);
+	const bKeys = Object.keys(b);
+	if (aKeys.length !== bKeys.length) return false;
+	return aKeys.every((key) => deepEqual(a[key], b[key]));
+}
+//#endregion
 //#region .build/host/index.js
 const name = "llm-fallbacks";
 const provide = ["llm-fallbacks"];
@@ -695,6 +913,23 @@ function overrideConfig(seed, to) {
 function apply(ctx, config = defaultFallbacksConfig) {
 	const logger = ctx.logger("llm-fallbacks");
 	const entry = Config(config);
+	const seeds = new FallbacksSeedManager(logger);
+	const seedsSettingsUnavailable = "llm-fallbacks: seeds: settings service is unavailable — seed roles cannot be written";
+	let writeRoles = () => {
+		throw new Error(seedsSettingsUnavailable);
+	};
+	ctx.inject(["settings"], (sctx) => {
+		writeRoles = (roles) => sctx.settings.update(FALLBACKS_SETTINGS_NAMESPACE, { roles });
+		return () => {
+			writeRoles = () => {
+				throw new Error(seedsSettingsUnavailable);
+			};
+		};
+	});
+	const seedsIo = {
+		read: () => source(),
+		writeRoles: (roles) => writeRoles(roles)
+	};
 	try {
 		ctx.provide("llm-fallbacks", {
 			name: "llm-fallbacks",
@@ -702,7 +937,10 @@ function apply(ctx, config = defaultFallbacksConfig) {
 			resolveRole,
 			resolveChain,
 			validateFallbacksConfig,
-			detectLegacyKeys
+			detectLegacyKeys,
+			declareSeeds: (declarations) => seeds.declare(declarations, seedsIo),
+			getEffectiveRoles: () => seeds.effectiveRoles(seedsIo),
+			revertSeededPersona: (id) => seeds.revert(id, seedsIo)
 		});
 	} catch (error) {
 		if (!(error instanceof Error) || !error.message.includes("has been registered")) throw error;
@@ -726,7 +964,7 @@ function apply(ctx, config = defaultFallbacksConfig) {
 	});
 	const bridge = { source: () => source() };
 	try {
-		new FallbacksConfigGateway(ctx, bridge);
+		new FallbacksConfigGateway(ctx, bridge, seeds);
 	} 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)");
@@ -861,4 +1099,4 @@ function apply(ctx, config = defaultFallbacksConfig) {
 	});
 }
 //#endregion
-export { Config, INHERIT_ROLE_ID, ROLE_ID_PATTERN, SelectorError, annotateCandidates, apply, countRetryEvents, createCandidateFilter, defaultFallbacksConfig, detectLegacyKeys, hasWildcardEntry, name, parseSelector, provide, resolveCandidate, resolveChain, resolveChainViews, resolveRole, selectCandidates, stateStore, validateFallbacksConfig };
+export { Config, FallbacksSeedManager, INHERIT_ROLE_ID, ROLE_ID_PATTERN, SelectorError, annotateCandidates, apply, countRetryEvents, createCandidateFilter, defaultFallbacksConfig, detectLegacyKeys, hasWildcardEntry, name, parseSelector, provide, resolveCandidate, resolveChain, resolveChainViews, resolveRole, selectCandidates, stateStore, validateFallbacksConfig };