dsh-llm-fallbacks 0.5.2 → 0.6.0

package/dist/gateway.d.ts

@@ -25,20 +25,22 @@
  *
  * Data: `get` reads the `FallbacksSettingsBridge` source — the same live
  * composed config the runtime reads (schema defaults → plugin-row base →
- * settings user layer). There is NO hard-gate resolver (unlike advisor's
+ * profile patch). There is NO hard-gate resolver (unlike advisor's
  * `resolveAdvisorConfig`): the fallbacks decision path runs at
  * `agent/request` time in `src/index.ts`, so the gateway returns the raw
  * composed config — `enabled` is a plain config field, not a gate output.
  * `set` validates the patch against the `Config` schema first (unknown-key
  * rejection unchanged — the settings service itself is non-strict and would
- * merge the unknown key through), then writes the USER layer in-process via
- * `ctx.settings.update` (no exposed-namespace gate on the in-process write —
- * the wire-level `exposedNamespaces()` check only guards the apiproxy path),
- * and returns the new composed value. `reset` (fallbacks-specific third
- * method — advisor has only get/set) clears the user layer via
+ * merge the unknown key through), then writes the plugin's profile-entry
+ * section in-process via `ctx.settings.update` (the `SettingsForms` form
+ * service; 0.1.7-rc.1 replaced the namespace registry — the write lands in
+ * the active profile's patch under {@link FALLBACKS_PROFILE_ENTRY} and the
+ * Loader commits it into the plugin's live config reference), and returns
+ * the new composed value. `reset` (fallbacks-specific third method —
+ * advisor has only get/set) clears the entry's patch section 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). Every read response (get/set/reset)
+ * pin stale defaults into the patch). 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
@@ -48,8 +50,8 @@
  * stays the entry, `get` still works; `set`/`reset` fail with a clear
  * error — KD-G5 fallback). The gateway captures the service through a
  * conditional `ctx.inject(['settings'], ...)` child (the same activation
- * pattern as `installSettingsSection`), because `ctx.settings` is only
- * resolvable from a fiber that declares it.
+ * pattern as the plugin apply's own settings child), because `ctx.settings`
+ * is only resolvable from a fiber that declares it.
  *
  * The returned config is normalized to the typertGateway JSON wire boundary:
  * only schema-declared keys cross the wire, and absent values are OMITTED,
@@ -59,18 +61,31 @@
  * @module dsh-llm-fallbacks/gateway
  */
 import type { Context } from '@deepseek-ai/cordis';
-import type { SettingsNamespace } from '@deepseek-ai/dsh-settings';
+import { type SettingsNamespace } from '@deepseek-ai/dsh-settings';
 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). 0.1.2 removed the `settingsNamespace` helper: the registered
- * namespace is the lowercase-hyphenated literal itself, branded through the
- * `SettingsNamespace` type the service APIs constrain on.
+ * The `fallbacks` service/typert namespace identity (`fallbacks`): the cordis
+ * service key, the typert namespace under `/api/fallbacks/*`, and the settings
+ * identity under the pre-0.1.6 dsh API. 0.1.7-rc.1 settings writes target the
+ * PROFILE ENTRY id instead (see {@link FALLBACKS_PROFILE_ENTRY}); the branded
+ * `SettingsNamespace` type the old service APIs constrained on survives as the
+ * type this constant carries.
  */
 export declare const FALLBACKS_SETTINGS_NAMESPACE: SettingsNamespace;
+/**
+ * The plugin's profile ENTRY id — the settings-write target on dsh 0.1.7-rc.1:
+ * `SettingsForms` keys every form and write by the Loader entry id
+ * (`entry.options.id`), and this plugin's bundle row ships `id: llm-fallbacks`
+ * (`bundle/cordis.patch.yml`), so `settings.update('llm-fallbacks', …)` edits
+ * exactly this plugin's section of the active profile patch. The section IS
+ * the Loader entry config now (schema defaults → bundle row base → profile
+ * patch), so a write is visible to the runtime through the same live config
+ * reference `apply()` reads — no separate registration step.
+ */
+export declare const FALLBACKS_PROFILE_ENTRY = "llm-fallbacks";
 /** One exact child LLM route on the additive `subagentPolicy` wire field (T5). */
 export type SubagentPolicyRoute = {
     provider: string;
@@ -129,7 +144,7 @@ export type SubagentPolicySnapshotFn = () => {
 /**
  * The live configuration source for the gateway (guide §7 — the same bridge
  * shape the runtime reads through). `source()` returns the live composed
- * config (schema defaults → plugin-row base → settings user layer). The
+ * config (schema defaults → plugin-row base → profile patch). The
  * gateway reads it LIVE on every call, so no change notification is needed
  * (the bridge stays minimal: source + the settings write channel; the dead
  * `onChange` fan-out was removed in the QC fix wave — nothing subscribed).
@@ -196,8 +211,8 @@ export declare class FallbacksConfigGateway extends TypertRemoteService {
      */
     constructor(ctx: Context, bridge: FallbacksSettingsBridge, seeds: FallbacksSeedManager, subagentPolicy?: SubagentPolicySnapshotFn);
     /**
-     * Read the current composed config (schema defaults → entry base → settings
-     * user layer). No hard-gate resolver (ADR-2): the raw composed config is
+     * Read the current composed config (schema defaults → entry base → profile
+     * patch). No hard-gate resolver (ADR-2): the raw composed config is
      * the wire value — `enabled` is a plain field, not a gate output.
      * @returns the wire-normalized composed config plus `legacyKeys` — legacy
      *   two-block-era fields (`chains` / `roles.default` / undeclared rule
@@ -209,13 +224,14 @@ export declare class FallbacksConfigGateway extends TypertRemoteService {
      */
     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).
+     * Validate a config patch and write it to the plugin's profile-entry section
+     * (live — the runtime reads the same composed source through the Loader; no
+     * restart needed).
      * @param patch - any subset of the config keys; unknown keys (top-level
      *   and nested under `roles`) are rejected before anything is written.
      * @returns the NEW composed config plus `legacyKeys` detected on the
-     *   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
+     *   POST-WRITE composed source (W-1/F-1): `set` is a config MERGE, so a
+     *   legacy patch section (`chains` / `roles.default`) survives a new-shape
      *   save — the response must keep reporting it, or the client banner
      *   would clear against server truth — plus the post-write `seeds` badge
      *   state (same W-1/F-1 rule as `legacyKeys`). Same shape as `get`.
@@ -224,13 +240,13 @@ export declare class FallbacksConfigGateway extends TypertRemoteService {
      */
     set(patch: FallbacksConfigPatch): Promise<FallbacksReadResult>;
     /**
-     * Clear the fallbacks settings USER layer so the composition defaults
+     * Clear the fallbacks profile-entry section 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
+     *   source — `replace` drops the patch section, but legacy keys carried by
      *   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
+     *   the post-write `seeds` badge state (clearing the patch section 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
@@ -255,7 +271,7 @@ export declare class FallbacksConfigGateway extends TypertRemoteService {
     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
+     * wire boundary. Containment (guide §10): a malformed stored patch section
      * that the non-strict settings schema let through (e.g. an unknown key)
      * must never fail the RPC — only schema-declared keys cross the wire, and
      * absent values are omitted, never present-as-undefined (the result
@@ -271,7 +287,7 @@ 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 plus the additive `seeds` badge state. set/reset must report the
-     * POST-WRITE source: the settings merge retains legacy user-layer keys,
+     * POST-WRITE source: the config merge retains legacy patch-section 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).
@@ -280,13 +296,13 @@ export declare class FallbacksConfigGateway extends TypertRemoteService {
     /**
      * 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).
+     * full `{ list, rules }` to the plugin's profile-entry section — both
+     * arrays always computed from a fresh composed read, so the write stays
+     * correct under the settings merge's 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;
 }

package/dist/index.d.ts

@@ -6,9 +6,11 @@
  * `llm-fallbacks` (see `bundle/cordis.patch.yml`), composed AFTER llm-retry.
  *
  * Wiring:
- * - `fallbacks` settings namespace via {@link installSettingsSection}
- *   (composition entry as base; `scope.watch` → `onChange` re-reads the
- *   runtime and re-validates selectors — spec §4).
+ * - `fallbacks` settings via the Loader entry Config (0.1.7-rc.1: the
+ *   volatile `Config` schema in `src/schema.ts` IS the settings section;
+ *   `apply` reads the Loader's live config reference, and the
+ *   `settings/document-updated` listener re-derives the runtime caches —
+ *   the old `installSection` setSource/onChange contract, spec §4).
  * - `agent/request-error` waterfall: `!enabled` / code ∉ `triggerCodes`
  *   (**always mode included**) → `next()`; otherwise resolve role + chain,
  *   and when a candidate survives the filter (current / cooldown /
@@ -138,4 +140,16 @@ export declare function chainHeads(ctx: Context): ReadonlyMap<string, EffectiveC
  * Exported for direct unit testing of the counting + fast path.
  */
 export declare function countRetryEvents(session: Session, turn: number, step: number, provider: string): number;
-export declare function apply(ctx: Context, config?: FallbacksConfig): void;
+/**
+ * The live config reference the 0.1.7-rc.1 Loader hands `apply` for a
+ * volatile Config schema: an identity-stable `{ get }` view (cosmokit's
+ * `Volatile` protocol) whose snapshot the Loader re-commits on every form
+ * save, so reading `.get()` per call is the authoritative live composed
+ * config. Detected STRUCTURALLY on purpose — the protocol is duck-shaped and
+ * the dev-time schemastery resolved from the lockfile can predate it, in
+ * which case the plain composed object arrives exactly as before.
+ */
+interface LiveConfigRef {
+    get(): unknown;
+}
+export declare function apply(ctx: Context, config?: FallbacksConfig | LiveConfigRef): void;

package/dist/index.js

@@ -35,7 +35,7 @@ function resolveWildcardEntry(failingModel, provider) {
 	};
 }
 function isOfficialAllDayId(id) {
-	return id === "deepseek-official/deepseek-flash" || id === "deepseek-official/deepseek-pro";
+	return id === "deepseek-official/deepseek-flash" || id === "deepseek-official/deepseek-v4-pro";
 }
 const PRESETS = {
 	"liang-peak": {
@@ -362,7 +362,7 @@ function validateFallbacksConfig(config, logger) {
 		if ((role.chain ?? []).length === 0) logger.warn(`llm-fallbacks: role "${role.id}" has no model config — declare at least one chain entry, or use the built-in "inherit" rule target instead`);
 		if (role.fallback !== void 0 && role.fallback !== "inherit-root" && role.fallback !== "none") logger.warn(`llm-fallbacks: role "${role.id}" has invalid fallback "${String(role.fallback)}" — expected "inherit-root" or "none"`);
 	}
-	if (config.rootChain.length > 0 && !isAllDayConforming(config.rootChain)) logger.warn("llm-fallbacks: rootChain must end with exactly one official model (deepseek-official/deepseek-flash or deepseek-official/deepseek-pro) — time-slot rows and the virtual picker row stay inert until the all-day chain tail conforms");
+	if (config.rootChain.length > 0 && !isAllDayConforming(config.rootChain)) logger.warn("llm-fallbacks: rootChain must end with exactly one official model (deepseek-official/deepseek-flash or deepseek-official/deepseek-v4-pro) — time-slot rows and the virtual picker row stay inert until the all-day chain tail conforms");
 	for (const entry of config.rootChain) try {
 		parseSelector(entry);
 	} catch (error) {
@@ -411,8 +411,6 @@ function detectLegacyKeys(source) {
 function isRecordLike(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-//#endregion
-//#region .build/host/schema.js
 const Config = z.object({
 	enabled: z.boolean().default(false),
 	triggerCodes: z.array(z.string()).default([
@@ -459,7 +457,7 @@ const Config = z.object({
 	})).default([]),
 	tz: z.string().default("Asia/Shanghai"),
 	recovery: z.union([z.const("timer"), z.const("half-open")]).default("timer")
-});
+}).extra("volatile", true);
 function buildAutomatchPrompt(roles, agent) {
 	const lines = [
 		"You are assigning a subagent to its best-fit role from a declared taxonomy.",
@@ -806,7 +804,8 @@ 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_SOURCE_KIND = "llm-fallbacks-role-notice";
+const ROLE_NOTICE_LEGACY_SOURCE_KINDS = [`plugin:${ROLE_NOTICE_PLUGIN}`];
 const ROLE_NOTICE_PERSONA_SKIPPED_SUFFIX = " (persona not applied)";
 function markNoticeEmitted(emitted, childSessionId) {
 	if (!emitted.has(childSessionId) && emitted.size >= 256) {
@@ -823,7 +822,6 @@ function buildRoleNotice(role, personaNotApplied) {
 		}],
 		source: {
 			kind: ROLE_NOTICE_SOURCE_KIND,
-			plugin: ROLE_NOTICE_PLUGIN,
 			form: "notice",
 			summary: boundContextSummary(`role: ${role}`)
 		}
@@ -916,8 +914,9 @@ function roleFromEvent(event) {
 	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;
+	const { kind } = source;
+	if (typeof kind !== "string") return void 0;
+	if (kind !== "llm-fallbacks-role-notice" && !ROLE_NOTICE_LEGACY_SOURCE_KINDS.includes(kind)) return;
 	return roleFromContent(content);
 }
 const roleProjectionUnit = {
@@ -1514,7 +1513,7 @@ function overrideConfigWithRouteRule(seed, to, explicitEffort) {
 }
 //#endregion
 //#region .build/host/gateway.js
-const FALLBACKS_SETTINGS_NAMESPACE = "fallbacks";
+const FALLBACKS_PROFILE_ENTRY = "llm-fallbacks";
 const CONFIG_KEYS = {
 	enabled: true,
 	triggerCodes: true,
@@ -1571,13 +1570,13 @@ var FallbacksConfigGateway = class extends TypertRemoteService {
 		if (settings === void 0) throw new Error("fallbacks: settings service is unavailable — configuration cannot be written");
 		const normalized = Object.fromEntries(Object.entries(patch).filter(([, value]) => value !== null));
 		if (Object.keys(normalized).length === 0) return this.readResult();
-		await settings.update(FALLBACKS_SETTINGS_NAMESPACE, normalized);
+		await settings.update(FALLBACKS_PROFILE_ENTRY, normalized);
 		return this.readResult();
 	}
 	async reset() {
 		const settings = this.settings;
 		if (settings === void 0) throw new Error("fallbacks: settings service is unavailable — configuration cannot be written");
-		await settings.replace(FALLBACKS_SETTINGS_NAMESPACE, {});
+		await settings.replace(FALLBACKS_PROFILE_ENTRY, {});
 		return this.readResult();
 	}
 	async revertSeed(id) {
@@ -1614,7 +1613,7 @@ var FallbacksConfigGateway = class extends TypertRemoteService {
 			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 });
+				return settings.update(FALLBACKS_PROFILE_ENTRY, { roles });
 			}
 		};
 	}
@@ -1679,7 +1678,7 @@ function validateConfigPatch(patch) {
 		}
 		if (key === "rootChain") {
 			const chain = patch[key];
-			if (chain !== null && chain !== void 0 && (!Array.isArray(chain) || !isAllDayConforming(chain))) throw new Error("dsh-llm-fallbacks: rootChain must end with exactly one official model (deepseek-official/deepseek-flash or deepseek-official/deepseek-pro)");
+			if (chain !== null && chain !== void 0 && (!Array.isArray(chain) || !isAllDayConforming(chain))) throw new Error("dsh-llm-fallbacks: rootChain must end with exactly one official model (deepseek-official/deepseek-flash or deepseek-official/deepseek-v4-pro)");
 		}
 	}
 	Config(patch);
@@ -2599,10 +2598,10 @@ function buildFallbacksTuiSection() {
 					zh: "根降级链（JSON）",
 					en: "Root chain (JSON)"
 				},
-				hint: "JSON array of model selectors; the last entry must be an official model (deepseek-official/deepseek-flash or deepseek-official/deepseek-pro). Pro is a legal tail but not yet available in the catalog — the settings card shows it disabled.",
+				hint: "JSON array of model selectors; the last entry must be an official model (deepseek-official/deepseek-flash or deepseek-official/deepseek-v4-pro). Pro is available in the catalog — the settings card no longer disables it.",
 				hintDescriptions: {
-					zh: "模型选择器 JSON 数组；末项必须是官方模型（deepseek-official/deepseek-flash 或 deepseek-official/deepseek-pro）。Pro 是合法链尾但目录暂未提供——设置卡中显示为禁用。",
-					en: "JSON array of model selectors; the last entry must be an official model (deepseek-official/deepseek-flash or deepseek-official/deepseek-pro). Pro is a legal tail but not yet available in the catalog — the settings card shows it disabled."
+					zh: "模型选择器 JSON 数组；末项必须是官方模型（deepseek-official/deepseek-flash 或 deepseek-official/deepseek-v4-pro）。Pro 已在目录中提供——设置卡中不再禁用。",
+					en: "JSON array of model selectors; the last entry must be an official model (deepseek-official/deepseek-flash or deepseek-official/deepseek-v4-pro). Pro is available in the catalog — the settings card no longer disables it."
 				},
 				group: "chain",
 				kind: "text",
@@ -2784,7 +2783,7 @@ 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 (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;
@@ -3060,16 +3059,34 @@ function authorizedRouteView(ctx, agent) {
 		} : void 0)
 	};
 }
+function isLiveConfigRef(value) {
+	return typeof value === "object" && value !== null && typeof value.get === "function";
+}
+function normalizeConfig(value) {
+	const plain = isLiveConfigRef(value) ? value.get() : value;
+	const resolved = Config(plain);
+	return isLiveConfigRef(resolved) ? resolved.get() : resolved;
+}
+function mergeConfigLayer(under, over) {
+	if (typeof over !== "object" || over === null || Array.isArray(over)) return under;
+	const merged = { ...under };
+	for (const [key, value] of Object.entries(over)) {
+		if (value === void 0) continue;
+		const current = merged[key];
+		merged[key] = typeof current === "object" && current !== null && !Array.isArray(current) && typeof value === "object" && value !== null && !Array.isArray(value) ? mergeConfigLayer(current, value) : value;
+	}
+	return merged;
+}
 function apply(ctx, config = defaultFallbacksConfig) {
 	const logger = ctx.logger("llm-fallbacks");
-	const entry = Config(config);
+	const entry = normalizeConfig(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 });
+		writeRoles = (roles) => sctx.settings.update(FALLBACKS_PROFILE_ENTRY, { roles });
 		try {
 			sctx.provide("llm-fallbacks", {
 				name: "llm-fallbacks",
@@ -3099,7 +3116,12 @@ function apply(ctx, config = defaultFallbacksConfig) {
 		writeRoles: (roles) => writeRoles(roles)
 	};
 	let serviceOwned = ctx.get("llm-fallbacks") === void 0;
-	let source = () => entry;
+	let settingsComposed;
+	let source = () => {
+		if (isLiveConfigRef(config)) return config.get();
+		if (settingsComposed !== void 0) return settingsComposed;
+		return entry;
+	};
 	const reconcileFallbacksAdapter = installFallbacksAdapter(ctx, () => source());
 	validateFallbacksConfig(entry, logger);
 	const legacyKeys = detectLegacyKeys(source());
@@ -3107,18 +3129,25 @@ function apply(ctx, config = defaultFallbacksConfig) {
 	let roleIds = new Map(entry.roles.list.map((role) => [role.id.trim(), role.id]));
 	let hasChains = entry.rootChain.length > 0 || entry.roles.list.some((role) => (role.chain?.length ?? 0) > 0);
 	ctx.inject(["settings"], (sctx) => {
-		sctx.settings.installSection(ctx, FALLBACKS_SETTINGS_NAMESPACE, Config, entry, {
-			setSource: (current) => {
-				source = current;
-			},
-			onChange: () => {
-				const current = source();
-				roleIds = new Map(current.roles.list.map((role) => [role.id.trim(), role.id]));
-				hasChains = current.rootChain.length > 0 || current.roles.list.some((role) => (role.chain?.length ?? 0) > 0);
-				reconcileFallbacksAdapter();
-				slotWinners.clear();
-			}
+		const settings = sctx.settings;
+		const refreshComposed = () => {
+			const descriptor = settings.describe().find((d) => d.ns === FALLBACKS_PROFILE_ENTRY);
+			settingsComposed = descriptor === void 0 ? void 0 : normalizeConfig(mergeConfigLayer(entry, descriptor.value));
+		};
+		if (!isLiveConfigRef(config)) refreshComposed();
+		const disposeDocumentUpdated = ctx.on("settings/document-updated", (ns) => {
+			if (ns !== "llm-fallbacks") return;
+			if (!isLiveConfigRef(config)) refreshComposed();
+			const current = source();
+			roleIds = new Map(current.roles.list.map((role) => [role.id.trim(), role.id]));
+			hasChains = current.rootChain.length > 0 || current.roles.list.some((role) => (role.chain?.length ?? 0) > 0);
+			reconcileFallbacksAdapter();
+			slotWinners.clear();
 		});
+		return () => {
+			disposeDocumentUpdated();
+			settingsComposed = void 0;
+		};
 	});
 	const bridge = { source: () => source() };
 	const chainHeadMap = new Map();

package/dist/role-notice.d.ts

@@ -27,17 +27,24 @@
  * decision has neither failure mode.
  *
  * Session-write contract (plan Global Constraints, hard): the row is a
- * `user/message` built with `createUserMessage` and the sanctioned plugin source
- * `{ kind: 'plugin', plugin: 'dsh-llm-fallbacks', form: 'notice', summary: … }`.
- * `plugin` is a member of the FROZEN released source-kind set the V2→V3 edge
- * classifies (`dsh-session-format-v2-to-v3/lib/index.js:14-30`: 15 kinds,
- * includes `plugin`); a bespoke kind would write fine and then refuse at the
- * next frozen edge with `cannot safely transform unclassified message source`
- * (`:125`). NO custom session event type, NO `ignorable` marker — a mount-only
- * plugin cannot publish either (`.mstar/projects/_default/references/
- * subagent-role-badge-visible/explore-role-seam-report.md` §Q3). The guard test
- * in `tests/role-notice.spec.ts` pins that membership against a checked-in
- * mirror of the set.
+ * `user/message` built with `createUserMessage` and the producer-declared
+ * source `{ kind: 'llm-fallbacks-role-notice', form: 'notice', summary: … }`.
+ * 0.1.7-rc.1 removed the shared `plugin` kind: `MessageSourceMap` is
+ * producer-declared now ("each producer declares its own `kind` in its own
+ * module; there is no shared catch-all `plugin` kind" — dsh-llm message.d.ts),
+ * so this module merges its own kind and stamps `form: 'notice'` + the bound
+ * summary exactly like the host's own model-switch notice
+ * (`core/agent/src/model-selection.ts`). User-role messages carry any
+ * producer's kind, consumers fall through unknown kinds, and the V4 format
+ * edge retains every direct source kind verbatim — a bespoke kind writes and
+ * survives every frozen edge. NO custom session event type, NO `ignorable`
+ * marker — a mount-only plugin cannot publish either (`.mstar/projects/
+ * _default/references/subagent-role-badge-visible/explore-role-seam-report.md`
+ * §Q3). The guard test in `tests/role-notice.spec.ts` pins the exact literal.
+ * Pre-upgrade durable rows (`kind: 'plugin', plugin: 'dsh-llm-fallbacks'`)
+ * migrate to `kind: 'plugin:dsh-llm-fallbacks'` at the V3→V4 edge; the role
+ * projection accepts that legacy form alongside this kind (see
+ * {@link ROLE_NOTICE_LEGACY_SOURCE_KINDS}).
  *
  * Once per child SESSION: the emitter consumes the seam's per-child record
  * marker (`firstNoticePending`) AND a per-agent `emitted` set (mirroring the
@@ -64,21 +71,42 @@
  * @module dsh-llm-fallbacks/role-notice
  */
 import type { Context } from '@deepseek-ai/cordis';
-import { type UserMessage } from '@deepseek-ai/dsh-llm';
+import { type ContextFormed, type UserMessage } from '@deepseek-ai/dsh-llm';
 import type { SubagentSeamRecord } from './subagents-seam.ts';
+declare module '@deepseek-ai/dsh-llm' {
+    interface MessageSourceMap {
+        'llm-fallbacks-role-notice': {
+            kind: 'llm-fallbacks-role-notice';
+        } & ContextFormed;
+    }
+}
 /**
- * The `plugin` field of every notice this plugin writes. Stable: the durable
- * source's provenance label is read from it (`ui-conversation`
- * `context-provenance.ts` — "the plugin id, or the bare source kind").
+ * The provenance label this plugin's notice rows carried under the pre-0.1.7
+ * `kind: 'plugin'` source API. The durable rows survive as data: the V3→V4
+ * session-format edge rewrites every unlisted V3 plugin source to
+ * `kind: 'plugin:<plugin>'`, so pre-upgrade child sessions carry
+ * `plugin:dsh-llm-fallbacks` rows — {@link ROLE_NOTICE_LEGACY_SOURCE_KINDS}
+ * and the role projection gate on this constant to keep badge continuity
+ * across the upgrade.
  */
 export declare const ROLE_NOTICE_PLUGIN = "dsh-llm-fallbacks";
 /**
- * The message source KIND the notice rides. `plugin` is the sanctioned kind for
- * a plugin-authored notice and a member of the frozen released set (see the
- * module header); the value is exported so the guard test asserts on the exact
- * literal the emitter uses.
+ * The message source KIND the notice rides. 0.1.7-rc.1 removed the shared
+ * `plugin` kind (`MessageSourceMap` is producer-declared now — each producer
+ * declares its own `kind` in its own module, the upstream `model-selection`
+ * precedent), so this module declares `llm-fallbacks-role-notice` above and
+ * the emitter stamps it with `form: 'notice'` + the bound summary exactly like
+ * the host's own model-switch notice. The value is exported so the guard test
+ * asserts on the exact literal the emitter uses.
+ */
+export declare const ROLE_NOTICE_SOURCE_KIND = "llm-fallbacks-role-notice";
+/**
+ * The source kinds the role projection must ALSO accept besides
+ * {@link ROLE_NOTICE_SOURCE_KIND}: the V4-migrated form of the pre-0.1.7
+ * `kind: 'plugin', plugin: 'dsh-llm-fallbacks'` rows (see
+ * {@link ROLE_NOTICE_PLUGIN}).
  */
-export declare const ROLE_NOTICE_SOURCE_KIND = "plugin";
+export declare const ROLE_NOTICE_LEGACY_SOURCE_KINDS: readonly ["plugin:dsh-llm-fallbacks"];
 /** Suffix appended when the role declares a persona that was NOT delivered. */
 export declare const ROLE_NOTICE_PERSONA_SKIPPED_SUFFIX = " (persona not applied)";
 /**

package/dist/role-projection.d.ts

@@ -5,14 +5,15 @@
  *
  * Data source = Task 3's notice row, the plugin's single write primitive: the
  * fold reads the child's committed `user/message` events, keeps the one whose
- * provenance is ours (`source.kind === 'plugin'` + `source.plugin ===
- * ROLE_NOTICE_PLUGIN`), and parses the role out of its **content text**
- * (`[role: <id>]`). No second write path, no new event type, no plugin-owned
- * store: the projection is a pure READ of the log, and the host's projection
- * cache checkpoints every registered unit at session creation, `turn/end` and
- * disposal — so a settled child (served as an unpublished observation whose
- * `projections` ride the follow opening snapshot) and a post-restart view both
- * work with nothing of ours on disk.
+ * provenance is ours (`source.kind` is the producer-declared
+ * ROLE_NOTICE_SOURCE_KIND, or the V3→V4-migrated form of a pre-0.1.7 row —
+ * `ROLE_NOTICE_LEGACY_SOURCE_KINDS`), and parses the role out of its
+ * **content text** (`[role: <id>]`). No second write path, no new event type,
+ * no plugin-owned store: the projection is a pure READ of the log, and the
+ * host's projection cache checkpoints every registered unit at session
+ * creation, `turn/end` and disposal — so a settled child (served as an
+ * unpublished observation whose `projections` ride the follow opening
+ * snapshot) and a post-restart view both work with nothing of ours on disk.
  *
  * NEVER `source.summary`: summaries are truncated at
  * `CONTEXT_SUMMARY_MAX_CHARS = 120` (`@deepseek-ai/dsh-llm` `message.ts`,
@@ -32,9 +33,9 @@
  * The runtime shape relied on — `register({ key, stateSchema, init, apply,
  * wire: { viewSchema, view }, stateVersion })` → unregister disposer — is the
  * documented `ProjectionDefinition` contract of
- * `@deepseek-ai/dsh-session-projection@0.1.5-rc.1`
+ * `@deepseek-ai/dsh-session-projection@0.1.7-rc.1`
  * (`lib/types/index.d.ts:38-80,150-152`); only `.parse` is ever called on the
- * schemas (`lib/index.js:255,305,433`).
+ * schemas (`lib/index.js:255,305,422`).
  *
  * @module dsh-llm-fallbacks/role-projection
  */

package/dist/schema.d.ts

@@ -19,8 +19,28 @@
  * `roles.default`) on the composed object at startup (warn + gateway
  * `legacyKeys`, see `src/index.ts` apply()).
  *
+ * 0.1.7-rc.1 adoption: the whole schema is marked `volatile` (dsh 0.1.6
+ * retired `installSection` — the Loader entry Config IS the settings
+ * section now, and `SettingsForms.update` only accepts volatile paths, so
+ * the marker is what keeps the gateway/card write path legal). One marker
+ * on the ROOT object makes every field live-editable and hands `apply` a
+ * single identity-stable config reference the Loader commits saves into
+ * (no remount per save). The marker rides the generic `.extra()` writer —
+ * the exact bytes `.volatile()` (schemastery ≥3.18.4) writes — because the
+ * dev-time schemastery resolved from the lockfile can predate that sugar;
+ * the `Meta` augmentation below declares the field the ^3.18.2 peer range
+ * admits at its upper end.
+ *
  * @module dsh-llm-fallbacks/schema
  */
 import z from '@deepseek-ai/schemastery';
 import type { FallbacksConfig } from './config.ts';
+declare module '@deepseek-ai/schemastery' {
+    namespace Schemastery {
+        interface Meta {
+            /** Live-editable marker read by the Loader / `SettingsForms` (dsh 0.1.6+). */
+            volatile?: boolean;
+        }
+    }
+}
 export declare const Config: z<FallbacksConfig>;

package/dist/subagents-seam.d.ts

@@ -46,13 +46,13 @@
  * `chain: []` role gets its persona exactly like a chained one (no routing
  * state is read). Both native start surfaces are covered, with the gate each
  * one's fail-loud contract needs (measured on the installed
- * `@deepseek-ai/dsh-subagent` `0.1.5-rc.1`): the one-shot `start` REJECTS a
+ * `@deepseek-ai/dsh-subagent` `0.1.7-rc.1`): the one-shot `start` REJECTS a
  * request carrying `persona` for a provider whose
- * `getProvider(name).capabilities.persona` is not `true` (`lib/index.js:3202-3227`,
+ * `getProvider(name).capabilities.persona` is not `true` (`lib/index.js:3284,3340-3363`,
  * `assertCapabilities`), so the merge pre-checks that flag; the continuable
  * surface is composed by the continuation manager, which applies
- * `request.persona` unconditionally (`lib/index.js:1703-1705`) and is gated by
- * the provider's `prepareContinuable` presence instead (`lib/index.js:3179-3183`).
+ * `request.persona` unconditionally (`lib/index.js:1691`) and is gated by
+ * the provider's `prepareContinuable` presence instead (`lib/index.js:3316-3319`).
  * A gate miss skips the persona with ONE contained debug log — never a failed
  * start. An explicit caller `persona` WINS (the slot is filled only when it is
  * absent), and every skip path returns the caller's OWN request object, so the