@deepseek-harness-tui/dsh-tui 0.14.1 → 0.16.0

package/lib/types/dsh-adapter/channel/mode-permission-actions.js

@@ -1,9 +1,12 @@
 import { assertShadowPolicy } from '../../adapter/kernel/runtime.js';
 import { t } from '../../i18n.js';
+import { readPermissionPref, writePermissionPref } from '../../permissionPrefs.js';
+import { PERMISSION_PRESET_AUTO } from '../../permissionPresetLabels.js';
 import { modeDisplayName } from '../../sessionModes.js';
 import { snapshotLiveSessionEvents } from '../compat/liveSession.js';
 import { createModeActions, reportModeSwitchFailure } from './mode-actions.js';
 import { createPermissionIdentity, foldPermissionPreset } from './mode-permission.js';
+import { PERMISSION_PRESET_CUSTOM } from './permissions.js';
 // Atom folds mirrored from mode-actions.ts: `createModeActions` does not
 // export them, and the permission-aware derive below must reproduce its
 // atom fallback exactly to stay the single source of the indicator.
@@ -61,6 +64,30 @@ function derivePermissionModeIndex(modes, events) {
         && (spec.approval === undefined || foldApprovalPolicy(events) === spec.approval));
     return index >= 0 ? index : 0;
 }
+/** The durable identity held before the latest `permission/preset` event.
+ *  Non-string presets are skipped exactly as {@link foldPermissionPreset}
+ *  skips them, so both folds agree on what the session sat on. */
+function previousPermissionPreset(events) {
+    let previous;
+    let latest;
+    for (const event of events) {
+        if (event.type !== 'permission/preset')
+            continue;
+        const preset = event.data.preset;
+        if (typeof preset !== 'string')
+            continue;
+        previous = latest;
+        latest = preset;
+    }
+    return previous;
+}
+/** Whether this session's log ever selected the experimental `auto` preset
+ *  (picker confirmation, typed command, or a resumed Auto session). Only then
+ *  may Shift+Tab land on it: a key press cannot await the risk confirmation. */
+export function autoPresetConfirmed(events) {
+    return events.some(event => event.type === 'permission/preset'
+        && event.data.preset === PERMISSION_PRESET_AUTO);
+}
 /**
  * Permission-aware session-mode actions: main's mode transition (plan
  * exclusivity, atom application, plan-exit restore) composed with the durable
@@ -90,6 +117,58 @@ export function createPermissionModeActions(ctx, state, deps) {
     });
     // An in-turn /plan off commits at pre-step, after the command has returned.
     const explicitPlanExits = new WeakSet();
+    /** True while this composition is walking a session INTO plan mode — from
+     *  the pre-plan identity capture until the plan atoms have been applied.
+     *  The canonical preset the plan entry switches to is a transient working
+     *  state (restored on exit), so the preference must not learn it. */
+    let planEntryInFlight = false;
+    /** Sessions the remembered permission was already seeded into (or decided
+     *  against): one attempt per session object, rebinds stay quiet. */
+    const permissionPrefSeeded = new WeakSet();
+    /** Target presets of the permission switches this TUI is driving right now
+     *  (the `/permission` command or the service write path). A switch AWAY
+     *  from `auto` is learned only when it lands on one of them: the
+     *  auto-review plugin migrates every Auto session to danger-full-access
+     *  when it unloads, and that migration — even one racing a pending switch
+     *  to another target — must not become the next session's default. */
+    const userPermissionTargets = [];
+    /** Per session, the identity a switch away from `auto` landed on without
+     *  being learned (the plugin-unload migration). It stays unlearnable on
+     *  the implicit paths — a plan entry's pre-plan seat and the plan exit's
+     *  restore — until an explicit switch is learned on that session. */
+    const unlearnedIdentity = new WeakMap();
+    /** `input` is the raw `/permission` argument; its first token names the
+     *  target preset, resolved case-insensitively against the mounted roster
+     *  so it compares equal to the value the log records. */
+    const trackUserPermissionSwitch = async (input, run) => {
+        const typed = input.trim().split(/\s+/)[0] ?? '';
+        let options = [];
+        try {
+            options = roster.readSnapshot(binding.agent)?.options ?? [];
+        }
+        catch {
+            options = [];
+        }
+        const target = options.find(option => option.value.toLowerCase() === typed.toLowerCase())?.value ?? typed;
+        userPermissionTargets.push(target);
+        try {
+            return await run();
+        }
+        finally {
+            userPermissionTargets.splice(userPermissionTargets.indexOf(target), 1);
+        }
+    };
+    /** Remember one durable permission identity for the next session (see
+     *  permissionPrefs.ts). Undefined and custom identities carry no preset
+     *  to remember, and `auto` is session-only by contract; a failed write is a
+     *  debug line, never user-facing. */
+    const persistPermissionPref = (value) => {
+        if (value === undefined || value === PERMISSION_PRESET_CUSTOM || value === PERMISSION_PRESET_AUTO)
+            return;
+        if (!writePermissionPref(value)) {
+            ctx.logger.debug(`dsh-tui: permission preference write failed for "${value}"`);
+        }
+    };
     /** Re-derive the roster and the current mode. The roster rebuild rides on
      *  every refresh: a registry mount/unmount and a re-bind both land here. */
     const refreshMode = () => {
@@ -131,6 +210,14 @@ export function createPermissionModeActions(ctx, state, deps) {
         // canonicalization can append replacement events.
         if (planChange && spec.plan === true && !planActive) {
             permission.rememberPrePlanIdentity(session);
+            // The canonicalization below reseats the durable identity on the
+            // plan atoms (read-only/ask) until the exit restores it. Keep the
+            // preference on the identity the user actually sat on, and let the
+            // event observer below ignore the replacement while it is in flight.
+            const seat = foldPermissionPreset(snapshotLiveSessionEvents(session));
+            if (seat !== unlearnedIdentity.get(session))
+                persistPermissionPref(seat);
+            planEntryInFlight = true;
         }
         if (planChange && spec.plan === false) {
             // An explicit switch away from plan owns its target mode; the
@@ -138,16 +225,29 @@ export function createPermissionModeActions(ctx, state, deps) {
             explicitPlanExits.add(session);
             permission.forgetPrePlanIdentity(session);
         }
-        if (spec.permission !== undefined) {
-            if (!(await permission.applyPermissionIdentity(spec.permission)))
+        try {
+            if (spec.permission !== undefined) {
+                if (!(await permission.applyPermissionIdentity(spec.permission)))
+                    return;
+                unlearnedIdentity.delete(session);
+                persistPermissionPref(spec.permission);
+            }
+            else if (!(await permission.canonicalizeForMode(spec, session))) {
+                return;
+            }
+            else if (spec.plan !== true) {
+                // A static mode the user cycled to owns its canonical preset
+                // identity (the plan spec's canonical form is transient instead).
+                unlearnedIdentity.delete(session);
+                persistPermissionPref(permission.canonicalPermissionForMode(spec, session));
+            }
+            if (!owner.current() || !binding.isCurrent(capture) || session !== agent.session)
                 return;
+            await base.applyMode(spec, capture);
         }
-        else if (!(await permission.canonicalizeForMode(spec, session))) {
-            return;
+        finally {
+            planEntryInFlight = false;
         }
-        if (!owner.current() || !binding.isCurrent(capture) || session !== agent.session)
-            return;
-        await base.applyMode(spec, capture);
         if (!owner.current() || !binding.isCurrent(capture))
             return;
         const before = state.modeIndex;
@@ -156,15 +256,26 @@ export function createPermissionModeActions(ctx, state, deps) {
             state.emit();
     };
     /** Shift+Tab: advance from the mode DERIVED from the session log (never a
-     *  stored index), so manual `/plan` use can never desync the cycle. Never
-     *  rejects — same fail-soft contract as {@link applyMode}. */
+     *  stored index), so manual `/plan` use can never desync the cycle; `auto`
+     *  is skipped unless {@link autoPresetConfirmed}. Never rejects — same
+     *  fail-soft contract as {@link applyMode}. */
     const cycleMode = async () => {
         try {
             const capture = binding.capture();
             if (!owner.current() || !binding.isCurrent(capture))
                 return;
-            const index = derivePermissionModeIndex(sessionModes, snapshotLiveSessionEvents(capture.agent.session));
-            await applyMode(sessionModes[(index + 1) % sessionModes.length], capture);
+            const events = snapshotLiveSessionEvents(capture.agent.session);
+            const index = derivePermissionModeIndex(sessionModes, events);
+            const autoConfirmed = autoPresetConfirmed(events);
+            // One full revolution, ending on the starting entry: a single-mode
+            // cycle re-applies it (the session's atoms may have drifted from it).
+            for (let step = 1; step <= sessionModes.length; step++) {
+                const next = sessionModes[(index + step) % sessionModes.length];
+                if (next.permission === PERMISSION_PRESET_AUTO && !autoConfirmed)
+                    continue;
+                await applyMode(next, capture);
+                return;
+            }
         }
         catch (error) {
             reportModeSwitchFailure(ctx, notify, refreshMode, error);
@@ -175,8 +286,34 @@ export function createPermissionModeActions(ctx, state, deps) {
         const sessionEvent = event;
         base.onSessionEvent(subject, sessionEvent);
         const type = sessionEvent.type;
-        if (type === 'permission/preset')
+        if (type === 'permission/preset') {
             refreshMode();
+            // Every durable identity change on the bound session teaches the
+            // preference — including switches the official /permission command
+            // performed on its own (typed input, other UIs over the same
+            // registry) — except the two plan-transition shapes: the canonical
+            // preset a plan entry reseats to (in flight below) and any identity
+            // switched to while plan is active (the exit restore re-seats the
+            // pre-plan one, and that restore event lands here again). Leaving
+            // `auto` is learned only when it lands on a target this TUI is driving
+            // (see trackUserPermissionSwitch), and an unlearned landing stays
+            // unlearned when a plan exit re-seats it; explicit mode switches
+            // persist on their own.
+            const events = snapshotLiveSessionEvents(subject);
+            const current = foldPermissionPreset(events);
+            const userDriven = current !== undefined && userPermissionTargets.includes(current);
+            if (planEntryInFlight || foldPlanActive(events)) {
+                // Plan transition shapes: never learned.
+            }
+            else if (previousPermissionPreset(events) === PERMISSION_PRESET_AUTO && !userDriven) {
+                if (current !== undefined)
+                    unlearnedIdentity.set(subject, current);
+            }
+            else if (userDriven || current !== unlearnedIdentity.get(subject)) {
+                unlearnedIdentity.delete(subject);
+                persistPermissionPref(current);
+            }
+        }
         if (type !== 'plan/mode' || sessionEvent.data.active !== false)
             return;
         const remembered = permission.prePlanPermissionIdentity(subject);
@@ -203,12 +340,97 @@ export function createPermissionModeActions(ctx, state, deps) {
             });
         });
     };
+    /** The composition's default preset: the identity `dsh-permission-presets`
+     *  pins into EVERY fresh session before it is published (`session/created` →
+     *  `pinInitialPermission`), read fail-closed from the mounted service —
+     *  undefined when it is absent or answers nothing usable. */
+    const compositionDefaultPreset = () => {
+        try {
+            const service = ctx.get('permissionPresets');
+            const value = service?.defaultPreset;
+            return typeof value === 'string' && value !== '' ? value : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    /** Seed a session that never customized its permission planes with the
+     *  persisted preference (permissionPrefs.ts): the last preset the user
+     *  switched to, applied through the same official /permission path every
+     *  manual switch takes. Never rejects.
+     *
+     *  Holding permission-plane events is NOT evidence of a user choice: the
+     *  composition pins `permission/preset` + `sandbox/mode` + `approval/policy`
+     *  into every fresh session at creation. So a session only owns its planes
+     *  when the log shows more than that pin — it ran a turn, or its durable
+     *  identity is one the composition did not pin (`custom`, a preset a user
+     *  switched to, a resumed log's own state). Everything else is untouched
+     *  and seeds, which is what "starts where the last session ended" means.
+     *
+     *  Yields to a DSH_PERMISSION_MODE launch pin (the composition's
+     *  sandbox-policy/approval defaults came from it, so that invocation
+     *  explicitly asked for that start state) and to shadow runtimes, which
+     *  must not write durable session policy. */
+    const applyRememberedPermission = async () => {
+        try {
+            if (deps.runtime.mode === 'passive-shadow' || deps.runtime.mode === 'replay-shadow')
+                return;
+            const pinned = process.env.DSH_PERMISSION_MODE;
+            if (pinned !== undefined && pinned !== '')
+                return;
+            const pref = readPermissionPref();
+            // `auto` is session-only; a preference written before that rule never
+            // seeds a fresh session into it.
+            if (pref === undefined || pref === PERMISSION_PRESET_AUTO)
+                return;
+            const agent = binding.agent;
+            const session = agent.session;
+            if (permissionPrefSeeded.has(session))
+                return;
+            const events = snapshotLiveSessionEvents(session);
+            const pinnedIdentity = compositionDefaultPreset();
+            let touchesPlanes = false;
+            for (const event of events) {
+                const known = event.type;
+                if (known === 'permission/preset' || known === 'sandbox/mode' || known === 'approval/policy') {
+                    touchesPlanes = true;
+                }
+                else if (known === 'turn/start') {
+                    // The session has been used: its planes are the ones it ran with,
+                    // never this boot's preference.
+                    return;
+                }
+            }
+            if (touchesPlanes && (pinnedIdentity === undefined || foldPermissionPreset(events) !== pinnedIdentity))
+                return;
+            // Fail closed against the mounted roster: an identity this
+            // deployment does not offer must not be driven through /permission
+            // (it would surface as a boot-time switch failure).
+            const snapshot = roster.readSnapshot(agent);
+            if (snapshot === undefined || !snapshot.options.some(option => option.value === pref)) {
+                permissionPrefSeeded.add(session);
+                ctx.logger.debug(`dsh-tui: remembered permission preset "${pref}" is not on the mounted roster; skipped`);
+                return;
+            }
+            permissionPrefSeeded.add(session);
+            const ok = await permission.applyPermissionIdentity(pref);
+            if (ok && owner.current() && session === binding.agent.session) {
+                refreshMode();
+                state.emit();
+            }
+        }
+        catch (error) {
+            ctx.logger.warn(`dsh-tui: remembered permission could not be applied: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    };
     return {
         refreshMode,
         cycleMode,
         applyMode,
         onSessionEvent,
-        runPermissionPreset: name => permission.runPermissionPreset(name),
+        applyRememberedPermission,
+        runPermissionPreset: name => trackUserPermissionSwitch(name, () => permission.runPermissionPreset(name)),
+        trackUserPermissionSwitch,
         permission,
     };
 }

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

@@ -25,9 +25,13 @@ export declare function createModelActions(ctx: Context, state: Pick<ChannelStat
     selection: ModelSelectionRef;
     applyPreferredEffort: () => Promise<void>;
     refreshEffortLevels: () => void;
-    listEfforts: () => Promise<{
+    listEfforts: (route?: {
+        provider: string;
+        model: string;
+    }) => Promise<{
         efforts: readonly EffortOption[];
         defaultEffort: string | undefined;
+        levelsFallback?: true;
     }>;
     setEffort: (id: string) => Promise<boolean>;
     setDefaultEffort: (id: string | undefined) => void;

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

@@ -1 +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,EAAwB,KAAK,qBAAqB,EAAE,MAAM,mBAAmB,CAAA;AAMpF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AACrD,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,iBAAiB,CAAA;AAEhC;;;;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;;gCA+FsC,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;;YA9NnB,MAAM;cAAQ,MAAM;;8BAmOzB,IAAI;0BACR,IAAI;;6BASD,IAAI;;uBAOJ,OAAO,CAAC,SAAS,YAAY,EAAE,CAAC;6BAQxB,MAAM,KAAG,OAAO,CAAC,OAAO,CAAC;EAkChE"}
+{"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,EAAwB,KAAK,qBAAqB,EAAE,MAAM,mBAAmB,CAAA;AAOpF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AACrD,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,iBAAiB,CAAA;AAEhC;;;;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;;gCAiGsC,OAAO,CAAC,IAAI,CAAC;+BAuDpB,IAAI;0BAqBD;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,KAAG,OAAO,CAAC;QAAE,OAAO,EAAE,SAAS,YAAY,EAAE,CAAC;QAAC,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;QAAC,cAAc,CAAC,EAAE,IAAI,CAAA;KAAE,CAAC;oBA0BnJ,MAAM,KAAG,OAAO,CAAC,OAAO,CAAC;2BAqBxB,MAAM,GAAG,SAAS,KAAG,IAAI;4BAM1B,IAAI;sBAeV,OAAO,CAAC,SAAS,YAAY,EAAE,CAAC;;YAxOnB,MAAM;cAAQ,MAAM;;8BAmPzB,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

@@ -5,6 +5,7 @@ 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';
+import { installedMeetsVersion } from '../contract.js';
 /**
  * Route metadata, effort preference and preset/model catalog actions.
  * This owns the async catalog caches and their generation fences; callers only
@@ -13,7 +14,7 @@ import { presetDisplayId, resolveCompatiblePreset, rosterOf } from '../preset-re
 export function createModelActions(ctx, state, deps) {
     const { owner, selection, notify } = deps;
     const llmRuntime = ctx.get('llm');
-    let preferredEffort = deps.initialEffort ?? readEffortPref();
+    let preferredEffort = readEffortPref() ?? deps.initialEffort;
     // 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;
@@ -47,14 +48,16 @@ export function createModelActions(ctx, state, deps) {
             deps.checkContextWarning();
         }
     };
-    /** Localized label of a standard ladder tier (the claude-effort-* family
-     * is the repo's existing vocabulary for these five names). */
+    /** Localized label of a standard ladder tier. The five names are the
+     *  host's own vocabulary (`effort-tier-*`): they label a *route* that
+     *  declares reasoning support without a tier list, whichever backend serves
+     *  it. A backend that shows its own ladder carries its own copy (B-3). */
     const STANDARD_EFFORT_LABEL_KEYS = {
-        low: 'claude-effort-low',
-        medium: 'claude-effort-medium',
-        high: 'claude-effort-high',
-        xhigh: 'claude-effort-xhigh',
-        max: 'claude-effort-max',
+        low: 'effort-tier-low',
+        medium: 'effort-tier-medium',
+        high: 'effort-tier-high',
+        xhigh: 'effort-tier-xhigh',
+        max: 'effort-tier-max',
     };
     const standardEffortLabel = (id) => {
         const key = STANDARD_EFFORT_LABEL_KEYS[id];
@@ -134,26 +137,18 @@ export function createModelActions(ctx, state, deps) {
                 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.
+            // Existing agents retain their pin across reattachment, and /settings
+            // reaches this path without a bind. Remove an unsupported old effort
+            // while keeping the selected route; otherwise the wire would retain the
+            // old tier while the readout announces the model default. The ref is not
+            // UI state; 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.
+        // Dedupe gates ONLY the toast: a new Agent has a fresh selection, so the
+        // preference must apply even when the previous Agent used the same tier.
         const fresh = lastEffortFallbackNotice?.preferred !== preferredEffort || lastEffortFallbackNotice.applied !== applied;
         if (applied !== preferredEffort && fresh) {
             lastEffortFallbackNotice = { preferred: preferredEffort, applied };
@@ -190,7 +185,24 @@ export function createModelActions(ctx, state, deps) {
         notify(t('effort-switched', { name: effort.name }));
         state.emit();
     };
-    const listEfforts = async () => {
+    const listEfforts = async (route) => {
+        if (route !== undefined) {
+            const binding = deps.binding.capture();
+            if (llmRuntime === undefined || typeof llmRuntime.resolveModelInfo !== 'function')
+                return { efforts: [], defaultEffort: undefined };
+            // Preview is independent of the live effort operation: browsing the
+            // picker must neither invalidate a pending preference nor publish the
+            // candidate's context window/tiers into the current session.
+            const info = await llmRuntime.resolveModelInfo(route.provider, route.model);
+            if (!owner.current() || !deps.binding.isCurrent(binding))
+                return { efforts: [], defaultEffort: undefined };
+            return {
+                efforts: tiersOf(info.reasoning),
+                defaultEffort: typeof info.reasoning === 'object' && info.reasoning !== null ? info.reasoning.defaultEffort : undefined,
+                ...(info.reasoning === true || (typeof info.reasoning === 'object' && info.reasoning !== null && info.reasoning.efforts === undefined)
+                    ? { levelsFallback: true } : {}),
+            };
+        }
         const capture = captureEffort();
         const resolved = await resolveEfforts(capture);
         if (resolved === 'stale')
@@ -236,10 +248,11 @@ export function createModelActions(ctx, state, deps) {
     };
     /**
      * 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.
+     * user layer (an explicit value there outranks the persisted `/effort`
+     * choice); an absent level re-derives the boot chain (the persisted
+     * `/effort` choice → the cordis.yml `effort` deployment default). 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());
@@ -268,7 +281,13 @@ export function createModelActions(ctx, state, deps) {
     const listModels = () => {
         if (llmRuntime === undefined)
             return Promise.resolve([]);
-        return Promise.all(llmRuntime.listProviders().map(provider => llmRuntime.listModels(provider.id).catch(() => []))).then(lists => lists.flat());
+        return Promise.all(llmRuntime.listProviders().map(provider => llmRuntime.listModels(provider.id).catch(() => []))).then(lists => lists.flat().map(model => {
+            // rc.2's official model-label plugin is display-only; keep route IDs intact.
+            const official = model.provider === 'deepseek-account' || model.provider === 'deepseek-official';
+            return official && model.id === 'deepseek-flash' && model.name === 'DeepSeek-V4.1-Flash' &&
+                installedMeetsVersion('@deepseek-ai/dsh-web-app', '0.2.1-rc.2')
+                ? { ...model, name: `${model.name} 1017` } : model;
+        }));
     };
     const listProviders = () => Promise.resolve(llmRuntime === undefined ? [] : llmRuntime.listProviders().map(info => ({ ...info })));
     const dropModelNodeCache = () => { modelNodeCache.generation += 1; modelNodeCache.nodes = undefined; modelNodeCache.load = undefined; };

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

@@ -0,0 +1,17 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent, ModelSelectionRef } from '@deepseek-ai/dsh-agent';
+import { type ChannelOwner } from './owner.js';
+/** Routing belongs to the live agent, including turns running while parked.
+ * The foreground facade follows the binding; each waterfall captures its own
+ * agent's ref so a later binding can never supply its route. */
+export declare function createModelSelection(ctx: Context, deps: {
+    owner: ChannelOwner;
+    agent(): Agent;
+}): {
+    selection: ModelSelectionRef;
+    bind: (agent: Agent, route: {
+        provider: string;
+        model: string;
+    }) => void;
+};
+//# sourceMappingURL=model-selection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"model-selection.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/model-selection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,KAAK,EAAE,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAA;AAEtE,OAAO,EAAsB,KAAK,YAAY,EAAE,MAAM,YAAY,CAAA;AAElE;;gEAEgE;AAChE,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE;IACvD,KAAK,EAAE,YAAY,CAAA;IACnB,KAAK,IAAI,KAAK,CAAA;CACf;;kBAesB,KAAK,SAAS;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,KAAG,IAAI;EA2E9E"}

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

@@ -0,0 +1,109 @@
+import { boundContextSummary, createUserMessage } from '@deepseek-ai/dsh-llm';
+import { createChannelOwner } from './owner.js';
+/** Routing belongs to the live agent, including turns running while parked.
+ * The foreground facade follows the binding; each waterfall captures its own
+ * agent's ref so a later binding can never supply its route. */
+export function createModelSelection(ctx, deps) {
+    const entries = new Map();
+    const foreground = () => {
+        const entry = entries.get(deps.agent());
+        if (entry === undefined)
+            throw new Error('dsh-tui: model selection has not been bound');
+        return entry.ref;
+    };
+    const selection = {
+        get current() { return foreground().current; },
+        set current(value) { foreground().current = value; },
+        get assembled() { return foreground().assembled; },
+        set assembled(value) { foreground().assembled = value; },
+    };
+    deps.owner.own(ctx.on('agent/disposed', ({ agent }) => entries.get(agent)?.release()));
+    const bind = (agent, route) => {
+        deps.owner.assertActive();
+        if (entries.has(agent))
+            return;
+        const recorded = agent.session.requestHeader?.()?.config;
+        const hasCreatedRoute = agent.options?.provider !== undefined && agent.options.model !== undefined;
+        // Seeded children can deliberately replace the inherited header's route.
+        // Restore a recorded pin only when the caller actually adopted that route.
+        const usesRecordedRoute = recorded?.provider === route.provider && recorded?.model === route.model;
+        const ref = {
+            current: route.provider !== '' && route.model !== '' &&
+                (!hasCreatedRoute || (usesRecordedRoute &&
+                    (route.provider !== agent.options.provider || route.model !== agent.options.model)))
+                ? { ...route } : undefined,
+            assembled: undefined,
+        };
+        const lifetime = createChannelOwner();
+        lifetime.bind(deps.owner.current);
+        let assemblyOperation = 0;
+        const current = lifetime.current;
+        const release = deps.owner.own(() => {
+            entries.delete(agent);
+            lifetime.dispose();
+        });
+        entries.set(agent, { ref, release });
+        const own = (dispose) => {
+            lifetime.own(dispose);
+            lifetime.assertActive();
+        };
+        try {
+            own(agent.ctx.on('system-prompt/assemble', async (_assembly, _context, next) => {
+                const operation = ++assemblyOperation;
+                const selected = ref.current;
+                const assembled = await next();
+                if (!current())
+                    return assembled;
+                // A slow context-panel inspection must not replace a newer turn's route.
+                if (operation === assemblyOperation)
+                    ref.assembled = selected;
+                if (selected === undefined)
+                    return assembled;
+                return { ...assembled, variables: { ...assembled.variables, provider: selected.provider, model: selected.model } };
+            }));
+            own(agent.ctx.on('agent/request', async (_payload, next) => {
+                const resolved = await next();
+                if (!current())
+                    return resolved;
+                const selected = ref.assembled;
+                if (selected === undefined)
+                    return resolved;
+                const { reasoningEffort: _inheritedEffort, ...withoutInheritedEffort } = resolved;
+                return {
+                    ...withoutInheritedEffort,
+                    provider: selected.provider,
+                    model: selected.model,
+                    ...(selected.reasoningEffort === undefined ? {} : { reasoningEffort: selected.reasoningEffort }),
+                };
+            }));
+            // Match upstream installModelSelection's admission-time provenance.
+            own(agent.ctx.on('agent/pre-step', async ({ agent: subject, messages, signal, step }, next) => {
+                const decision = await next();
+                if (!current() || decision.kind === 'reject' || signal.aborted)
+                    return decision;
+                if (decision.messages.length === 0 && (step === 1 || messages.length > 0))
+                    return decision;
+                const selected = ref.assembled;
+                const previous = subject.session.requestHeader()?.config;
+                if (selected === undefined || previous === undefined ||
+                    (selected.provider === previous.provider && selected.model === previous.model))
+                    return decision;
+                const from = selected.provider === previous.provider ? previous.model : `${previous.provider}/${previous.model}`;
+                const to = selected.provider === previous.provider ? selected.model : `${selected.provider}/${selected.model}`;
+                return { ...decision, messages: [...decision.messages, createUserMessage({
+                            content: [{ type: 'text', text: `[model changed: assistant turns above this point were generated by ${from}; the session continues with ${to}]` }],
+                            // Older source unions lack this kind; the runtime shape is unchanged.
+                            source: { kind: 'model-selection', form: 'notice', summary: boundContextSummary(`${from} → ${to}`) },
+                        })] };
+            }, { prepend: true }));
+        }
+        catch (error) {
+            try {
+                release();
+            }
+            catch { /* preserve the registration failure */ }
+            throw error;
+        }
+    };
+    return { selection, bind };
+}