dsh-autotier 0.2.3 → 0.2.6

package/lib/index.js

@@ -1,6 +1,7 @@
-import { a as TIER_INVOCATIONS, c as TIER_SESSION_VIEW_SCHEMA, d as TIER_STATUS_SCHEMA, f as COST_MODES, g as TIER_IDS, h as SCENARIOS, i as TIER_CATALOG_SCHEMA, l as TIER_SET_MODE_DESCRIPTOR, m as ROUTING_MODES, n as TIER_AGENT_ID_SCHEMA, o as TIER_MODE_SCHEMA, p as EFFORT_IDS, r as TIER_CATALOG_DESCRIPTOR, s as TIER_NAMESPACE, t as ROUTE_SOURCES, u as TIER_STATUS_DESCRIPTOR } from "./wire-BpKSOHgo.js";
+import { a as TIER_INVOCATIONS, c as TIER_SESSION_VIEW_SCHEMA, d as TIER_STATUS_SCHEMA, f as COST_MODES, g as TIER_IDS, h as SCENARIOS, i as TIER_CATALOG_SCHEMA, l as TIER_SET_MODE_DESCRIPTOR, m as ROUTING_MODES, n as TIER_AGENT_ID_SCHEMA, o as TIER_MODE_SCHEMA, p as EFFORT_IDS, r as TIER_CATALOG_DESCRIPTOR, s as TIER_NAMESPACE, t as ROUTE_SOURCES, u as TIER_STATUS_DESCRIPTOR } from "./wire-BxsY8BiN.js";
+import { isVolatile } from "@deepseek-ai/cosmokit";
 import z from "@deepseek-ai/schemastery";
-import { BlockAssembler, createUserMessage } from "@deepseek-ai/dsh-llm";
+import { BlockAssembler, boundContextSummary, createUserMessage } from "@deepseek-ai/dsh-llm";
 import { Service } from "@deepseek-ai/cordis";
 import { TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
 import { defineTool } from "@deepseek-ai/dsh-tools";
@@ -403,15 +404,6 @@ function registerTierCommand(ctx, service, states) {
 }
 //#endregion
 //#region src/schema.ts
-/**
-* The raw (possibly partial) configuration surface of dsh-autotier: the
-* Schemastery schema the Loader validates and the settings UI renders, plus the
-* interfaces it resolves to. The judgement that turns a raw config into a
-* resolved one lives in `config.ts`, so this module stays free of executable
-* logic (a schema module must not mix function values into its declarations).
-*
-* @module dsh-autotier/schema
-*/
 /** The default strong tier: the catalog's quality-critical model at high effort. */
 const DEFAULT_STRONG = {
 	provider: "deepseek-official",
@@ -422,14 +414,14 @@ const DEFAULT_STRONG = {
 /** The default cheap tier: the catalog's routine/parallel model at low effort. */
 const DEFAULT_CHEAP = {
 	provider: "deepseek-official",
-	model: "deepseek-v4-flash",
+	model: "deepseek-flash",
 	effort: "low",
 	followSession: true
 };
 /** The default vision landing: the catalog's only image-capable model. */
 const DEFAULT_VISION = {
 	provider: "deepseek-official",
-	model: "deepseek-v4-flash-vision-exp"
+	model: "deepseek-flash"
 };
 /**
 * One tier schema per tier, so a partially-specified tier gets the same
@@ -457,7 +449,15 @@ const cheapTier = z.object({
 		model: z.string().default("")
 	})).default([])
 });
-/** Schemastery schema: the loader validates and fills defaults before `apply`. */
+/**
+* Schemastery schema: the loader validates and fills defaults before `apply`.
+*
+* Each top-level section is `.volatile()` so a host settings-form write reaches
+* a running plugin through `loader/volatile-update`. A section that owns no
+* live-switchable field (`routingMode`) stays plain: `.volatile()` is an opt-in
+* that adds a form-editable surface, and inventing one for a field the plugin
+* already switches per session would give the same behaviour two owners.
+*/
 const Config = z.object({
 	tiers: z.object({
 		strong: strongTier.default({
@@ -470,7 +470,7 @@ const Config = z.object({
 		}),
 		vision: z.object({
 			provider: z.string().default("deepseek-official"),
-			model: z.string().default("deepseek-v4-flash-vision-exp")
+			model: z.string().default("deepseek-flash")
 		}).default({ ...DEFAULT_VISION })
 	}).default({
 		strong: {
@@ -482,7 +482,7 @@ const Config = z.object({
 			fallback: []
 		},
 		vision: { ...DEFAULT_VISION }
-	}),
+	}).volatile(),
 	intent: z.object({
 		ruleThreshold: z.number().min(1e-6).max(1).default(.7),
 		attemptBand: z.object({
@@ -581,7 +581,7 @@ const Config = z.object({
 			multimodal: true
 		},
 		costMode: "balanced"
-	}),
+	}).volatile(),
 	guard: z.object({
 		enabled: z.boolean().default(true),
 		tiers: z.array(z.union(["cheap"])).default(["cheap"]),
@@ -604,7 +604,7 @@ const Config = z.object({
 			".github/workflows"
 		],
 		interopDefend: "auto"
-	}),
+	}).volatile(),
 	escalation: z.object({
 		threshold: z.number().step(1).min(1).max(100).default(2),
 		windowMs: z.number().min(1).max(864e5).default(6e4),
@@ -617,7 +617,7 @@ const Config = z.object({
 		ttlMs: 18e4,
 		fallbackTtlMs: 3e5,
 		signature: true
-	}),
+	}).volatile(),
 	routingMode: z.union([...ROUTING_MODES]).default("auto")
 });
 //#endregion
@@ -630,6 +630,47 @@ const Config = z.object({
 *
 * @module dsh-autotier/config
 */
+/**
+* Read one config field that may arrive as a live reference or as plain data.
+* The Loader hands `apply` a `VolatileConfig` (every section is a reference);
+* a programmatic mount, a test, or `scripts/` hands plain data. Both faces feed
+* the same resolver, so neither can drift from the other.
+*
+* `Volatile.get()` answers a deeply-readonly snapshot. The resolvers below read
+* these values and then produce their own frozen output, so the read-only view
+* is exactly the contract wanted; the cast re-widens it to the mutable field
+* type so those signatures do not have to carry `readonly` everywhere.
+*
+* @param value - the field as handed to the plugin.
+* @returns the current snapshot value.
+*/
+function unwrap(value) {
+	return isVolatile(value) ? value.get() : value;
+}
+/**
+* Read the plain-data config out of either accepted face.
+*
+* `exactOptionalPropertyTypes` is on, so an absent section is omitted rather
+* than set to `undefined`: the resolvers below treat "key absent" and "key
+* undefined" alike, but only the omitted form is assignable to `Config`.
+*
+* @param raw - the plugin configuration as received.
+* @returns the plain-data config every resolver below reads.
+*/
+function plain(raw) {
+	if (raw === void 0) return {};
+	const tiers = unwrap(raw.tiers);
+	const intent = unwrap(raw.intent);
+	const guard = unwrap(raw.guard);
+	const escalation = unwrap(raw.escalation);
+	return {
+		...tiers === void 0 ? {} : { tiers },
+		...intent === void 0 ? {} : { intent },
+		...guard === void 0 ? {} : { guard },
+		...escalation === void 0 ? {} : { escalation },
+		...raw.routingMode === void 0 ? {} : { routingMode: raw.routingMode }
+	};
+}
 /** Throw the standard fail-loud config error for one invalid field. */
 function invalid(field, detail) {
 	throw new Error(`dsh-autotier: config.${field} ${detail}`);
@@ -815,12 +856,23 @@ function effectiveLanding(tier) {
 * Resolve raw config to the frozen runtime policy, re-judging every default,
 * bound and cross-field requirement.
 *
-* @param raw - raw loader config; `undefined` for a bare row.
+* The cross-field judgement is the whole reason this module exists, and it is
+* NOT expressed in the Schemastery schema: the host validates a form write
+* against the schema alone, so a violation this function catches (a strong and
+* a cheap tier landing on the same route, `hysteresis.toCheap >= toStrong`, a
+* rule with neither a pattern nor a tool) would otherwise persist and only fail
+* later. Every actor that can change the configuration therefore routes through
+* here — the Loader at mount, and `settings.ts` on each `loader/volatile-update`
+* — and refuses the change instead of storing something unroutable.
+*
+* @param raw - raw loader config; `undefined` for a bare row. Accepts both the
+*   Loader's `VolatileConfig` face and the plain-data `Config` face.
 * @returns the frozen resolved config.
 * @throws {Error} when a value is out of bounds or a cross-field requirement fails.
 */
 function resolveConfig(raw) {
-	const tiers = raw?.tiers ?? {};
+	const source = plain(raw);
+	const tiers = source.tiers ?? {};
 	const strong = resolveTier("strong", tiers.strong, DEFAULT_STRONG);
 	const cheap = resolveTier("cheap", tiers.cheap, DEFAULT_CHEAP);
 	const strongTriple = effectiveLanding(strong);
@@ -834,20 +886,21 @@ function resolveConfig(raw) {
 				model: text("tiers.vision.model", tiers.vision?.model, DEFAULT_VISION.model)
 			}
 		},
-		intent: resolveIntent(raw?.intent),
-		guard: resolveGuard(raw?.guard),
-		escalation: resolveEscalation(raw?.escalation),
-		routingMode: member("routingMode", raw?.routingMode, "auto", ROUTING_MODES)
+		intent: resolveIntent(source.intent),
+		guard: resolveGuard(source.guard),
+		escalation: resolveEscalation(source.escalation),
+		routingMode: member("routingMode", source.routingMode, "auto", ROUTING_MODES)
 	});
 }
 /**
-* Judge a configuration without keeping the resolved value. This is the
-* save-time hook the `autotier` settings namespace registers, so a user write
-* that violates a cross-field requirement is refused at the write instead of
-* silently disabling the plugin.
+* Judge a configuration without keeping the resolved value.
 *
 * @param value - the configuration to judge.
 * @throws {Error} when the configuration is invalid.
+* @deprecated The host no longer offers a `settings.register` validate hook, so
+*   this is no longer wired as a save-time gate. {@link resolveConfig} is the
+*   single judge and is called directly at mount and on every live update; this
+*   alias remains exported because it is part of the plugin's published surface.
 */
 function validateConfig(value) {
 	resolveConfig(value);
@@ -1987,8 +2040,9 @@ async function runJudge(ctx, config, text, signal) {
 				text: prompt
 			}],
 			source: {
-				kind: "plugin",
-				plugin: "dsh-autotier"
+				kind: "dsh-autotier",
+				form: "notice",
+				summary: boundContextSummary(`autotier judge: classify intent (${route.provider}/${route.model})`)
 			}
 		})],
 		temperature: config.intent.judge.temperature,
@@ -2103,6 +2157,57 @@ var RoutePreflight = class {
 		return safe;
 	}
 };
+/**
+* Mount-time default-model catalogue membership check.
+*
+* The 0.1.6 line removed the deepseek v4-flash* catalogue ids and introduced
+* `deepseek-flash` (image-capable). On that catalogue generation a default
+* tier id that is not in the host catalogue must fail the mount loudly —
+* silently degrading to a text-only passthrough is exactly the N7 regression
+* this check guards against.
+*
+* Generation gate: hosts whose catalogue predates the new vocabulary (e.g.
+* `0.1.2-rc.1`, where none of the default ids exist) keep the accepted M2
+* degradation (unlisted id ⇒ text-only) and skip the check with one
+* documented log line, so mounting on the old compat rows is preserved.
+*
+* @param ctx - the plugin context.
+* @param tiers - the resolved tier landings to verify.
+* @throws {Error} when the catalogue is the new generation and a default
+*   model id is not present in it.
+*/
+async function assertTierDefaultsInCatalog(ctx, tiers) {
+	const provider = "deepseek-official";
+	const llm = ctx.llm;
+	if (llm === void 0 || typeof llm.listProviders !== "function" || typeof llm.resolveModelInfo !== "function") {
+		ctx.logger.info("dsh-autotier: the llm catalogue seam is unavailable; skipping the default-model catalogue check");
+		return;
+	}
+	if (!llm.listProviders().some((entry) => entry.id === provider)) {
+		ctx.logger.info("dsh-autotier: provider \"%s\" is not registered; skipping the default-model catalogue check", provider);
+		return;
+	}
+	const defaults = [
+		["strong", tiers.strong.model],
+		["cheap", tiers.cheap.model],
+		["vision", tiers.vision.model]
+	];
+	let newGeneration = false;
+	for (const [, model] of defaults) try {
+		await llm.resolveModelInfo(provider, model);
+		newGeneration = true;
+		break;
+	} catch {}
+	if (!newGeneration) {
+		ctx.logger.info("dsh-autotier: the host catalogue predates the deepseek-flash vocabulary; skipping the default-model catalogue check (unlisted ids degrade to text-only on this host)");
+		return;
+	}
+	for (const [tier, model] of defaults) try {
+		await llm.resolveModelInfo(provider, model);
+	} catch {
+		throw new Error(`dsh-autotier: the default ${tier} model "${provider}/${model}" is not in the host catalogue; refusing to mount with a silent text-only landing`);
+	}
+}
 //#endregion
 //#region src/selection.ts
 /** Key of one selection, for comparing our own writes with external ones. */
@@ -2124,28 +2229,47 @@ var SelectionSync = class {
 	constructor(options) {
 		this.ctx = options.ctx;
 		this.states = options.states;
-		this.ctx.on("settings/updated", (ns, next) => {
-			if (String(ns) !== "agent-default-model") return;
-			const key = selectionKey(next);
-			if (this.selfWrite === key) {
-				this.selfWrite = void 0;
-				return;
-			}
-			this.delegateLiveSessions(key);
-		});
 	}
 	/** The optional default-model service. */
 	get defaultModel() {
 		return this.ctx.get("agentDefaultModel");
 	}
 	/**
-	* Mirror one applied landing into the default-model document. Repeated
-	* landings with the same value are skipped, so a long cheap run writes once.
+	* Read the documented selection and delegate every live session when it is
+	* no longer the value this module wrote.
+	*
+	* Before this module's first write nothing is delegated, whatever the
+	* document holds: at that point "not ours" describes the composition default
+	* and any selection the user made before the plugin ever routed, and neither
+	* is an override of a routing decision. Once this module owns a write, any
+	* divergence is by construction somebody else's edit.
+	*/
+	observeExternalSelection() {
+		if (this.selfWrite === void 0) return;
+		const service = this.defaultModel;
+		if (service === void 0) return;
+		let current;
+		try {
+			current = service.currentSelection();
+		} catch (error) {
+			this.ctx.logger.debug("dsh-autotier: could not read the default-model selection: %o", error);
+			return;
+		}
+		const key = selectionKey(current);
+		if (key === this.selfWrite) return;
+		this.delegateLiveSessions(key);
+	}
+	/**
+	* Mirror one applied landing into the default-model document. An external
+	* change to that document is honoured first, so routing never overwrites the
+	* model the user picked. Repeated landings with the same value are skipped,
+	* so a long cheap run writes once.
 	* @param route - the landing actually applied.
 	*/
 	noteRoute(route) {
 		const service = this.defaultModel;
 		if (service === void 0) return;
+		this.observeExternalSelection();
 		const selection = {
 			provider: route.provider,
 			model: route.model,
@@ -2229,6 +2353,13 @@ var AutotierRouter = class {
 		this.ctx.on("agent/error", (payload) => this.onAgentError(payload.agent, payload.error));
 		this.ctx.on("agent/request-error", (payload, next) => this.onRequestError(payload.agent, payload.provider, payload.failure, next));
 		this.ctx.on("session/event", (session, event) => this.onSessionEvent(session, event));
+		this.ctx.on("agent/created", (payload) => {
+			try {
+				this.states.for(payload.agent);
+			} catch (error) {
+				this.ctx.logger.warn("dsh-autotier: could not backfill routing state for the created agent (%o)", error);
+			}
+		});
 		this.ctx.effect(() => () => {
 			this.disposed = true;
 			this.lifetime.abort();
@@ -2626,25 +2757,33 @@ function routeOf(tier) {
 * plugin unloading removes the service with every listener it owns.
 */
 var AutotierService = class extends Service {
-	scope;
 	posteriorTable = new PosteriorTable();
 	resolved;
 	compiled;
 	/**
-	* Register the service as `ctx.autotier` and start following the settings
-	* namespace.
+	* Register the service as `ctx.autotier`.
 	* @param ctx - the owning plugin context.
-	* @param options - the live settings scope and the mount-time configuration.
+	* @param options - the mount-time configuration.
 	*/
 	constructor(ctx, options) {
 		super(ctx, "autotier");
-		this.scope = options.scope;
 		this.resolved = options.config;
 		this.compiled = compileRules(options.config.intent.rules);
-		ctx.effect(() => this.scope.watch((next) => {
-			this.resolved = resolveConfig(next);
-			this.compiled = compileRules(this.resolved.intent.rules);
-		}));
+	}
+	/**
+	* Adopt a configuration a live settings write produced. The caller has
+	* already judged it through {@link resolveConfig}, so this only swaps the
+	* policy and recompiles the rule table.
+	*
+	* The whole policy is replaced, never merged: a settings form submits the
+	* complete Config, so a field the user cleared must fall back to its schema
+	* default rather than keep the previous live value.
+	*
+	* @param config - the newly resolved configuration.
+	*/
+	reconfigure(config) {
+		this.resolved = config;
+		this.compiled = compileRules(config.intent.rules);
 	}
 	/** The live resolved configuration. */
 	config() {
@@ -2712,6 +2851,34 @@ var AutotierService = class extends Service {
 	}
 };
 //#endregion
+//#region src/settings.ts
+/**
+* Claim the settings page policy and follow live configuration edits.
+*
+* The page-policy claim is best-effort: `settings` is a hard inject, but a host
+* line that composes the plugin without the settings service must still route,
+* so a missing or differently-shaped service degrades to "no page" instead of
+* failing the mount.
+*
+* @param options - the plugin context, the volatile row config and the service.
+*/
+function bindSettings(options) {
+	const { ctx, config, service } = options;
+	const settings = ctx.get("settings");
+	if (settings !== void 0 && typeof settings.configure === "function") ctx.effect(() => settings.configure({ auto: false }, ctx.fiber));
+	ctx.on("loader/volatile-update", () => {
+		let next;
+		try {
+			next = resolveConfig(config);
+		} catch (error) {
+			ctx.logger.warn("dsh-autotier: keeping the last good routing policy; the updated configuration was refused: %s", error instanceof Error ? error.message : String(error));
+			return;
+		}
+		service.reconfigure(next);
+		ctx.logger.info("dsh-autotier: routing policy reloaded from a live configuration update");
+	});
+}
+//#endregion
 //#region src/state.ts
 /** The projection key autotier owns. */
 const TIER_PROJECTION_KEY = "autotier";
@@ -3006,25 +3173,25 @@ const inject = [
 	"sessions"
 ];
 /**
-* Mount the plugin: judge the configuration, register the `autotier` settings
-* namespace, publish the `ctx.autotier` service, and wire the routing listeners,
-* the `/tier` command and the two read-only tools.
+* Mount the plugin: judge the configuration, claim the settings page policy,
+* publish the `ctx.autotier` service, and wire the routing listeners, the
+* `/tier` command and the two read-only tools.
 *
 * @param ctx - the plugin context.
-* @param config - the raw row configuration; every field is optional.
-* @throws {Error} when the configuration fails the cross-field judgement.
+* @param config - the Loader's volatile row configuration. Also accepts the
+*   plain-data `AutotierConfig` face, so a programmatic mount or a test can
+*   pass literal values.
+* @throws {Error} when the configuration fails the cross-field judgement, or
+*   when a default tier model id is absent from a new-generation host catalogue.
 */
-function apply(ctx, config = {}) {
+async function apply(ctx, config = {}) {
 	const resolved = resolveConfig(config);
-	const service = new AutotierService(ctx, {
-		scope: ctx.settings.register("autotier", Config, {
-			base: config,
-			applies: "live",
-			validate: (value) => {
-				validateConfig(value);
-			}
-		}),
-		config: resolved
+	await assertTierDefaultsInCatalog(ctx, resolved.tiers);
+	const service = new AutotierService(ctx, { config: resolved });
+	bindSettings({
+		ctx,
+		config,
+		service
 	});
 	registerTierProjection(ctx);
 	const states = new AgentStateStore();

package/lib/typert.host.js

@@ -1,4 +1,4 @@
-import { a as TIER_INVOCATIONS } from "./wire-BpKSOHgo.js";
+import { a as TIER_INVOCATIONS } from "./wire-BxsY8BiN.js";
 //#region src/typert.host.ts
 /**
 * The hand-written Typert HOST manifest for `dsh-autotier`, exported as

package/lib/types/client/TierSettingsCard.d.ts

@@ -1,13 +1,15 @@
 /**
- * The autotier Settings card (Plugins section): the session routing-mode
- * selector, the read-only tier landings, the live session state, and the model
- * catalog dropdown fed by `tier/catalog`.
+ * The autotier card on the Plugins page (`plugins.item`, id `autotier`): the
+ * session routing-mode selector, the read-only tier landings, the live session
+ * state, and the model catalog dropdown fed by `tier/catalog`.
  *
- * The selector writes the *session* override for the session currently open in
- * the shell (resolved by the client entry through the sessions store face), so
- * it stays non-persistent exactly like the pill and `/tier`. When no session is
- * open the host answers with an empty session view and the selector is disabled
- * with an explanation instead of failing silently.
+ * The Plugins page renders it in two views: `summary` (the one-liner under the
+ * card title) and `page` (the full panel). The selector writes the *session*
+ * override for the session currently open in the shell (resolved by the client
+ * entry through the sessions store face), so it stays non-persistent exactly
+ * like the pill and `/tier`. When no session is open the host answers with an
+ * empty session view and the selector is disabled with an explanation instead
+ * of failing silently.
  *
  * @module dsh-autotier/client/TierSettingsCard
  */
@@ -24,8 +26,8 @@ export interface TierSettingsInjected {
     /** Pin or clear the current session's routing mode. */
     setMode: (mode: RoutingMode) => Promise<TierStatus>;
 }
-/** Full component props assembled by the Plugins-tab renderer. */
-export type TierSettingsCardProps = PropsRuntime<'settings.plugins.tab'> & PropsLocale<'settings.autotier'> & InjectFace<TierSettingsInjected>;
-/** The Settings card body. */
-export declare function TierSettingsCard({ status, catalog, setMode, t }: TierSettingsCardProps): ReactNode;
+/** Full component props assembled by the Plugins-page renderer. */
+export type TierSettingsCardProps = PropsRuntime<'plugins.item'> & PropsLocale<'settings.autotier'> & InjectFace<TierSettingsInjected>;
+/** The Plugins-page card body. */
+export declare function TierSettingsCard({ status, catalog, setMode, t, view }: TierSettingsCardProps): ReactNode;
 //# sourceMappingURL=TierSettingsCard.d.ts.map

package/lib/types/client/TierSettingsCard.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TierSettingsCard.d.ts","sourceRoot":"","sources":["../../../src/client/TierSettingsCard.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAuB,KAAK,SAAS,EAAE,MAAM,OAAO,CAAA;AAC3D,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAA;AAC7F,OAAO,EAAiB,KAAK,WAAW,EAAE,MAAM,aAAa,CAAA;AAC7D,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAGzD,kFAAkF;AAClF,MAAM,WAAW,oBAAoB;IACnC,2CAA2C;IAC3C,MAAM,EAAE,MAAM,OAAO,CAAC,UAAU,CAAC,CAAA;IACjC,4CAA4C;IAC5C,OAAO,EAAE,MAAM,OAAO,CAAC,WAAW,CAAC,CAAA;IACnC,uDAAuD;IACvD,OAAO,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,OAAO,CAAC,UAAU,CAAC,CAAA;CACpD;AAED,kEAAkE;AAClE,MAAM,MAAM,qBAAqB,GAC/B,YAAY,CAAC,sBAAsB,CAAC,GAClC,WAAW,CAAC,mBAAmB,CAAC,GAChC,UAAU,CAAC,oBAAoB,CAAC,CAAA;AAOpC,8BAA8B;AAC9B,wBAAgB,gBAAgB,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,EAAE,EAAE,qBAAqB,GAAG,SAAS,CAoIlG"}
+{"version":3,"file":"TierSettingsCard.d.ts","sourceRoot":"","sources":["../../../src/client/TierSettingsCard.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAuB,KAAK,SAAS,EAAE,MAAM,OAAO,CAAA;AAC3D,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAA;AAC7F,OAAO,EAAiB,KAAK,WAAW,EAAE,MAAM,aAAa,CAAA;AAC7D,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAGzD,kFAAkF;AAClF,MAAM,WAAW,oBAAoB;IACnC,2CAA2C;IAC3C,MAAM,EAAE,MAAM,OAAO,CAAC,UAAU,CAAC,CAAA;IACjC,4CAA4C;IAC5C,OAAO,EAAE,MAAM,OAAO,CAAC,WAAW,CAAC,CAAA;IACnC,uDAAuD;IACvD,OAAO,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,OAAO,CAAC,UAAU,CAAC,CAAA;CACpD;AAED,mEAAmE;AACnE,MAAM,MAAM,qBAAqB,GAC/B,YAAY,CAAC,cAAc,CAAC,GAC1B,WAAW,CAAC,mBAAmB,CAAC,GAChC,UAAU,CAAC,oBAAoB,CAAC,CAAA;AAOpC,kCAAkC;AAClC,wBAAgB,gBAAgB,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,qBAAqB,GAAG,SAAS,CA+IxG"}

package/lib/types/client/index.d.ts

@@ -1,10 +1,11 @@
 /**
  * `dsh-autotier`, browser half: mounts the `tier` Remote contribution, then
  * registers the composer tier pill into `conversation.input.left` and the
- * autotier card into the Plugins settings section (`settings.plugins.tab`, id
- * `autotier`). All data arrives through the `remote.tier` namespace — the pill
- * binds the session id the slot factory hands it, the Settings card resolves the
- * session currently open in the shell through the sessions store face.
+ * autotier card on the Plugins page (`plugins.item`, id `autotier`; two views:
+ * a `summary` one-liner and the `page` form). All data arrives through the
+ * `remote.tier` namespace — the pill binds the session id the slot factory
+ * hands it, the card resolves the session currently open in the shell through
+ * the sessions store face.
  *
  * @module dsh-autotier/client
  */

package/lib/types/client/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/client/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAiBnE,YAAY,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AACrE,YAAY,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAA;AACzF,YAAY,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AACrD,OAAO,EACL,cAAc,EACd,WAAW,EACX,QAAQ,EACR,YAAY,EACZ,OAAO,EACP,QAAQ,EACR,UAAU,EACV,QAAQ,EACR,YAAY,EACZ,OAAO,GACR,MAAM,cAAc,CAAA;AACrB,YAAY,EAAE,gBAAgB,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAe5E,iDAAiD;AACjD,eAAO,MAAM,EAAE,sBAAsB,CAAA;AAErC,kFAAkF;AAClF,eAAO,MAAM,IAAI,iBAAiB,CAAA;AAElC,uGAAuG;AACvG,eAAO,MAAM,MAAM,UAAgC,CAAA;AAEnD;;;;;GAKG;AACH,wBAAsB,KAAK,CAAC,GAAG,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAqD7D"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/client/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAiBnE,YAAY,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AACrE,YAAY,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAA;AACzF,YAAY,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AACrD,OAAO,EACL,cAAc,EACd,WAAW,EACX,QAAQ,EACR,YAAY,EACZ,OAAO,EACP,QAAQ,EACR,UAAU,EACV,QAAQ,EACR,YAAY,EACZ,OAAO,GACR,MAAM,cAAc,CAAA;AACrB,YAAY,EAAE,gBAAgB,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAe5E,iDAAiD;AACjD,eAAO,MAAM,EAAE,sBAAsB,CAAA;AAErC,kFAAkF;AAClF,eAAO,MAAM,IAAI,iBAAiB,CAAA;AAElC,uGAAuG;AACvG,eAAO,MAAM,MAAM,UAAgC,CAAA;AAEnD;;;;;GAKG;AACH,wBAAsB,KAAK,CAAC,GAAG,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAqD7D"}

package/lib/types/client/remote.d.ts

@@ -45,15 +45,15 @@ export declare const AUTOTIER_REMOTE: Readonly<{
             source: "json";
             codec: Readonly<{
                 mode: "strict";
-                typeSymbol: "dsh-autotier/wire#TierAgentId";
-                schema: import("zod").ZodOptional<import("zod").ZodString>;
+                typeSymbol: string;
+                create: () => import("zod").ZodOptional<import("zod").ZodString>;
             }>;
             acceptsUndefined: true;
         }>[];
         readonly result: Readonly<{
             mode: "strict";
             typeSymbol: string;
-            schema: import("zod").ZodObject<{
+            create: () => import("zod").ZodObject<{
                 mode: import("zod").ZodEnum<{
                     strong: "strong";
                     cheap: "cheap";
@@ -158,10 +158,10 @@ export declare const AUTOTIER_REMOTE: Readonly<{
             kind: "direct";
         }>;
         readonly parameters: readonly never[];
-        readonly result: Readonly<{
+        readonly result: Readonly<Readonly<{
             mode: "strict";
-            typeSymbol: "dsh-autotier/wire#TierCatalog";
-            schema: import("zod").ZodArray<import("zod").ZodObject<{
+            typeSymbol: string;
+            create: () => import("zod").ZodArray<import("zod").ZodObject<{
                 provider: import("zod").ZodString;
                 models: import("zod").ZodArray<import("zod").ZodObject<{
                     id: import("zod").ZodString;
@@ -169,7 +169,7 @@ export declare const AUTOTIER_REMOTE: Readonly<{
                     inputModalities: import("zod").ZodArray<import("zod").ZodString>;
                 }, import("zod/v4/core").$strip>>;
             }, import("zod/v4/core").$strip>>;
-        }>;
+        }>>;
         readonly sourceLocation: Readonly<{
             file: "src/wire.ts";
             line: 1;
@@ -189,8 +189,8 @@ export declare const AUTOTIER_REMOTE: Readonly<{
             source: "json";
             codec: Readonly<{
                 mode: "strict";
-                typeSymbol: "dsh-autotier/wire#TierAgentId";
-                schema: import("zod").ZodOptional<import("zod").ZodString>;
+                typeSymbol: string;
+                create: () => import("zod").ZodOptional<import("zod").ZodString>;
             }>;
             acceptsUndefined: true;
         }> | Readonly<{
@@ -199,8 +199,8 @@ export declare const AUTOTIER_REMOTE: Readonly<{
             source: "json";
             codec: Readonly<{
                 mode: "strict";
-                typeSymbol: "dsh-autotier/types#RoutingMode";
-                schema: import("zod").ZodEnum<{
+                typeSymbol: string;
+                create: () => import("zod").ZodEnum<{
                     strong: "strong";
                     cheap: "cheap";
                     off: "off";
@@ -212,7 +212,7 @@ export declare const AUTOTIER_REMOTE: Readonly<{
         readonly result: Readonly<{
             mode: "strict";
             typeSymbol: string;
-            schema: import("zod").ZodObject<{
+            create: () => import("zod").ZodObject<{
                 mode: import("zod").ZodEnum<{
                     strong: "strong";
                     cheap: "cheap";