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

package/lib/types/dsh-adapter/channel/session-metadata.js

@@ -0,0 +1,209 @@
+import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import { clearResumeTarget, forgetSession, readResumeTarget, touchSession, writeResumeTarget } from '../../sessionHistory.js';
+import { t } from '../../i18n.js';
+import { appendSessionTitle, deleteSessionLog } from '../compat/index.js';
+import { snapshotLiveSessionEvents } from '../compat/liveSession.js';
+import { collectRecentActivity, parseRecapResponse, RECAP_RECENT_CHARS, wrapRecapPrompt } from '../recap.js';
+import { listSummaries, locateSession, previewSession } from '../sessions/index.js';
+import { runSideQuestion, wrapSideQuestion } from '../sideQuestion.js';
+import { isUserInvocable } from '@deepseek-ai/dsh-skill';
+const PREVIEW_ENTRIES = 8;
+/** Session-scoped metadata, persistence queries, and tool-less LLM reads. */
+export function createSessionMetadataActions(ctx, deps) {
+    const current = (capture) => deps.owner.current() && deps.binding.isCurrent(capture);
+    const persistence = () => ctx.get('sessionPersistence');
+    const withOwnerSignal = (signal) => signal === undefined ? deps.owner.signal : AbortSignal.any([signal, deps.owner.signal]);
+    const listSessions = async () => {
+        const capture = deps.binding.capture();
+        const source = persistence();
+        if (!source) {
+            if (current(capture))
+                deps.setPersistedSessions([]);
+            return [];
+        }
+        const summaries = await listSummaries(source);
+        if (!current(capture))
+            return [];
+        deps.setPersistedSessions(summaries);
+        return summaries;
+    };
+    const preview = async (sessionId) => {
+        const capture = deps.binding.capture();
+        const source = persistence();
+        if (!source)
+            return [];
+        const path = await locateSession(source, sessionId);
+        if (!current(capture) || path === undefined)
+            return [];
+        const entries = await previewSession(path, PREVIEW_ENTRIES);
+        return current(capture) ? entries : [];
+    };
+    const listSkills = async () => {
+        const capture = deps.binding.capture();
+        const target = capture.agent;
+        const registry = deps.skillRegistryFor(target);
+        if (!registry)
+            return [];
+        try {
+            const observation = await registry.snapshot(deps.skillViewOptions(target));
+            if (!current(capture) || !observation.complete)
+                return undefined;
+            return observation.skills.map(skill => ({
+                name: skill.name,
+                description: skill.description,
+                userInvocable: isUserInvocable(skill),
+                source: skill.source,
+            }));
+        }
+        catch {
+            return current(capture) ? undefined : [];
+        }
+    };
+    const describeCredential = async (ref) => {
+        const capture = deps.binding.capture();
+        const credentials = ctx.get('credentials');
+        if (!credentials)
+            return undefined;
+        try {
+            const result = await credentials.describe(ref);
+            return current(capture) ? result : undefined;
+        }
+        catch (error) { // `undefined` means the optional service is absent. Keep a live
+            // credential service's read failure observable; only suppress it once
+            // this Channel binding has been replaced or disposed.
+            if (!current(capture))
+                return undefined;
+            throw error;
+        }
+    };
+    /**
+     * Recaps omit conversation history but borrow its effective system text.
+     * Derivation applies surface replacements and empty prompt tombstones;
+     * scanning the event log would revive superseded instructions.
+     */
+    const currentSystemText = (capture) => {
+        try {
+            const system = capture.agent.session.deriveMessages().findLast(message => message.role === 'system');
+            const text = system?.content.map(block => block.type === 'text' ? block.text : '').join('') ?? '';
+            return text === '' ? undefined : text;
+        }
+        catch {
+            // A session without derived history has no surface prompt to lend.
+        }
+        return undefined;
+    };
+    const llmRequest = (capture, messages, includesHistory, signal) => {
+        const header = capture.agent.session.requestHeader();
+        const config = header?.config;
+        // Pre-V3 headers carried the system prompt inline; V3 moved it to
+        // `system/message` surface nodes (see currentSystemText).
+        const legacySystem = header?.system;
+        const system = messages.some(message => message.role === 'system')
+            ? undefined
+            : typeof legacySystem === 'string' ? legacySystem : includesHistory ? undefined : currentSystemText(capture);
+        return {
+            provider: config?.provider ?? deps.provider(),
+            model: config?.model ?? deps.model(),
+            messages,
+            ...(system !== undefined && { system }),
+            ...(config?.reasoningEffort !== undefined && { reasoningEffort: config.reasoningEffort }),
+            ...(config?.temperature !== undefined && { temperature: config.temperature }),
+            ...(config?.maxTokens !== undefined && { maxTokens: config.maxTokens }),
+            ...(config?.stop !== undefined && { stop: [...config.stop] }),
+            sessionId: capture.agent.session.id,
+            ...(signal && { signal }),
+        };
+    };
+    const sideQuestion = async (question, options) => {
+        const capture = deps.binding.capture();
+        const llm = ctx.get('llm');
+        if (!llm)
+            return { answer: null, error: t('btw-llm-unavailable') };
+        const signal = withOwnerSignal(options?.signal);
+        const outcome = await runSideQuestion({
+            stream: llm.stream.bind(llm),
+            options: llmRequest(capture, [
+                ...capture.agent.session.deriveMessages(),
+                createUserMessage({ content: [{ type: 'text', text: wrapSideQuestion(question) }], source: { kind: 'plugin', plugin: 'dsh-tui/btw' } }),
+            ], true, signal),
+            // Do not let an old session append streamed UI facts after a switch.
+            onText: delta => { if (current(capture) && !options?.signal?.aborted)
+                options?.onText?.(delta); },
+            signal,
+        });
+        return current(capture) ? outcome : { answer: null };
+    };
+    const recapRecent = async (options) => {
+        const capture = deps.binding.capture();
+        const llm = ctx.get('llm');
+        // Optional host services can be partially mounted while startup is still
+        // composing. A present service without its streaming capability is just
+        // as unavailable as an absent service; do not throw from an auto recap.
+        if (typeof llm?.stream !== 'function')
+            return { summary: null, error: t('recap-llm-unavailable') };
+        const activity = collectRecentActivity(snapshotLiveSessionEvents(capture.agent.session), RECAP_RECENT_CHARS);
+        if (activity === '')
+            return { summary: null, error: t('recap-no-activity') };
+        const signal = withOwnerSignal(options?.signal);
+        const outcome = await runSideQuestion({
+            stream: llm.stream.bind(llm),
+            options: llmRequest(capture, [
+                createUserMessage({ content: [{ type: 'text', text: wrapRecapPrompt(activity) }], source: { kind: 'plugin', plugin: 'dsh-tui/recap' } }),
+            ], false, signal),
+            onText: delta => { if (current(capture) && !options?.signal?.aborted)
+                options?.onText?.(delta); },
+            signal,
+        });
+        if (!current(capture) || outcome.answer === null)
+            return { summary: null, ...(current(capture) ? { error: outcome.error } : {}) };
+        const parsed = parseRecapResponse(outcome.answer);
+        return parsed.title === undefined ? { summary: parsed.summary } : { summary: parsed.summary, title: parsed.title };
+    };
+    const renameSession = (title) => {
+        const capture = deps.binding.capture();
+        if (!current(capture))
+            return;
+        capture.agent.session.append('session/title', { title });
+        deps.setSessionTitle(title);
+        deps.emit();
+    };
+    const setSessionColor = (color) => {
+        const capture = deps.binding.capture();
+        if (!current(capture))
+            return;
+        capture.agent.session
+            .append('session/color', { color });
+        deps.setSessionColor(color);
+        deps.emit();
+    };
+    const deleteSession = async (sessionId) => {
+        const capture = deps.binding.capture();
+        if (sessionId === capture.agent.session.id || !current(capture))
+            return false;
+        if (deleteSessionLog(sessionId) !== 'deleted' || !current(capture))
+            return false;
+        forgetSession(sessionId);
+        deps.forgetAgentView(sessionId);
+        if (readResumeTarget() === sessionId)
+            clearResumeTarget();
+        return true;
+    };
+    const renameSessionTo = async (sessionId, title) => {
+        const capture = deps.binding.capture();
+        if (!current(capture))
+            return false;
+        if (sessionId === capture.agent.session.id) {
+            renameSession(title);
+            return true;
+        }
+        if (appendSessionTitle(sessionId, title) !== 'appended' || !current(capture))
+            return false;
+        touchSession(sessionId);
+        return true;
+    };
+    return {
+        listSessions, previewSession: preview, listSkills, describeCredential,
+        sideQuestion, recapRecent, setResumeTarget: writeResumeTarget,
+        renameSession, setSessionColor, deleteSession, renameSessionTo,
+    };
+}

package/lib/types/dsh-adapter/channel/session-reset.d.ts

@@ -0,0 +1,11 @@
+import type { ChannelState } from './types.js';
+export type SessionResetState = Pick<ChannelState, 'rows' | 'todos' | 'pending' | 'goal' | 'sessionTitle' | 'sessionColor' | 'tokens' | 'responseChars' | 'activeToolCount' | 'lastUserText' | 'working' | 'cancelPending' | 'spinnerMode' | 'tps' | 'tpsSamples' | 'lastUsage' | 'workingActivity' | 'contextSegments'>;
+/**
+ * Reset the projection facts shared by every foreground session adoption.
+ * Target-specific route, cwd, preset, loaded-context and status fields stay
+ * with the caller: not every adoption has the same semantics for those.
+ */
+export declare function resetSessionProjection(state: SessionResetState, rowIds: {
+    value: number;
+}, resetProjector: () => void, resetSubagents: () => void, resetJobs: () => void): void;
+//# sourceMappingURL=session-reset.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"session-reset.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/session-reset.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAE9C,MAAM,MAAM,iBAAiB,GAAG,IAAI,CAClC,YAAY,EACV,MAAM,GACN,OAAO,GACP,SAAS,GACT,MAAM,GACN,cAAc,GACd,cAAc,GACd,QAAQ,GACR,eAAe,GACf,iBAAiB,GACjB,cAAc,GACd,SAAS,GACT,eAAe,GACf,aAAa,GACb,KAAK,GACL,YAAY,GACZ,WAAW,GACX,iBAAiB,GACjB,iBAAiB,CACpB,CAAA;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,iBAAiB,EACxB,MAAM,EAAE;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,EACzB,cAAc,EAAE,MAAM,IAAI,EAC1B,cAAc,EAAE,MAAM,IAAI,EAC1B,SAAS,EAAE,MAAM,IAAI,GACpB,IAAI,CAqCN"}

package/lib/types/dsh-adapter/channel/session-reset.js

@@ -0,0 +1,44 @@
+import { markChannelReadDirty } from '../../adapter/channel/read-view.js';
+/**
+ * Reset the projection facts shared by every foreground session adoption.
+ * Target-specific route, cwd, preset, loaded-context and status fields stay
+ * with the caller: not every adoption has the same semantics for those.
+ */
+export function resetSessionProjection(state, rowIds, resetProjector, resetSubagents, resetJobs) {
+    resetProjector();
+    rowIds.value = 0;
+    state.rows.length = 0;
+    markChannelReadDirty(state.rows);
+    resetSubagents();
+    resetJobs();
+    state.todos = [];
+    state.pending = [];
+    state.goal = undefined;
+    state.sessionTitle = '';
+    state.sessionColor = '';
+    state.tokens = {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        peak: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        idle: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    };
+    state.responseChars = 0;
+    state.activeToolCount = 0;
+    state.lastUserText = '';
+    state.working = false;
+    state.cancelPending = false;
+    state.spinnerMode = 'requesting';
+    state.tps = undefined;
+    state.tpsSamples = [];
+    state.lastUsage = undefined;
+    state.workingActivity = undefined;
+    state.contextSegments = {
+        system: 0,
+        prompt: 0,
+        assistant: 0,
+        thinking: 0,
+        tools: 0,
+    };
+}

package/lib/types/dsh-adapter/channel/session-resume.d.ts

@@ -0,0 +1,56 @@
+import type { AgentHandle } from '@deepseek-ai/dsh-agent';
+import type { Context } from '@deepseek-ai/cordis';
+import { type SessionEvent } from '@deepseek-ai/dsh-session';
+import { resetSessionProjection } from './session-reset.js';
+import type { createChannelBinding } from './binding.js';
+import type { ChannelOwner } from './owner.js';
+import { type AdapterRuntimeOptions } from '../../adapter/kernel/runtime.js';
+import type { ChannelState, ResumeResult } from './types.js';
+type Binding = ReturnType<typeof createChannelBinding>;
+type ResumeState = Pick<ChannelState, 'working' | 'status' | 'agentId' | 'cwd' | 'displayCwd' | 'agentPreset' | 'provider' | 'model' | 'loadedContext' | 'contextWindow' | 'effortLevels' | 'reasoningEffort' | 'working' | 'emit'> & Parameters<typeof resetSessionProjection>[0];
+export type NewSessionTarget = {
+    /** Internal guarded workspace handoff; never exposed on ChannelUi.newSession(). */
+    readonly cwd: string;
+    readonly displayCwd?: string;
+};
+/** Persisted-session and fresh-session foreground actions. */
+export declare function createSessionResumeActions(ctx: Context, state: ResumeState, options: {
+    configuredPreset?: string;
+    configuredProvider?: string;
+    configuredModel?: string;
+    provider: string;
+    model: string;
+}, deps: {
+    owner: Pick<ChannelOwner, 'current'>;
+    binding: Pick<Binding, 'agent' | 'capture' | 'isCurrent' | 'prepare' | 'abandon' | 'adopt'>;
+    backgroundHandles: Map<string, AgentHandle>;
+    rowIds: {
+        value: number;
+    };
+    resetProjector(): void;
+    resetSubagents(): void;
+    resetJobs(): void;
+    replay(events: readonly SessionEvent[]): void;
+    settleReplay(): void;
+    describeWorkspace(cwd: string): {
+        description?: string;
+    };
+    refreshGitBranch(): void;
+    bindAgent(): void;
+    refreshCommands(): void;
+    refreshLoadedContext(): Promise<void>;
+    refreshSkillCommands(): Promise<void>;
+    clearStagedImages(): void;
+    settleCompaction(): Promise<void>;
+    sessionSwitchVetoed(kind: 'new' | 'resume' | 'agent-view', targetSessionId?: string): Promise<boolean>;
+    notify: ChannelState['notify'];
+    notifySessionSwitched(kind: 'new' | 'resume' | 'agent-view', sessionId: string, previousSessionId: string): void;
+    runtime: AdapterRuntimeOptions;
+}): {
+    resumeInto: (sessionId: string, kind: "resume" | "agent-view", keepCurrent: boolean) => Promise<ResumeResult>;
+    resumeTo: (sessionId: string) => Promise<ResumeResult>;
+    newSession: () => Promise<boolean>;
+    newSessionWithTarget: (target?: NewSessionTarget) => Promise<boolean>;
+};
+export {};
+//# sourceMappingURL=session-resume.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"session-resume.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/session-resume.ts"],"names":[],"mappings":"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"}

package/lib/types/dsh-adapter/channel/session-resume.js

@@ -0,0 +1,240 @@
+import { randomUUID } from 'node:crypto';
+import { SessionId } from '@deepseek-ai/dsh-session';
+import { explicitModelRoute, recordedModelRoute, resolveModelRoute, validateModelRoute } from '../../modelRoute.js';
+import { clearResumeTarget, touchAgentViewSession, touchSession, writeResumeTarget } from '../../sessionHistory.js';
+import { t } from '../../i18n.js';
+import { readModelPref } from '../../modelPrefs.js';
+import { migratePresetPref, readPresetPref } from '../../presetPrefs.js';
+import { agentViewHasTurns } from '../agent-view.js';
+import { ensureLegacySessionEventTypes } from '../compat/index.js';
+import { snapshotLiveSessionEvents } from '../compat/liveSession.js';
+import { composePreset, resolvePersistedPreset, resolvePersistedRoute } from '../presets.js';
+import { attachSessionToWorkspace } from '../workspace.js';
+import { resetSessionProjection } from './session-reset.js';
+import { assertCapabilityShadowPolicy } from '../../adapter/kernel/runtime.js';
+/** Persisted-session and fresh-session foreground actions. */
+export function createSessionResumeActions(ctx, state, options, deps) {
+    const resetAndBind = (handle, agentPreset, route, replay) => {
+        resetSessionProjection(state, deps.rowIds, deps.resetProjector, deps.resetSubagents, deps.resetJobs);
+        state.status = handle.agent.status;
+        state.agentId = handle.agent.id;
+        state.agentPreset = agentPreset;
+        if (route !== undefined) {
+            state.provider = route.provider;
+            state.model = route.model;
+        }
+        state.loadedContext = undefined;
+        state.contextWindow = undefined;
+        state.effortLevels = undefined;
+        state.reasoningEffort = undefined;
+        if (replay) {
+            deps.replay(snapshotLiveSessionEvents(handle.agent.session));
+            deps.settleReplay();
+            // A resumed log can end mid-turn; mirror boot's post-replay status.
+            state.working = handle.agent.status === 'running';
+        }
+        deps.bindAgent();
+        deps.refreshCommands();
+        void deps.refreshLoadedContext();
+        void deps.refreshSkillCommands();
+    };
+    /** Resume a persisted session, optionally parking the attached agent for agent-view attachment. */
+    const resume = async (sessionId, kind, keepCurrent, adoption, entrySession) => {
+        const agents = ctx.get('agents');
+        if (!agents) {
+            deps.notify(t('resume-unavailable'), { color: 'error' });
+            return { ok: false, reason: 'unavailable' };
+        }
+        ensureLegacySessionEventTypes();
+        const composed = await composePreset(ctx, await resolvePersistedPreset(ctx, SessionId(sessionId)));
+        const explicitRoute = explicitModelRoute({ provider: options.configuredProvider, model: options.configuredModel });
+        const persistedRoute = await resolvePersistedRoute(ctx, SessionId(sessionId));
+        let handle;
+        try {
+            handle = await deps.binding.prepare(adoption, () => agents.resume({
+                resumeSessionId: SessionId(sessionId),
+                agentOptions: {
+                    provider: explicitRoute?.provider ?? persistedRoute?.provider,
+                    model: explicitRoute?.model ?? persistedRoute?.model,
+                },
+                ...(composed.setup === undefined ? {} : { setup: composed.setup }),
+            }));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            deps.notify(t('resume-failed', { err: message }), { color: 'error', timeoutMs: 8000 });
+            return { ok: false, reason: 'failed', error: message };
+        }
+        if (!deps.binding.isCurrent(adoption)) {
+            await deps.binding.abandon(handle);
+            return { ok: false, reason: 'cancelled' };
+        }
+        try {
+            await attachSessionToWorkspace(ctx, handle.agent.session.header.cwd ?? state.cwd, SessionId(sessionId));
+        }
+        catch (error) {
+            deps.notify(t('resume-attach-failed', { err: error instanceof Error ? error.message : String(error) }), { color: 'warning', timeoutMs: 8000 });
+        }
+        if (entrySession !== undefined && (!deps.owner.current() || deps.binding.agent.session !== entrySession)) {
+            await deps.binding.abandon(handle);
+            deps.notify(t('resume-session-changed'), { color: 'error' });
+            return { ok: false, reason: 'failed', error: 'live session changed during resume' };
+        }
+        return deps.binding.adopt(handle, adoption, (committed, disposePrevious) => {
+            const previousSessionId = String(committed.agent.session.id);
+            state.cwd = handle.agent.session.header.cwd ?? state.cwd;
+            state.displayCwd = deps.describeWorkspace(state.cwd).description ?? state.cwd;
+            deps.refreshGitBranch();
+            // Reset the input FIFO and pending-decision indicators BEFORE the first
+            // emit (main's bind → clear → refresh order); see the /new tail.
+            deps.clearStagedImages();
+            resetAndBind(handle, composed.agentPreset, explicitRoute ?? recordedModelRoute(snapshotLiveSessionEvents(handle.agent.session)), true);
+            writeResumeTarget(sessionId);
+            touchSession(sessionId);
+            state.emit();
+            const keepPrevious = keepCurrent && committed.handle !== undefined
+                && (committed.handle.agent.status === 'running' || agentViewHasTurns(snapshotLiveSessionEvents(committed.handle.agent.session)));
+            if (committed.handle !== undefined) {
+                if (keepPrevious) {
+                    deps.backgroundHandles.set(previousSessionId, committed.handle);
+                    disposePrevious('park');
+                }
+                else {
+                    disposePrevious('dispose');
+                }
+            }
+            if (kind === 'agent-view') {
+                touchAgentViewSession(sessionId);
+                touchAgentViewSession(previousSessionId);
+            }
+            deps.notifySessionSwitched(kind, sessionId, previousSessionId);
+            return { ok: true };
+        });
+    };
+    const resumeInto = (sessionId, kind, keepCurrent) => resume(sessionId, kind, keepCurrent, deps.binding.capture());
+    /** `/resume` keeps the entry capture across its veto/compaction awaits, so a rival switch cannot adopt over newer state. */
+    const resumeTo = async (sessionId) => {
+        const adoption = deps.binding.capture();
+        if (state.working) {
+            deps.notify(t('resume-while-working'), { color: 'warning' });
+            return { ok: false, reason: 'working' };
+        }
+        const agents = ctx.get('agents');
+        if (!agents) {
+            deps.notify(t('resume-unavailable'), { color: 'error' });
+            return { ok: false, reason: 'unavailable' };
+        }
+        if (await deps.sessionSwitchVetoed('resume', sessionId))
+            return { ok: false, reason: 'cancelled' };
+        await deps.settleCompaction();
+        const entrySession = deps.binding.agent.session;
+        return resume(sessionId, 'resume', false, adoption, entrySession);
+    };
+    const newSessionWithTarget = async (target) => {
+        // The typed workspace target seam still creates a real Agent/session; it
+        // must pass the same shadow policy gate as the public /new action.
+        assertCapabilityShadowPolicy('host.channel.actions.new-session', deps.runtime.mode, deps.runtime.slices);
+        const adoption = deps.binding.capture();
+        const targetCwd = target?.cwd ?? state.cwd;
+        const targetDisplayCwd = target?.displayCwd;
+        const current = () => deps.owner.current() && deps.binding.isCurrent(adoption);
+        if (state.working) {
+            deps.notify(t('new-session-while-working'), { color: 'warning' });
+            return false;
+        }
+        const agents = ctx.get('agents');
+        if (!agents) {
+            deps.notify(t('new-session-unavailable'), { color: 'error' });
+            return false;
+        }
+        let sessionId;
+        let composed;
+        let route;
+        try {
+            if (await deps.sessionSwitchVetoed('new') || !current())
+                return false;
+            await deps.settleCompaction();
+            if (!current())
+                return false;
+            sessionId = SessionId(randomUUID());
+            const presetPref = options.configuredPreset === undefined ? readPresetPref() : undefined;
+            composed = await composePreset(ctx, options.configuredPreset ?? presetPref);
+            if (!current())
+                return false;
+            const resolved = resolveModelRoute({ provider: options.configuredProvider, model: options.configuredModel }, readModelPref(), { provider: options.provider, model: options.model });
+            const llm = ctx.get('llm');
+            const validated = await validateModelRoute(llm, resolved, { provider: options.provider, model: options.model });
+            route = validated.route;
+            if (!current())
+                return false;
+            if (!migratePresetPref(presetPref, composed.agentPreset)) {
+                deps.notify(t('preset-switched-pref-failed', { id: composed.agentPreset ?? presetPref ?? 'unknown' }), { color: 'warning' });
+            }
+            if (validated.rejected !== undefined) {
+                deps.notify(t('model-route-invalid', { provider: validated.rejected.provider, model: validated.rejected.model, fallback: `${route.provider}/${route.model}` }), { color: 'warning', timeoutMs: 8000 });
+            }
+        }
+        catch (error) {
+            if (current()) {
+                const message = error instanceof Error ? error.message : String(error);
+                deps.notify(t('new-session-failed', { err: message }), { color: 'error', timeoutMs: 8000 });
+            }
+            return false;
+        }
+        let handle;
+        try {
+            handle = await deps.binding.prepare(adoption, () => agents.create({
+                sessionId,
+                meta: { cwd: targetCwd, ...(composed.agentPreset === undefined ? {} : { agentPreset: composed.agentPreset }) },
+                agentOptions: route,
+                ...(composed.setup === undefined ? {} : { setup: composed.setup }),
+            }));
+        }
+        catch (error) {
+            if (current()) {
+                const message = error instanceof Error ? error.message : String(error);
+                deps.notify(t('new-session-failed', { err: message }), { color: 'error', timeoutMs: 8000 });
+            }
+            return false;
+        }
+        if (!current()) {
+            await deps.binding.abandon(handle);
+            return false;
+        }
+        try {
+            await attachSessionToWorkspace(ctx, targetCwd, sessionId);
+        }
+        catch (error) {
+            if (current())
+                deps.notify(t('new-session-attach-failed', { err: error instanceof Error ? error.message : String(error) }), { color: 'warning', timeoutMs: 8000 });
+        }
+        if (!current()) {
+            await deps.binding.abandon(handle);
+            return false;
+        }
+        // Do not catch this synchronous commit tail. A post-commit setup failure
+        // is owned by binding.adopt(), which revokes the new live handle and must
+        // reject its caller rather than masquerade as an ordinary precommit false.
+        return deps.binding.adopt(handle, adoption, (committed, disposePrevious) => {
+            const previousSessionId = String(committed.agent.session.id);
+            // The target only becomes shared channel state inside the successful
+            // adoption tail. A losing prepared handle therefore cannot publish or
+            // roll back another workspace's cwd.
+            state.cwd = targetCwd;
+            state.displayCwd = targetDisplayCwd ?? deps.describeWorkspace(targetCwd).description ?? targetCwd;
+            // Reset the input FIFO and the pending-decision indicators BEFORE the
+            // first emit: a submit enqueued from a session-changed subscriber must
+            // land on a fresh chain instead of behind the replaced session's parked
+            // promise (main's bind → clear → refresh order).
+            deps.clearStagedImages();
+            resetAndBind(handle, composed.agentPreset, route, false);
+            clearResumeTarget();
+            touchSession(handle.agent.id);
+            disposePrevious('dispose');
+            deps.notifySessionSwitched('new', String(handle.agent.id), previousSessionId);
+            return true;
+        });
+    };
+    const newSession = () => newSessionWithTarget();
+    return { resumeInto, resumeTo, newSession, newSessionWithTarget };
+}

package/lib/types/dsh-adapter/channel/session-rewind.d.ts

@@ -0,0 +1,19 @@
+import type { AgentHandle } from '@deepseek-ai/dsh-agent';
+import type { Context } from '@deepseek-ai/cordis';
+import { SessionId, type SessionEvent } from '@deepseek-ai/dsh-session';
+import type { createChannelBinding } from './binding.js';
+import type { ChannelOwner } from './owner.js';
+import type { ChannelState, ChatRow } from './types.js';
+type Binding = ReturnType<typeof createChannelBinding>;
+type RewindState = Pick<ChannelState, 'working' | 'cwd' | 'provider' | 'model'>;
+/** Rewind a selected transcript row into a prepared, binding-owned fork. */
+export declare function createRewindToAction(ctx: Context, state: RewindState, deps: {
+    owner: Pick<ChannelOwner, 'current'>;
+    binding: Pick<Binding, 'agent' | 'capture' | 'prepare' | 'isCurrent' | 'abandon'>;
+    settleCompaction(): Promise<void>;
+    notify: ChannelState['notify'];
+    adoptForkedAgent(handle: AgentHandle, capture: ReturnType<Binding['capture']>, seed: readonly SessionEvent[], agentPreset: string | undefined, childId: SessionId): string;
+    notifySessionSwitched(kind: 'rewind', sessionId: string, previousSessionId: string): void;
+}): (row: ChatRow, mode?: string | null) => Promise<string | null>;
+export {};
+//# sourceMappingURL=session-rewind.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"session-rewind.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/session-rewind.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAsB,MAAM,wBAAwB,CAAA;AAC7E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,EAAE,SAAS,EAAE,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,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,YAAY,CAAA;AAEvD,KAAK,OAAO,GAAG,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAA;AACtD,KAAK,WAAW,GAAG,IAAI,CAAC,YAAY,EAAE,SAAS,GAAG,KAAK,GAAG,UAAU,GAAG,OAAO,CAAC,CAAA;AAgB/E,4EAA4E;AAC5E,wBAAgB,oBAAoB,CAClC,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,CAAC,CAAA;IACjF,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACjC,MAAM,EAAE,YAAY,CAAC,QAAQ,CAAC,CAAA;IAC9B,gBAAgB,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,UAAU,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,YAAY,EAAE,EAAE,WAAW,EAAE,MAAM,GAAG,SAAS,EAAE,OAAO,EAAE,SAAS,GAAG,MAAM,CAAA;IAC1K,qBAAqB,CAAC,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAA;CAC1F,IAEa,KAAK,OAAO,EAAE,OAAM,MAAM,GAAG,IAAW,KAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAwFhF"}