dsh-llm-fallbacks 0.4.4 → 0.5.0

package/dist/index.js

@@ -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);
@@ -1601,6 +1605,7 @@ function registerFallbacksCommands(registry, controller, locale = "zh") {
 var FallbacksSeedManager = class {
 	logger;
 	registry = new Map();
+	declareSeq = 0;
 	constructor(logger) {
 		this.logger = logger;
 	}
@@ -1646,28 +1651,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 +1722,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 +1747,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 +1761,7 @@ var FallbacksSeedManager = class {
 		});
 		return {
 			reverted: true,
-			persona: entry.persona
+			persona: declared.persona
 		};
 	}
 	warnSkip(id, reason) {
@@ -1740,43 +1786,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 +2271,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 +2349,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 +2378,8 @@ var FallbacksChainAdapter = class extends LlmAdapter {
 		return llm.stream({
 			...options,
 			provider: head.provider,
-			model: head.model
+			model: head.model,
+			messages: restoreEnvelopeProvenance(options.messages)
 		});
 	}
 };
@@ -2412,11 +2494,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";
@@ -2573,7 +2673,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 +2771,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 +2806,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 +2828,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);
@@ -2784,19 +2874,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;
 	});
@@ -2816,13 +2904,18 @@ function apply(ctx, config = defaultFallbacksConfig) {
 	});
 	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();
@@ -2836,7 +2929,7 @@ function apply(ctx, config = defaultFallbacksConfig) {
 	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);

package/dist/role-resolution.d.ts

@@ -51,6 +51,17 @@ export interface ResolveRoleAtDispatchOptions {
     automatch?: (agent: AgentLike) => Promise<string | null>;
     /** Warning sink — the decision path injects the plugin logger. */
     warn: (message: string) => void;
+    /**
+     * The route the agent's request was actually SERVED by, when that differs
+     * from the pair recorded on the agent (the virtual `FallbacksChain/Auto`
+     * row). Rule matching accepts either, so a rule keyed on the real chain head
+     * keeps matching a child whose recorded route is the virtual pair (QC1 I-1).
+     * `undefined` for every real route.
+     */
+    servedRoute?: {
+        provider: string;
+        model: string;
+    };
 }
 /**
  * Resolve the dispatch-time role for an agent across three ordered stages

package/dist/roles.d.ts

@@ -82,4 +82,7 @@ export interface AgentLike {
  * decision path injects the cordis `logger.warn` so every plugin warning
  * flows through the plugin log namespace (qc2 F-002 / qc3 S-3).
  */
-export declare function resolveRole(agent: AgentLike, rules: FallbacksRoleRule[], roleIds: ReadonlyMap<string, string>, warn?: (message: string) => void): string;
+export declare function resolveRole(agent: AgentLike, rules: FallbacksRoleRule[], roleIds: ReadonlyMap<string, string>, warn?: (message: string) => void, servedRoute?: {
+    provider: string;
+    model: string;
+}): string;

package/dist/seeds.d.ts

@@ -11,20 +11,34 @@
  * State model (spec §9.2) — two stores, strictly separated:
  * 1. operator config rows (persisted; a seeded role is a plain
  *    `roles.list` row `{ id, persona }`), and
- * 2. an in-memory per-apply seed registry (`Map<id, { persona, set }>` —
- *    the declared default persona plus its provenance label), declare =
- *    replacement (the batch is the companion's full current set).
+ * 2. an in-memory per-apply seed registry keyed by PRODUCER LABEL
+ *    (`bundled` | set name | `external`), each slice holding that
+ *    producer's current id → `{ persona, set }` declarations. Declare =
+ *    replacement PER PRODUCER: a declare replaces only its own slice, so
+ *    the plugin's bundled presets stay `bundled` even when a companion
+ *    merge-preserves them into its own batch (plan
+ *    seeds-source-and-persona-width, Decisions #1).
  * `seeded` / `personaOverridden` / `source` are DERIVED at read time, never
  * stored — a config round-trip cannot orphan an override (AC-3), and
  * provenance rides the in-memory registry only, so it can never churn a
  * settings write.
  *
+ * Resolution precedence (Decisions #2): `bundled` wins for any id the
+ * plugin's own preset self-declare currently declares; otherwise the most
+ * recent non-bundled producer declaring the id wins (its set name, or
+ * `external` when unnamed); no live declaration ⇒ `user`. Unnamed producers
+ * share the `external` slice (Decisions #3); `{ set }` is the remedy.
+ *
  * Materialization (spec §9.2): append `{ id, persona }` (two keys only,
  * R4) / attach row untouched / at-default tracking / override preserved +
- * `'persona-source'` conflict / omitted id drops from the registry while
- * the row stays (R2). No delta → no settings write (idempotent, AC-1).
- * Compute → write → commit registry: a failed write throws and leaves the
- * registry unchanged (retry-safe).
+ * `'persona-source'` conflict / omitted id drops from the declaring
+ * producer's slice while the row stays (R2). Tracking is driven by the
+ * id's RESOLVED effective default — `prior` = resolved before the
+ * declare, `incoming` = resolved after the candidate slice commit — so a
+ * producer that is not the resolution winner for an id it declares never
+ * rewrites the row (F-001). No delta → no settings write (idempotent,
+ * AC-1). Compute → write → commit registry: a failed write throws and
+ * leaves the registry unchanged (retry-safe).
  *
  * @module dsh-llm-fallbacks/seeds
  */
@@ -151,13 +165,22 @@ export interface SeedsIo {
  */
 export declare class FallbacksSeedManager {
     private readonly logger;
-    /** Per-apply declaration registry: declared default persona + provenance label. */
+    /**
+     * Per-producer declaration registry: producer label (`bundled` | set
+     * name | `external`) → that producer's current slice. A declare replaces
+     * only its own slice; an empty batch drops the slice.
+     */
     private registry;
+    /** Monotonic declare counter — "most recent producer" for resolution precedence. */
+    private declareSeq;
     constructor(logger: FallbacksConfigLogger);
     /**
-     * Declare seeds with replacement semantics — the batch is the
-     * companion's FULL current declaration set; ids omitted from the batch
-     * drop out of the registry while their rows remain (R2).
+     * Declare seeds with replacement semantics PER PRODUCER — the batch is
+     * the producer's FULL current declaration set; ids omitted from the
+     * batch drop out of that producer's slice while their rows remain (R2).
+     * Other producers' slices are untouched, so a companion merge-preserving
+     * the bundled presets into its own batch never re-labels them (Decisions
+     * #1).
      *
      * `options` labels the whole batch's provenance (spec §2), resolved once
      * per call: an invalid set name warns once and degrades to the unnamed
@@ -165,27 +188,46 @@ export declare class FallbacksSeedManager {
      *
      * Per-id validation AS DECLARED (spec §9.3): non-string / pattern miss /
      * reserved `inherit` / duplicate-in-batch → skip + warn; valid siblings
-     * still apply (AC-5). Materializes per spec §9.2, writes only when the
-     * computed `{ list, rules }` differs from the current composed roles
-     * (idempotent, AC-1), and commits the registry only after a successful
-     * write (compute → write → commit; retry-safe).
+     * still apply (AC-5). Materializes per spec §9.2 against the id's
+     * RESOLVED effective default before/after the candidate slice commit
+     * (at-default tracking follows the resolution winner — a producer that
+     * is not the winner for an id it declares never rewrites the row),
+     * writes only when the computed `{ list, rules }` differs from the
+     * current composed roles (idempotent, AC-1), and commits the slice only
+     * after a successful write (compute → write → commit; retry-safe). An
+     * empty batch drops the producer's slice.
      */
     declare(seeds: readonly SeedDeclaration[], io: SeedsIo, options?: SeedsInternalDeclareOptions): Promise<SeedDeclareOutcome>;
+    /**
+     * Resolve one id's live declaration across producer slices (spec §2,
+     * Decisions #2): the bundled preset self-declare wins for any id it
+     * currently declares; otherwise the most recent non-bundled producer
+     * declaring the id wins (its set name, or `external` when unnamed); no
+     * live declaration ⇒ `undefined` (the row reads `user`). Single place —
+     * `effectiveRoles`, `wireStatus`, and `revert` can never disagree. The
+     * optional `registry` argument resolves against a CANDIDATE registry
+     * (the declaring slice already replaced) — the same precedence, used by
+     * `declare` to compute the post-commit effective default for tracking.
+     */
+    private resolveDeclared;
     /**
      * Readback (b) — sync, derived: every config row annotated with
      * `seeded` / `personaOverridden` / `seedPersona` (trimmed row-id
      * membership in the live declaration set; persona inequality) plus the
-     * row's provenance `source` (spec §2): the declaring set's label, or
-     * `user` when no live declaration covers the row. Nothing
-     * override-shaped is stored, so a config round-trip cannot orphan state.
+     * row's provenance `source` (spec §2): the winning producer's label per
+     * `resolveDeclared`, or `user` when no live declaration covers the row.
+     * Nothing override-shaped is stored, so a config round-trip cannot
+     * orphan state.
      */
     effectiveRoles(io: SeedsIo): EffectiveRolesReadback;
     /** Card badge state (spec §9.4): seeded rows, with the override flag and the provenance label. */
     wireStatus(io: SeedsIo): SeedsWireStatus[];
     /**
-     * Revert one id to the CURRENT declared seed default (AC-3). Writes
-     * persona only — the row is otherwise copied verbatim (R4). Ids absent
-     * from the registry (`not-seeded`) or with a deleted row (`row-absent`)
+     * Revert one id to the CURRENT declared seed default (AC-3) — resolved
+     * through the same precedence as the readbacks, so a preserved bundled id
+     * reverts to the bundled persona, never a companion's copy. Writes
+     * persona only — the row is otherwise copied verbatim (R4). Ids with no
+     * live declaration (`not-seeded`) or with a deleted row (`row-absent`)
      * return a non-reverted outcome without throwing; a failed settings
      * write propagates loudly (spec §9.1).
      */

package/dist/time-slots.d.ts

@@ -78,7 +78,7 @@ export declare const PRESETS: Record<PresetId, PresetDefinition>;
  * are the ordered walk before that last-resort fallback. An empty chain or
  * a chain whose tail is not an official model (including the retired V4
  * ids) keeps slot rows inert and refuses the virtual-row
- * override/delegate; the v0.2.2 failure walk over the raw chain stays
+ * delegate; the v0.2.2 failure walk over the raw chain stays
  * verbatim.
  */
 export declare function isAllDayConforming(chain: readonly string[]): boolean;
@@ -92,7 +92,8 @@ export declare function isAllDayConforming(chain: readonly string[]): boolean;
  * P6 (qc1 F-001): without a conforming all-day the slot rows are inert, so
  * this IS the raw `rootChain` — the gate lives in {@link resolveSlotState},
  * the single source every slot surface (this, the 分时切换 log, the
- * `/fallbacks` strip, select-is-primary, the virtual adapter delegate) reads.
+ * `/fallbacks` strip, the virtual adapter delegate, its served-route anchor)
+ * reads.
  */
 export declare function resolveEffectiveChain(config: FallbacksConfig, now: Date, tz: string): string[];
 /**