@askdkc/dsh-cli 0.11.3

package/lib/types/dsh-adapter/channel/mode-roster.js

@@ -0,0 +1,119 @@
+import { isCommandCompletionToken } from '../../commands.js';
+import { canonicalPresetFor, permissionCycleEntry, permissionModeSpec, stablePermissionRosterOrder, } from '../../sessionModes.js';
+import { permissionBundlesFromService, permissionPresetSnapshotFromService, } from './permissions.js';
+/** Durable identities the configured modes already own; a runtime preset with
+ *  one of them is the same switch by another route and never duplicated. */
+export function configuredPermissionIds(modes) {
+    return new Set(modes.flatMap(spec => spec.permission === undefined ? [] : [spec.permission]));
+}
+/** Canonical targets of the STATIC modes. On a stock table that is the three
+ *  built-in names; on renamed tables the deployment's own names for the same
+ *  bundles. They are never dynamic entries: the indicator would otherwise
+ *  snap to a dynamic look-alike instead of the static mode. */
+export function staticCanonicalTargets(modes, bundles) {
+    const targets = new Set();
+    for (const spec of modes) {
+        if (spec.permission !== undefined || spec.sandbox === undefined || spec.approval === undefined)
+            continue;
+        const canonical = canonicalPresetFor(spec.sandbox, spec.approval, bundles);
+        if (canonical !== undefined)
+            targets.add(canonical);
+    }
+    return targets;
+}
+/** The mounted `permissionPresets` registry as a runtime snapshot, or
+ *  undefined when no runtime table is mounted (legacy/unavailable tables are
+ *  not a roster). Reads are fail-closed: a throwing registry is no roster. */
+export function readRuntimePermissionSnapshot(ctx, target) {
+    let service;
+    try {
+        service = ctx.get('permissionPresets');
+    }
+    catch {
+        return undefined;
+    }
+    if (service === undefined)
+        return undefined;
+    const snapshot = permissionPresetSnapshotFromService(service, target.session);
+    return snapshot.availability === 'runtime' ? snapshot : undefined;
+}
+/** Warn at most once per (agent, identity, reason) — a registry that keeps
+ *  re-listing an unusable preset must not flood the log on every rebuild. */
+export function warnOnceForPermissionEntry(warned, warn, target, value, reason) {
+    const key = `${String(target.id)}:${value}:${reason}`;
+    if (warned.has(key))
+        return;
+    if (warned.size >= 200)
+        warned.clear();
+    warned.add(key);
+    warn(`dsh-tui: permission preset "${value}" skipped from Shift+Tab (${reason})`);
+}
+/**
+ * Dynamic session-mode roster (main's `sessionModes` / `rebuildSessionModes`).
+ *
+ * Runtime permission presets are appended AFTER the configured/default modes
+ * whenever the SERVICE snapshot is usable — no dependency on the external
+ * `/permission` command reaching this agent's registry, because switching
+ * falls back to the service's own write path when the command row is absent.
+ * Registry order is authoritative on first observation; later rebuilds
+ * preserve the relative order of identities already seen so unrelated
+ * command-registry churn cannot reshuffle Shift+Tab. Removed identities drop
+ * out and a later re-add is treated as new.
+ */
+export function createPermissionModeRoster(ctx, deps) {
+    const warn = deps.warn ?? ((message) => ctx.logger.warn(message));
+    const configuredIds = configuredPermissionIds(deps.configuredModes);
+    const warned = new Set();
+    const order = new WeakMap();
+    // Mutated in place: a consumer that captured this array keeps observing the
+    // live roster across rebuilds (see the interface contract).
+    const modes = [...deps.configuredModes];
+    const bundlesOf = () => {
+        let service;
+        try {
+            service = ctx.get('permissionPresets');
+        }
+        catch {
+            return [];
+        }
+        return service === undefined ? [] : permissionBundlesFromService(service);
+    };
+    const canonicalFor = (sandbox, approval) => canonicalPresetFor(sandbox, approval, bundlesOf());
+    const rebuild = (target) => {
+        const snapshot = readRuntimePermissionSnapshot(ctx, target);
+        const excluded = staticCanonicalTargets(deps.configuredModes, bundlesOf());
+        const candidates = new Map();
+        if (snapshot !== undefined) {
+            for (const option of snapshot.options) {
+                if (excluded.has(option.value)) {
+                    warnOnceForPermissionEntry(warned, warn, target, option.value, 'canonical target');
+                    continue;
+                }
+                if (!isCommandCompletionToken(option.value)) {
+                    warnOnceForPermissionEntry(warned, warn, target, option.value, 'unsafe command token');
+                    continue;
+                }
+                const decision = permissionCycleEntry(option, configuredIds);
+                if (!decision.accepted) {
+                    warnOnceForPermissionEntry(warned, warn, target, option.value, decision.reason);
+                    continue;
+                }
+                candidates.set(option.value, option);
+            }
+        }
+        const next = stablePermissionRosterOrder(order.get(target.session) ?? [], [...candidates.keys()]);
+        order.set(target.session, next);
+        const dynamic = [];
+        for (const value of next) {
+            const option = candidates.get(value);
+            if (option !== undefined)
+                dynamic.push(permissionModeSpec(option));
+        }
+        modes.length = 0;
+        for (const spec of [...deps.configuredModes, ...dynamic])
+            modes.push(spec);
+    };
+    // Main rebuilds once at construction, before the roster is first read.
+    rebuild(deps.agent());
+    return { modes, rebuild, readSnapshot: target => readRuntimePermissionSnapshot(ctx, target), canonicalFor };
+}

package/lib/types/dsh-adapter/channel/model-actions.d.ts

@@ -0,0 +1,49 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { type LlmModelInfo } from '@deepseek-ai/dsh-llm';
+import type { Agent, ModelSelectionRef } from '@deepseek-ai/dsh-agent';
+import type { CommandCompletionNode } from '../../commands.js';
+import type { createChannelBinding } from './binding.js';
+import type { ChannelOwner } from './owner.js';
+import type { ChannelState, EffortOption, PresetOption } from './types.js';
+type Binding = ReturnType<typeof createChannelBinding>;
+/**
+ * Route metadata, effort preference and preset/model catalog actions.
+ * This owns the async catalog caches and their generation fences; callers only
+ * compose its surface into ChannelState after the state has been constructed.
+ */
+export declare function createModelActions(ctx: Context, state: Pick<ChannelState, 'provider' | 'model' | 'reasoningEffort' | 'effortLevels' | 'agentPreset' | 'working' | 'contextWindow' | 'emit'>, deps: {
+    owner: Pick<ChannelOwner, 'current'>;
+    binding: Pick<Binding, 'capture' | 'isCurrent'>;
+    selection: ModelSelectionRef;
+    initialEffort?: string;
+    agent(): Agent;
+    notify: ChannelState['notify'];
+    /** Re-check the context-low warning after a refreshed route metadata
+     * answer carries a newer contextWindow than the session started with. */
+    checkContextWarning(): void;
+}): {
+    selection: ModelSelectionRef;
+    applyPreferredEffort: () => Promise<void>;
+    refreshEffortLevels: () => void;
+    listEfforts: () => Promise<{
+        efforts: readonly EffortOption[];
+        defaultEffort: string | undefined;
+    }>;
+    setEffort: (id: string) => Promise<boolean>;
+    setDefaultEffort: (id: string | undefined) => void;
+    warmEffortLevels: () => void;
+    listModels: () => Promise<readonly LlmModelInfo[]>;
+    listProviders: () => Promise<{
+        id: string;
+        name: string;
+    }[]>;
+    dropModelNodeCache: () => void;
+    warmModelNodes: () => void;
+    modelNodes: () => readonly CommandCompletionNode[];
+    warmPresetOptions: () => void;
+    presetOptions: () => readonly PresetOption[];
+    listPresets: () => Promise<readonly PresetOption[]>;
+    switchPreset: (presetId: string) => Promise<boolean>;
+};
+export {};
+//# sourceMappingURL=model-actions.d.ts.map

package/lib/types/dsh-adapter/channel/model-actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-actions.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/model-actions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,EAAqB,KAAK,YAAY,EAAE,MAAM,sBAAsB,CAAA;AAC3E,OAAO,KAAK,EAAE,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAA;AACtE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAA;AAM9D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAA;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAE1E,KAAK,OAAO,GAAG,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEtD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,OAAO,EACZ,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,UAAU,GAAG,OAAO,GAAG,iBAAiB,GAAG,cAAc,GAAG,aAAa,GAAG,SAAS,GAAG,eAAe,GAAG,MAAM,CAAC,EAC3I,IAAI,EAAE;IACJ,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,SAAS,CAAC,CAAA;IACpC,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,SAAS,GAAG,WAAW,CAAC,CAAA;IAC/C,SAAS,EAAE,iBAAiB,CAAA;IAC5B,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,KAAK,IAAI,KAAK,CAAA;IACd,MAAM,EAAE,YAAY,CAAC,QAAQ,CAAC,CAAA;IAC9B;6EACyE;IACzE,mBAAmB,IAAI,IAAI,CAAA;CAC5B;;gCA8DsC,OAAO,CAAC,IAAI,CAAC;+BA+DpB,IAAI;uBAqBN,OAAO,CAAC;QAAE,OAAO,EAAE,SAAS,YAAY,EAAE,CAAC;QAAC,aAAa,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,CAAC;oBAWjF,MAAM,KAAG,OAAO,CAAC,OAAO,CAAC;2BAoBxB,MAAM,GAAG,SAAS,KAAG,IAAI;4BAM1B,IAAI;sBAeV,OAAO,CAAC,SAAS,YAAY,EAAE,CAAC;;YAhMnB,MAAM;cAAQ,MAAM;;8BAqMzB,IAAI;0BACR,IAAI;;6BASD,IAAI;;uBAOJ,OAAO,CAAC,SAAS,YAAY,EAAE,CAAC;6BAQxB,MAAM,KAAG,OAAO,CAAC,OAAO,CAAC;EAkChE"}

package/lib/types/dsh-adapter/channel/model-actions.js

@@ -0,0 +1,351 @@
+import { ReasoningEffortId } from '@deepseek-ai/dsh-llm';
+import { nearestLowerEffort, readEffortPref, resolveEffortDefault, writeEffortPref } from '../../effortPrefs.js';
+import { snapshotLiveSessionEvents } from '../compat/liveSession.js';
+import { getLang, t, tOr } from '../../i18n.js';
+import { migratePresetPref, writePresetPref } from '../../presetPrefs.js';
+import { presetDisplayId, resolveCompatiblePreset, rosterOf } from '../preset-resolution.js';
+/**
+ * Route metadata, effort preference and preset/model catalog actions.
+ * This owns the async catalog caches and their generation fences; callers only
+ * compose its surface into ChannelState after the state has been constructed.
+ */
+export function createModelActions(ctx, state, deps) {
+    const { owner, selection, notify } = deps;
+    const llmRuntime = ctx.get('llm');
+    let preferredEffort = deps.initialEffort ?? readEffortPref();
+    // Last fallback notice shown for a (preferred → applied) pair: bind fires on
+    // every session switch, so an unchanged downgrade must not re-toast.
+    let lastEffortFallbackNotice;
+    // State construction cannot call this factory yet; seed the visible value
+    // before the root starts binding or exposes the completed ChannelState.
+    state.reasoningEffort = preferredEffort;
+    let effortLevelsGeneration = 0;
+    let effortOperation = 0;
+    let presetOperation = 0;
+    const effortWarm = { tried: false };
+    const modelNodeCache = { nodes: undefined, load: undefined, generation: 0 };
+    const presetOptionCache = { lang: undefined, list: undefined, load: undefined };
+    const captureEffort = () => ({
+        binding: deps.binding.capture(), provider: state.provider, model: state.model, operation: ++effortOperation,
+    });
+    const effortCurrent = (capture) => owner.current() && deps.binding.isCurrent(capture.binding) &&
+        state.provider === capture.provider && state.model === capture.model && effortOperation === capture.operation;
+    /** Route-level metadata shared by every resolveModelInfo consumer. The
+     * context window follows the route, not the binding: a resume rebuilds
+     * the binding (effortCurrent goes false) while the capacity answer for
+     * the same provider/model is still the live truth, so this runs before
+     * any effort freshness gate. Lifetime is the one fence it keeps: the
+     * answer crosses an await, so a Channel released while the lookup was in
+     * flight must neither write into its dead state nor re-arm the
+     * context-low warning through checkContextWarning. */
+    const applyRouteMetadata = (capture, info) => {
+        if (!owner.current())
+            return;
+        if (state.provider === capture.provider && state.model === capture.model && info.context !== undefined) {
+            state.contextWindow = info.context.contextWindow;
+            deps.checkContextWarning();
+        }
+    };
+    const resolveEfforts = async (capture) => {
+        if (llmRuntime === undefined || typeof llmRuntime.resolveModelInfo !== 'function')
+            return 'unavailable';
+        try {
+            const info = await llmRuntime.resolveModelInfo(capture.provider, capture.model);
+            applyRouteMetadata(capture, info);
+            if (!effortCurrent(capture))
+                return 'stale';
+            const efforts = info.reasoning?.efforts ?? [];
+            state.effortLevels = efforts.map(level => level.id);
+            return { efforts, defaultEffort: info.reasoning?.defaultEffort };
+        }
+        catch (error) {
+            if (!effortCurrent(capture))
+                return 'stale';
+            notify(t('effort-read-failed', { error: error instanceof Error ? error.message : String(error) }), { color: 'error', timeoutMs: 8000 });
+            return 'error';
+        }
+    };
+    const applyPreferredEffort = async () => {
+        if (llmRuntime === undefined || typeof llmRuntime.resolveModelInfo !== 'function')
+            return;
+        const capture = captureEffort();
+        const resolved = await resolveEfforts(capture);
+        if (resolved === 'unavailable' || resolved === 'error' || resolved === 'stale' || !effortCurrent(capture))
+            return;
+        // This same binding-time lookup is the route's initial tier refresh even
+        // without a stored preference. Do not make a separate competing refresh
+        // operation that could invalidate the selected preference completion.
+        if (preferredEffort === undefined)
+            return;
+        const available = resolved.efforts.map(effort => effort.id);
+        // Exact hit applies silently; a miss falls back to the nearest LOWER tier
+        // the route offers (never up), and both miss paths notify exactly once
+        // per (preferred → applied) pair — bind fires on every session switch,
+        // so an unchanged downgrade must not re-toast.
+        const applied = nearestLowerEffort(preferredEffort, available);
+        if (applied === undefined) {
+            if (lastEffortFallbackNotice?.preferred !== preferredEffort || lastEffortFallbackNotice.applied !== undefined) {
+                lastEffortFallbackNotice = { preferred: preferredEffort, applied: undefined };
+                notify(t('effort-preference-unsupported', { preferred: preferredEffort }), { color: 'warning' });
+            }
+            // Nothing is pinned, so the ROUTE's model default is what actually ships
+            // and the readout (status line, /effort status) must say so. Every switch
+            // tail clears it before this runs (session-resume.ts / model-switch.ts /
+            // session-live-adoption.ts / background-action.ts), but a resumed log's
+            // replayed `request/header` can leave an older tier behind — neither blank
+            // nor "last route's tier" is the truth. Only the readout moves: pinning
+            // the default into selection.current would put a tier the user never chose
+            // onto the wire, which is exactly what "never up" forbids.
+            const shipped = resolved.defaultEffort;
+            if (state.reasoningEffort !== shipped) {
+                state.reasoningEffort = shipped;
+                state.emit();
+            }
+            // An effort pin installed earlier (an exact hit, /effort <id>) survives
+            // every path that is NOT a bind: /settings' effortDefault hands the level
+            // straight to setDefaultEffort → applyPreferredEffort (plugin.ts:804 →
+            // setDefaultEffort above), which never resets selection.current — the four
+            // switch tails that do are all on the bind side. Leaving it would put the
+            // OLD tier back on the wire while the readout above announces the model
+            // default. Drop the effort only: the provider/model half of the pin is
+            // this route's, not the stale tier's. No emit — setDefaultEffort reaches
+            // here through that same non-bind path, and nothing UI-visible reads this
+            // ref (it is the router's ModelSelectionRef, not the IDE ChannelSelection
+            // the status line shows); the readout above already emits when it moves.
+            if (selection.current?.reasoningEffort !== undefined) {
+                selection.current = { provider: capture.provider, model: capture.model };
+            }
+            return;
+        }
+        // Dedupe gates ONLY the toast: bind resets selection.current on every
+        // session switch, so the pin below must re-apply unconditionally — an
+        // early return here would ship the model default from the second session
+        // on (review C1). The status line shows the tier that actually ships.
+        const fresh = lastEffortFallbackNotice?.preferred !== preferredEffort || lastEffortFallbackNotice.applied !== applied;
+        if (applied !== preferredEffort && fresh) {
+            lastEffortFallbackNotice = { preferred: preferredEffort, applied };
+            notify(t('effort-preference-downgraded', { preferred: preferredEffort, applied }), { color: 'warning' });
+        }
+        if (applied === preferredEffort)
+            lastEffortFallbackNotice = undefined;
+        state.reasoningEffort = applied;
+        selection.current = { provider: capture.provider, model: capture.model, reasoningEffort: ReasoningEffortId(applied) };
+        state.emit();
+    };
+    const refreshEffortLevels = () => {
+        if (llmRuntime === undefined || typeof llmRuntime.resolveModelInfo !== 'function')
+            return;
+        const capture = captureEffort();
+        const generation = ++effortLevelsGeneration;
+        void llmRuntime.resolveModelInfo(capture.provider, capture.model).then(info => {
+            if (generation !== effortLevelsGeneration)
+                return;
+            applyRouteMetadata(capture, info);
+            if (!effortCurrent(capture))
+                return;
+            state.effortLevels = (info.reasoning?.efforts ?? []).map(level => level.id);
+            state.emit();
+        }).catch(() => undefined);
+    };
+    const applyEffort = (effort, capture) => {
+        if (!effortCurrent(capture))
+            return;
+        selection.current = { provider: capture.provider, model: capture.model, reasoningEffort: ReasoningEffortId(effort.id) };
+        preferredEffort = effort.id;
+        state.reasoningEffort = effort.id;
+        writeEffortPref(effort.id);
+        notify(t('effort-switched', { name: effort.name }));
+        state.emit();
+    };
+    const listEfforts = async () => {
+        const capture = captureEffort();
+        const resolved = await resolveEfforts(capture);
+        if (resolved === 'stale')
+            return { efforts: [], defaultEffort: undefined };
+        if (resolved === 'unavailable') {
+            notify(t('effort-unavailable'), { color: 'error' });
+            return { efforts: [], defaultEffort: undefined };
+        }
+        if (resolved === 'error')
+            return { efforts: [], defaultEffort: undefined };
+        if (!effortCurrent(capture))
+            return { efforts: [], defaultEffort: undefined };
+        if (resolved.efforts.length === 0)
+            notify(t('effort-unsupported'), { color: 'warning' });
+        else if (resolved.efforts.length === 1)
+            notify(t('effort-single-tier', { name: resolved.efforts[0].name }), { color: 'warning' });
+        return resolved;
+    };
+    const setEffort = async (id) => {
+        const capture = captureEffort();
+        const resolved = await resolveEfforts(capture);
+        if (resolved === 'stale')
+            return false;
+        if (resolved === 'unavailable') {
+            notify(t('effort-unavailable'), { color: 'error' });
+            return false;
+        }
+        if (resolved === 'error')
+            return false;
+        if (!effortCurrent(capture))
+            return false;
+        if (resolved.efforts.length === 0) {
+            notify(t('effort-unsupported'), { color: 'warning' });
+            return false;
+        }
+        const found = resolved.efforts.find(effort => effort.id === id);
+        if (found === undefined) {
+            notify(t('effort-invalid', { id, ids: resolved.efforts.map(effort => effort.id).join(', ') }), { color: 'warning' });
+            return false;
+        }
+        applyEffort(found, capture);
+        return effortCurrent(capture);
+    };
+    /**
+     * Re-seat the future-sessions default reasoning effort. `id` is the settings
+     * user layer (the settings user layer outranks the cordis.yml `effort` pin);
+     * an absent level re-derives the boot chain (cordis `effort` → the persisted
+     * /effort choice). Also re-pins the live agent when its route offers the
+     * level, so the change lands on the next request. No-op when unchanged.
+     */
+    const setDefaultEffort = (id) => {
+        const resolved = resolveEffortDefault(id, deps.initialEffort, readEffortPref());
+        if (resolved === preferredEffort)
+            return;
+        preferredEffort = resolved;
+        void applyPreferredEffort();
+    };
+    const warmEffortLevels = () => {
+        if (state.effortLevels !== undefined || effortWarm.tried)
+            return;
+        effortWarm.tried = true;
+        const capture = captureEffort();
+        void resolveEfforts(capture).then(result => {
+            if (result !== 'unavailable' && result !== 'error' && result !== 'stale' && effortCurrent(capture)) {
+                effortWarm.tried = false;
+                state.emit();
+            }
+            else if (effortOperation === capture.operation) {
+                // A stale route/binding has its own next bind warm; a transient
+                // unavailable/error may be retried on a later explicit completion.
+                effortWarm.tried = false;
+            }
+        }).catch(() => undefined);
+    };
+    const listModels = () => {
+        if (llmRuntime === undefined)
+            return Promise.resolve([]);
+        return Promise.all(llmRuntime.listProviders().map(provider => llmRuntime.listModels(provider.id).catch(() => []))).then(lists => lists.flat());
+    };
+    const listProviders = () => Promise.resolve(llmRuntime === undefined ? [] : llmRuntime.listProviders().map(info => ({ ...info })));
+    const dropModelNodeCache = () => { modelNodeCache.generation += 1; modelNodeCache.nodes = undefined; modelNodeCache.load = undefined; };
+    const warmModelNodes = () => {
+        if (modelNodeCache.load !== undefined)
+            return;
+        const generation = modelNodeCache.generation;
+        modelNodeCache.load = listModels().then(list => {
+            if (!owner.current() || generation !== modelNodeCache.generation)
+                return;
+            modelNodeCache.nodes = list.map(model => ({ name: `${model.provider}/${model.id}`, description: model.name, ...(state.provider === model.provider && state.model === model.id ? { tag: 'current' } : {}) }));
+            state.emit();
+        }).catch(() => { if (owner.current() && generation === modelNodeCache.generation)
+            modelNodeCache.nodes = []; });
+    };
+    const warmPresetOptions = () => {
+        const lang = getLang();
+        if (presetOptionCache.lang !== undefined && presetOptionCache.lang !== lang) {
+            presetOptionCache.list = undefined;
+            presetOptionCache.load = undefined;
+        }
+        if (presetOptionCache.load !== undefined)
+            return;
+        presetOptionCache.lang = lang;
+        presetOptionCache.load = listPresets().then(list => { presetOptionCache.list = list; state.emit(); }).catch(() => { presetOptionCache.list = []; });
+    };
+    const listPresets = async () => {
+        const presets = rosterOf(ctx);
+        if (presets === undefined)
+            return [];
+        const localized = getLang() === 'en';
+        try {
+            return (await presets.list()).map(preset => ({ id: preset.id, ...(preset.name === undefined ? {} : { name: localized ? tOr(`preset-name-${presetDisplayId(preset.id)}`, preset.name) : preset.name }), ...(preset.description === undefined ? {} : { description: localized ? tOr(`preset-desc-${presetDisplayId(preset.id)}`, preset.description) : preset.description }), ...(preset.broken === undefined ? {} : { broken: preset.broken }), isDefault: preset.id === presets.defaultId }));
+        }
+        catch {
+            return [];
+        }
+    };
+    const switchPreset = async (presetId) => {
+        const presets = rosterOf(ctx);
+        if (presets === undefined) {
+            notify(t('preset-unavailable'), { color: 'error' });
+            return false;
+        }
+        if (state.working) {
+            notify(t('preset-agent-running'), { color: 'warning' });
+            return false;
+        }
+        const capture = deps.binding.capture();
+        const targetAgent = deps.agent();
+        const targetSession = targetAgent.session;
+        const operation = ++presetOperation;
+        const current = () => owner.current() && deps.binding.isCurrent(capture) && deps.agent() === targetAgent && targetAgent.session === targetSession && operation === presetOperation;
+        let target;
+        try {
+            target = await resolveCompatiblePreset(presets, presetId);
+        }
+        catch (error) {
+            if (current())
+                notify(t('preset-not-found', { id: presetId, err: error instanceof Error ? error.message : String(error) }), { color: 'error', timeoutMs: 8000 });
+            return false;
+        }
+        if (!current())
+            return false;
+        if (target.broken !== undefined) {
+            notify(t('preset-load-failed', { id: target.id, broken: target.broken }), { color: 'error', timeoutMs: 8000 });
+            return false;
+        }
+        if (target.id === state.agentPreset) {
+            if (!migratePresetPref(presetId, target.id)) {
+                notify(t('preset-switched-pref-failed', { id: target.id }), { color: 'warning' });
+                return true;
+            }
+            notify(t('preset-already-current', { id: target.id }), { color: 'success' });
+            return true;
+        }
+        if (snapshotLiveSessionEvents(targetSession).some(event => event.type === 'turn/start')) {
+            if (!current())
+                return false;
+            if (!writePresetPref(target.id)) {
+                notify(t('preset-pref-write-failed'), { color: 'error' });
+                return false;
+            }
+            notify(t('preset-locked-saved-default', { current: state.agentPreset ?? 'host', id: target.id }), { color: 'warning', timeoutMs: 8000 });
+            return true;
+        }
+        let preset;
+        try {
+            preset = await presets.recompose(targetAgent.ctx, target.id);
+        }
+        catch (error) {
+            if (current())
+                notify(t('preset-switch-failed', { err: error instanceof Error ? error.message : String(error) }), { color: 'error', timeoutMs: 8000 });
+            return false;
+        }
+        if (!current())
+            return false;
+        targetSession.append('agent-preset/selected', { agentPreset: preset.id });
+        if (!current())
+            return false;
+        state.agentPreset = preset.id;
+        state.emit();
+        if (!current())
+            return false;
+        if (!writePresetPref(target.id)) {
+            notify(t('preset-switched-pref-failed', { id: target.id }), { color: 'warning' });
+            return true;
+        }
+        notify(t('preset-switched-saved', { id: target.id }), { color: 'success' });
+        return true;
+    };
+    return { selection, applyPreferredEffort, refreshEffortLevels, listEfforts, setEffort, setDefaultEffort, warmEffortLevels, listModels, listProviders, dropModelNodeCache, warmModelNodes, modelNodes: () => modelNodeCache.nodes ?? [], warmPresetOptions, presetOptions: () => presetOptionCache.list ?? [], listPresets, switchPreset };
+}

package/lib/types/dsh-adapter/channel/model-switch.d.ts

@@ -0,0 +1,31 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { type SessionEvent } from '@deepseek-ai/dsh-session';
+import type { createChannelBinding } from './binding.js';
+import type { ChannelOwner } from './owner.js';
+import { resetSessionProjection } from './session-reset.js';
+import type { ChannelState } from './types.js';
+type Binding = ReturnType<typeof createChannelBinding>;
+type SwitchState = Parameters<typeof resetSessionProjection>[0] & Pick<ChannelState, 'cwd' | 'working' | 'status' | 'agentId' | 'sessionId' | 'agentPreset' | 'provider' | 'model' | 'contextWindow' | 'effortLevels' | 'reasoningEffort' | 'emit'>;
+/** Model-route adoption transaction. It settles compaction before its fork snapshot and owns the post-commit reset. */
+export declare function createModelSwitchAction(ctx: Context, state: SwitchState, deps: {
+    owner: Pick<ChannelOwner, 'current'>;
+    binding: Pick<Binding, 'agent' | 'capture' | 'prepare' | 'isCurrent' | 'abandon' | 'adopt'>;
+    rowIds: {
+        value: number;
+    };
+    settleCompaction(): Promise<void>;
+    resetProjector(): void;
+    resetSubagents(): void;
+    resetJobs(): void;
+    replay(events: readonly SessionEvent[]): void;
+    settleReplay(): void;
+    bindAgent(): void;
+    refreshCommands(): void;
+    refreshLoadedContext(): Promise<void>;
+    refreshSkillCommands(): Promise<void>;
+    clearStagedImages(): void;
+    dropModelCompletion(): void;
+    notify: ChannelState['notify'];
+}): (provider: string, model: string) => Promise<boolean>;
+export {};
+//# sourceMappingURL=model-switch.d.ts.map

package/lib/types/dsh-adapter/channel/model-switch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-switch.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/model-switch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAGlD,OAAO,EAAa,KAAK,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAQvE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAA;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAC9C,OAAO,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAA;AAC3D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAE9C,KAAK,OAAO,GAAG,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAA;AACtD,KAAK,WAAW,GAAG,UAAU,CAAC,OAAO,sBAAsB,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,YAAY,EACjF,KAAK,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,GAAG,WAAW,GAAG,aAAa,GAAG,UAAU,GAAG,OAAO,GAAG,eAAe,GAAG,cAAc,GAAG,iBAAiB,GAAG,MAAM,CAAC,CAAA;AAEhK,uHAAuH;AACvH,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,OAAO,EACZ,KAAK,EAAE,WAAW,EAClB,IAAI,EAAE;IACJ,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,SAAS,CAAC,CAAA;IACpC,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,GAAG,SAAS,GAAG,WAAW,GAAG,SAAS,GAAG,OAAO,CAAC,CAAA;IAC3F,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;IACzB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACjC,cAAc,IAAI,IAAI,CAAA;IACtB,cAAc,IAAI,IAAI,CAAA;IACtB,SAAS,IAAI,IAAI,CAAA;IACjB,MAAM,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,GAAG,IAAI,CAAA;IAC7C,YAAY,IAAI,IAAI,CAAA;IACpB,SAAS,IAAI,IAAI,CAAA;IACjB,eAAe,IAAI,IAAI,CAAA;IACvB,oBAAoB,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACrC,oBAAoB,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACrC,iBAAiB,IAAI,IAAI,CAAA;IACzB,mBAAmB,IAAI,IAAI,CAAA;IAC3B,MAAM,EAAE,YAAY,CAAC,QAAQ,CAAC,CAAA;CAC/B,IAEa,UAAU,MAAM,EAAE,OAAO,MAAM,KAAG,OAAO,CAAC,OAAO,CAAC,CA4EjE"}