@deepseek-harness-tui/dsh-tui 0.10.0 → 0.10.2

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

@@ -0,0 +1,275 @@
+import { ReasoningEffortId } from '@deepseek-ai/dsh-llm';
+import { 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 { 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();
+    // 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;
+    const resolveEfforts = async (capture) => {
+        if (llmRuntime === undefined || typeof llmRuntime.resolveModelInfo !== 'function')
+            return 'unavailable';
+        try {
+            const info = await llmRuntime.resolveModelInfo(capture.provider, capture.model);
+            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 || !resolved.efforts.some(effort => effort.id === preferredEffort))
+            return;
+        selection.current = { provider: capture.provider, model: capture.model, reasoningEffort: ReasoningEffortId(preferredEffort) };
+    };
+    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 (!effortCurrent(capture) || generation !== effortLevelsGeneration)
+                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-${preset.id}`, preset.name) : preset.name }), ...(preset.description === undefined ? {} : { description: localized ? tOr(`preset-desc-${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,32 @@
+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' | '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;
+    onModelSwitch(model: string): 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;AAOvE,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,aAAa,GAAG,UAAU,GAAG,OAAO,GAAG,eAAe,GAAG,cAAc,GAAG,iBAAiB,GAAG,MAAM,CAAC,CAAA;AAElJ,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,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IAClC,MAAM,EAAE,YAAY,CAAC,QAAQ,CAAC,CAAA;CAC/B,IAEa,UAAU,MAAM,EAAE,OAAO,MAAM,KAAG,OAAO,CAAC,OAAO,CAAC,CAgEjE"}

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

@@ -0,0 +1,98 @@
+import { randomUUID } from 'node:crypto';
+import { SessionId } from '@deepseek-ai/dsh-session';
+import { t } from '../../i18n.js';
+import { writeModelPref } from '../../modelPrefs.js';
+import { touchSession } from '../../sessionHistory.js';
+import { liveSessionCreateOptions, sliceLiveSessionSeed } from '../compat/index.js';
+import { composePreset, runningPresetOf } from '../presets.js';
+import { attachSessionToWorkspace } from '../workspace.js';
+import { resetSessionProjection } from './session-reset.js';
+/** Model-route adoption transaction. It settles compaction before its fork snapshot and owns the post-commit reset. */
+export function createModelSwitchAction(ctx, state, deps) {
+    return async (provider, model) => {
+        const adoption = deps.binding.capture();
+        if (state.working) {
+            deps.notify(t('model-switch-while-working'), { color: 'warning' });
+            return false;
+        }
+        const agents = ctx.get('agents');
+        if (agents === undefined) {
+            deps.notify(t('model-switch-unavailable'), { color: 'error' });
+            return false;
+        }
+        let seed;
+        try {
+            // A compaction checkpoint may not settle after the model fork snapshot.
+            await deps.settleCompaction();
+            // No boundary = the whole source log (continue the conversation). Slice
+            // the SOURCE snapshot: sessions.fork() registers a real child, and its
+            // snapshot length is not the inherited cut.
+            seed = sliceLiveSessionSeed(deps.binding.agent.session);
+        }
+        catch (error) {
+            deps.notify(t('model-switch-fork-failed', { err: error instanceof Error ? error.message : String(error) }), { color: 'error' });
+            return false;
+        }
+        const childId = SessionId(randomUUID());
+        const composed = await composePreset(ctx, runningPresetOf(deps.binding.agent.session));
+        let handle;
+        try {
+            handle = await deps.binding.prepare(adoption, () => agents.create(liveSessionCreateOptions({
+                sessionId: childId,
+                seed,
+                runtimeSession: deps.binding.agent.session,
+                inheritedCount: seed.length,
+                cwd: state.cwd,
+                parentSession: deps.binding.agent.session.id,
+                agentPreset: composed.agentPreset,
+                agentOptions: { provider, model },
+                setup: composed.setup,
+            })));
+        }
+        catch (error) {
+            deps.notify(t('model-switch-failed', { err: error instanceof Error ? error.message : String(error) }), { color: 'error', timeoutMs: 8000 });
+            return false;
+        }
+        try {
+            await attachSessionToWorkspace(ctx, state.cwd, childId);
+        }
+        catch (error) {
+            deps.notify(t('model-switch-attach-failed', { err: error instanceof Error ? error.message : String(error) }), { color: 'warning', timeoutMs: 8000 });
+        }
+        if (!deps.binding.isCurrent(adoption) || !deps.owner.current()) {
+            await deps.binding.abandon(handle);
+            return false;
+        }
+        return deps.binding.adopt(handle, adoption, (_previous, disposePrevious) => {
+            resetSessionProjection(state, deps.rowIds, deps.resetProjector, deps.resetSubagents, deps.resetJobs);
+            state.status = handle.agent.status;
+            state.agentId = handle.agent.id;
+            state.agentPreset = composed.agentPreset;
+            state.provider = provider;
+            state.model = model;
+            state.contextWindow = undefined;
+            state.effortLevels = undefined;
+            state.reasoningEffort = undefined;
+            deps.dropModelCompletion();
+            deps.replay(seed);
+            deps.settleReplay();
+            state.working = handle.agent.status === 'running';
+            // Reset the input FIFO and pending-decision indicators BEFORE the first
+            // emit: a submit from a session-changed subscriber must not chain onto
+            // the replaced session's parked promise (main's bind → clear → refresh
+            // order).
+            deps.clearStagedImages();
+            deps.bindAgent();
+            deps.onModelSwitch(model);
+            deps.refreshCommands();
+            void deps.refreshLoadedContext();
+            void deps.refreshSkillCommands();
+            touchSession(childId);
+            state.emit();
+            disposePrevious('dispose');
+            if (!writeModelPref(provider, model))
+                deps.notify(t('model-pref-write-failed'), { color: 'warning' });
+            return true;
+        });
+    };
+}

package/lib/types/dsh-adapter/channel/notifications.d.ts

@@ -0,0 +1,9 @@
+import type { ChannelOwner } from './owner.js';
+import type { ChannelUi } from '../../adapter/ports/channel-ui.js';
+import type { NotificationItem } from './types.js';
+/** Own expiry and explicit dismissal in the same bounded notification scope. */
+export declare function createChannelNotifications(state: () => {
+    notifications: NotificationItem[];
+    emit(): void;
+}, owner: ChannelOwner): ChannelUi['notify'];
+//# sourceMappingURL=notifications.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"notifications.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/notifications.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAC9C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mCAAmC,CAAA;AAClE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAElD,gFAAgF;AAChF,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,MAAM;IAAE,aAAa,EAAE,gBAAgB,EAAE,CAAC;IAAC,IAAI,IAAI,IAAI,CAAA;CAAE,EAChE,KAAK,EAAE,YAAY,GAClB,SAAS,CAAC,QAAQ,CAAC,CAiBrB"}

package/lib/types/dsh-adapter/channel/notifications.js

@@ -0,0 +1,24 @@
+/** Own expiry and explicit dismissal in the same bounded notification scope. */
+export function createChannelNotifications(state, owner) {
+    let sequence = 0;
+    return (text, options = {}) => {
+        owner.assertActive();
+        const item = { id: sequence++, text, color: options.color, timeoutMs: options.timeoutMs ?? 4000 };
+        state().notifications.push(item);
+        state().emit();
+        let timer;
+        const release = owner.own(() => {
+            if (timer !== undefined)
+                clearTimeout(timer);
+            const store = state();
+            const index = store.notifications.indexOf(item);
+            if (index >= 0) {
+                store.notifications.splice(index, 1);
+                store.emit();
+            }
+        });
+        if (item.timeoutMs > 0)
+            timer = setTimeout(release, item.timeoutMs);
+        return release;
+    };
+}

package/lib/types/dsh-adapter/channel/owner.d.ts

@@ -0,0 +1,18 @@
+/** Channel lifetime plus binding fences for work that crosses an await. */
+export declare function createChannelOwner(): {
+    current: () => boolean;
+    assertActive: () => void;
+    readonly cleanupCount: number;
+    signal: AbortSignal;
+    bind(check: () => boolean): void;
+    own(cleanup: () => void): () => void;
+    dispose(): void;
+};
+export type ChannelOwner = ReturnType<typeof createChannelOwner>;
+export declare function registerChannelOwner(channel: object, owner: ChannelOwner): void;
+export declare function bindChannelOwner(channel: object, check: () => boolean): void;
+export declare function channelOwnerCurrent(channel: object): boolean;
+/** Register work that must be revoked whenever this Channel owner releases. */
+export declare function onChannelOwnerDispose(channel: object, cleanup: () => void): () => void;
+export declare function disposeChannelOwner(channel: object): void;
+//# sourceMappingURL=owner.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"owner.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/owner.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,wBAAgB,kBAAkB;;;;;gBAgBlB,MAAM,OAAO;iBACZ,MAAM,IAAI;;EA0B1B;AACD,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAEhE,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,IAAI,CAA+B;AAC/G,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,OAAO,GAAG,IAAI,CAAqC;AAClH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAmD;AAChH,+EAA+E;AAC/E,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAGtF;AACD,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAmC"}

package/lib/types/dsh-adapter/channel/owner.js

@@ -0,0 +1,73 @@
+/** Channel lifetime plus binding fences for work that crosses an await. */
+export function createChannelOwner() {
+    let active = true;
+    let externalCheck = () => true;
+    const cleanups = new Set();
+    const controller = new AbortController();
+    const current = () => {
+        if (!active)
+            return false;
+        try {
+            return externalCheck();
+        }
+        catch {
+            return false;
+        }
+    };
+    const assertActive = () => {
+        if (!current())
+            throw new Error('dsh-tui: Channel lifetime has ended');
+    };
+    return {
+        current, assertActive,
+        get cleanupCount() { return cleanups.size; },
+        signal: controller.signal,
+        bind(check) { externalCheck = check; },
+        own(cleanup) {
+            let released = false;
+            const release = () => {
+                if (released)
+                    return;
+                released = true;
+                cleanups.delete(release);
+                cleanup();
+            };
+            if (active)
+                cleanups.add(release);
+            else
+                release();
+            return release;
+        },
+        dispose() {
+            if (!active)
+                return;
+            active = false;
+            controller.abort();
+            const failures = [];
+            // Every registered resource gets one cleanup attempt. A throwing
+            // external disposer must not strand later subscriptions or handles.
+            for (const cleanup of [...cleanups]) {
+                try {
+                    cleanup();
+                }
+                catch (error) {
+                    failures.push(error);
+                }
+            }
+            if (failures.length === 1)
+                throw failures[0];
+            if (failures.length > 1)
+                throw new AggregateError(failures, 'dsh-tui: Channel cleanup failed');
+        },
+    };
+}
+const owners = new WeakMap();
+export function registerChannelOwner(channel, owner) { owners.set(channel, owner); }
+export function bindChannelOwner(channel, check) { owners.get(channel)?.bind(check); }
+export function channelOwnerCurrent(channel) { return owners.get(channel)?.current() ?? false; }
+/** Register work that must be revoked whenever this Channel owner releases. */
+export function onChannelOwnerDispose(channel, cleanup) {
+    const owner = owners.get(channel);
+    return owner === undefined ? (() => undefined) : owner.own(cleanup);
+}
+export function disposeChannelOwner(channel) { owners.get(channel)?.dispose(); }

package/lib/types/dsh-adapter/channel/paths.d.ts

@@ -0,0 +1,31 @@
+import { type FileCandidate } from '../../utils/fileSuggestions.js';
+import type { FileSuggestionFs } from './types.js';
+/** Trailing path segment (`C:/a/b` → `b`). */
+export declare function basename(path: string): string;
+/** Normalize a cwd for comparison: forward slashes, no trailing slash; case
+ *  folded when the platform's filesystem semantics are case-insensitive. */
+export declare function normalizeCwd(path: string, caseInsensitive: boolean): string;
+/**
+ * `/resume` project filter (issue #96): exact cwd match, PLUS sessions
+ * recorded in a subdirectory — pre-upgrade launches recorded the launch
+ * subdirectory as the header cwd, and with the cwd default now resolving to
+ * the git worktree root an exact match would hide those sessions forever.
+ * They belong to the same workspace, so they stay listed. Comparison follows
+ * the platform's filesystem semantics (case-insensitive on Windows — a
+ * pre-upgrade header may record `C:\Repo` where the current launch resolves
+ * `c:\repo`). `caseInsensitive` is a parameter (not a platform read) so the
+ * verifier can exercise both modes on any host. Exported for
+ * scripts/verify-session-cwd.mjs.
+ *
+ * Boundary rule (issue #153): container directories are nobody's workspace.
+ * $HOME and the Windows root forms — plain drive roots (`C:`), UNC share
+ * roots (`//server/share`), and extended-length roots (`//?/C:`,
+ * `//?/UNC/server/share`) — are ancestors of unrelated projects, so the
+ * descendant rules below would list every session on the machine from `~`
+ * (and every session on the drive/share from those roots). At these
+ * boundaries, in either direction, only an exact match passes.
+ */
+export declare function sessionCwdMatches(stateCwd: string, headerCwd: string, caseInsensitive?: boolean): boolean;
+export declare function listPathCandidates(fs: FileSuggestionFs, cwd: string, query: string, signal: AbortSignal | undefined, topK: number): Promise<FileCandidate[]>;
+export declare function listFilesDeepCandidates(fs: FileSuggestionFs | undefined, root: string, signal?: AbortSignal): Promise<FileCandidate[]>;
+//# sourceMappingURL=paths.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/paths.ts"],"names":[],"mappings":"AACA,OAAO,EAAsB,KAAK,aAAa,EAAE,MAAM,gCAAgC,CAAA;AAEvF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAElD,8CAA8C;AAC9C,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAG7C;AAED;4EAC4E;AAC5E,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,eAAe,EAAE,OAAO,GAAG,MAAM,CAG3E;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,eAAe,GAAE,OAAsC,GACtD,OAAO,CAwBT;AAED,wBAAsB,kBAAkB,CAAC,EAAE,EAAE,gBAAgB,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CAyBlK;AAED,wBAAsB,uBAAuB,CAAC,EAAE,EAAE,gBAAgB,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CAmD5I"}