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

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

@@ -0,0 +1,128 @@
+import { SessionId } from '@deepseek-ai/dsh-session';
+import { randomUUID } from 'node:crypto';
+import { t } from '../../i18n.js';
+import { liveSessionCreateOptions, liveSessionOffset, sliceLiveSessionSeed, snapshotLiveSessionEvents } from '../compat/index.js';
+import { dispatchTuiDecision } from '../extension-events.js';
+import { normalizeRewindDoneSummary } from './decisions.js';
+import { composePreset, runningPresetOf } from '../presets.js';
+import { attachSessionToWorkspace } from '../workspace.js';
+async function waitForTurnEnd(session, fromSeq, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const last = snapshotLiveSessionEvents(session).at(-1);
+        if (last !== undefined && last.type === 'turn/end' && last.seq >= fromSeq)
+            return true;
+        await new Promise(resolve => setTimeout(resolve, 200));
+    }
+    return false;
+}
+/** Rewind a selected transcript row into a prepared, binding-owned fork. */
+export function createRewindToAction(ctx, state, deps) {
+    return async (row, mode = null) => {
+        if (row.seq === undefined)
+            return null;
+        const adoption = deps.binding.capture();
+        const agents = ctx.get('agents');
+        if (!agents) {
+            deps.notify(t('rewind-unavailable'), { color: 'error' });
+            return null;
+        }
+        const wasWorking = state.working;
+        const cancelSeq = liveSessionOffset(deps.binding.agent.session);
+        if (wasWorking)
+            deps.binding.agent.cancel({ kind: 'user' });
+        if (wasWorking && !await waitForTurnEnd(deps.binding.agent.session, cancelSeq, 30000)) {
+            deps.notify(t('rewind-settling'), { color: 'error' });
+            return null;
+        }
+        await deps.settleCompaction();
+        const childId = SessionId(randomUUID());
+        const events = snapshotLiveSessionEvents(deps.binding.agent.session);
+        let boundary = row.seq;
+        for (let i = row.seq; i >= 0; i--) {
+            const event = events[i];
+            if (event === undefined)
+                break;
+            if (event.type === 'turn/start') {
+                boundary = event.seq - 1;
+                break;
+            }
+            if (event.type === 'turn/end')
+                break;
+        }
+        let seed;
+        try {
+            if (boundary < 0)
+                throw new Error('cannot rewind to the very first message');
+            // Slice the SOURCE snapshot through an inclusive seq. Never
+            // sessions.fork(): that registers a real child whose snapshot includes
+            // child-owned session/end-seed, so snapshot.length is not the inherited
+            // cut. agents.create owns the new session id.
+            seed = sliceLiveSessionSeed(deps.binding.agent.session, boundary);
+        }
+        catch (error) {
+            deps.notify(t('rewind-fork-failed', { err: error instanceof Error ? error.message : String(error) }), { color: 'error' });
+            return null;
+        }
+        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: state.provider, model: state.model },
+                setup: async (agentCtx, agent) => {
+                    // The cut keeps pre-turn inbox insertions but drops their claims.
+                    // Newer hosts replay those inherited splices, so cancel the restored
+                    // queue durably in the CHILD before publication or preset setup.
+                    // Clearing only state.pending would hide, not revoke, the old work.
+                    agent.inbox.clear();
+                    return composed.setup?.(agentCtx, agent);
+                },
+            })));
+        }
+        catch {
+            deps.notify(t('rewind-create-failed'), { color: 'error' });
+            return null;
+        }
+        if (!deps.binding.isCurrent(adoption)) {
+            await deps.binding.abandon(handle);
+            return null;
+        }
+        try {
+            await attachSessionToWorkspace(ctx, state.cwd, childId);
+        }
+        catch (error) {
+            deps.notify(t('rewind-attach-failed', { err: error instanceof Error ? error.message : String(error) }), { color: 'warning', timeoutMs: 8000 });
+        }
+        if (!deps.owner.current()) {
+            await deps.binding.abandon(handle);
+            return null;
+        }
+        const sourceSessionId = deps.adoptForkedAgent(handle, adoption, snapshotLiveSessionEvents(handle.agent.session), composed.agentPreset, childId);
+        try {
+            void dispatchTuiDecision(ctx, 'tui/rewind-done', {
+                text: row.text,
+                mode,
+                boundarySeq: boundary,
+                sourceSessionId,
+                childSessionId: String(childId),
+                sessionId: String(childId),
+                cwd: state.cwd,
+            }, normalizeRewindDoneSummary).then(summary => {
+                if (typeof summary === 'string')
+                    deps.notify(summary, { timeoutMs: 6000 });
+            }).catch((error) => ctx.logger.warn('dsh-tui: tui/rewind-done dispatch failed: %o', error));
+        }
+        catch (error) {
+            ctx.logger.warn('dsh-tui: tui/rewind-done dispatch failed: %o', error);
+        }
+        deps.notifySessionSwitched('rewind', String(childId), sourceSessionId);
+        return row.text;
+    };
+}

package/lib/types/dsh-adapter/channel/session-tree-actions.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 } from './types.js';
+type Binding = ReturnType<typeof createChannelBinding>;
+type TreeRewindState = Pick<ChannelState, 'working' | 'cwd' | 'provider' | 'model'>;
+/** Rewind or fork a selected tree node; loading foreign family logs stays in this persistence adapter seam. */
+export declare function createTreeRewindAction(ctx: Context, state: TreeRewindState, deps: {
+    owner: Pick<ChannelOwner, 'current'>;
+    binding: Pick<Binding, 'agent' | 'capture' | 'isCurrent' | 'prepare' | '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' | 'fork', sessionId: string, previousSessionId: string): void;
+}): (sessionId: string, seq: number, mode?: "rewind" | "fork") => Promise<string | null>;
+export {};
+//# sourceMappingURL=session-tree-actions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"session-tree-actions.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/session-tree-actions.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;AASvE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAA;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAE9C,KAAK,OAAO,GAAG,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAA;AACtD,KAAK,eAAe,GAAG,IAAI,CAAC,YAAY,EAAE,SAAS,GAAG,KAAK,GAAG,UAAU,GAAG,OAAO,CAAC,CAAA;AAYnF,+GAA+G;AAC/G,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,OAAO,EACZ,KAAK,EAAE,eAAe,EACtB,IAAI,EAAE;IACJ,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,SAAS,CAAC,CAAA;IACpC,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,GAAG,WAAW,GAAG,SAAS,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,GAAG,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAA;CACnG,IAEa,WAAW,MAAM,EAAE,KAAK,MAAM,EAAE,OAAM,QAAQ,GAAG,MAAiB,KAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CA4G1G"}

package/lib/types/dsh-adapter/channel/session-tree-actions.js

@@ -0,0 +1,138 @@
+import { SessionId } from '@deepseek-ai/dsh-session';
+import { randomUUID } from 'node:crypto';
+import { t } from '../../i18n.js';
+import { appendInterruptedTurnEnd, liveSessionCreateOptions, liveSessionOffset, snapshotLiveSessionEvents } from '../compat/index.js';
+import { readPersistedSession } from '../compat/persistence.js';
+import { closeLiveForkTurn } from '../compat/liveSession.js';
+import { composePreset, resolvePersistedPreset, runningPresetOf } from '../presets.js';
+import { attachSessionToWorkspace } from '../workspace.js';
+import { forkTarget, rewindTarget, turnUserText } from '../sessionTree.js';
+async function waitForTurnEnd(session, fromSeq, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const last = snapshotLiveSessionEvents(session).at(-1);
+        if (last !== undefined && last.type === 'turn/end' && last.seq >= fromSeq)
+            return true;
+        await new Promise(resolve => setTimeout(resolve, 200));
+    }
+    return false;
+}
+/** Rewind or fork a selected tree node; loading foreign family logs stays in this persistence adapter seam. */
+export function createTreeRewindAction(ctx, state, deps) {
+    return async (sessionId, seq, mode = 'rewind') => {
+        const adoption = deps.binding.capture();
+        const agents = ctx.get('agents');
+        if (!agents) {
+            deps.notify(t('rewind-unavailable'), { color: 'error' });
+            return null;
+        }
+        await deps.settleCompaction();
+        const entrySession = deps.binding.agent.session;
+        const currentId = String(entrySession.id);
+        const childId = SessionId(randomUUID());
+        let sourceEvents;
+        let sourceCwd = state.cwd;
+        let forkFromLive = true;
+        if (sessionId === currentId) {
+            sourceEvents = snapshotLiveSessionEvents(entrySession);
+        }
+        else {
+            forkFromLive = false;
+            const persistence = ctx.get('sessionPersistence');
+            if (!persistence || (typeof persistence.open !== 'function' && typeof persistence.load !== 'function')) {
+                deps.notify(t('rewind-no-persistence'), { color: 'error' });
+                return null;
+            }
+            try {
+                const loaded = await readPersistedSession(persistence, SessionId(sessionId));
+                sourceEvents = loaded.events;
+                sourceCwd = loaded.meta.cwd ?? state.cwd;
+            }
+            catch (error) {
+                deps.notify(t('rewind-load-failed', { err: error instanceof Error ? error.message : String(error) }), { color: 'error' });
+                return null;
+            }
+        }
+        const target = mode === 'fork' ? forkTarget(sourceEvents, seq) : rewindTarget(sourceEvents, seq);
+        if (target.boundary < 0) {
+            deps.notify(t('rewind-first-message'), { color: 'error' });
+            return null;
+        }
+        if (forkFromLive && !sourceEvents.some(event => event.seq > target.boundary && (event.type === 'user/message' || event.type === 'assistant/message' || event.type === 'tool/call' || event.type === 'tool/result'))) {
+            deps.notify(t('rewind-noop'), { color: 'warning' });
+            return null;
+        }
+        const restoredText = mode === 'fork' ? '' : turnUserText(sourceEvents, seq);
+        const sourcePreset = forkFromLive
+            ? runningPresetOf(entrySession)
+            : ((await resolvePersistedPreset(ctx, SessionId(sessionId))) ?? runningPresetOf(entrySession));
+        const composed = await composePreset(ctx, sourcePreset);
+        if (!deps.owner.current() || deps.binding.agent.session !== entrySession) {
+            deps.notify(t('rewind-session-changed'), { color: 'error' });
+            return null;
+        }
+        const wasWorking = state.working;
+        const cancelSeq = liveSessionOffset(deps.binding.agent.session);
+        if (wasWorking)
+            deps.binding.agent.cancel({ kind: 'user' });
+        if (wasWorking && !await waitForTurnEnd(deps.binding.agent.session, cancelSeq, 30000)) {
+            deps.notify(t('rewind-settling'), { color: 'error' });
+            return null;
+        }
+        const seed = sourceEvents.filter(event => event.seq <= target.boundary);
+        const inheritedCount = seed.length;
+        const closeAfterCreate = target.closeTurn !== undefined && entrySession.header?.version >= 3;
+        if (target.closeTurn !== undefined && !closeAfterCreate) {
+            appendInterruptedTurnEnd(seed, target.closeTurn);
+        }
+        let handle;
+        try {
+            handle = await deps.binding.prepare(adoption, () => agents.create(liveSessionCreateOptions({
+                sessionId: childId,
+                seed,
+                runtimeSession: entrySession,
+                inheritedCount,
+                cwd: sourceCwd,
+                parentSession: SessionId(sessionId),
+                agentPreset: composed.agentPreset,
+                agentOptions: { provider: state.provider, model: state.model },
+                setup: closeAfterCreate || mode === 'rewind' ? async (agentCtx, agent) => {
+                    // V3 requires seed.length === inheritedEventCount. The constructor
+                    // inserts the inherited marker, then these closers belong to the
+                    // child and persist before publication, without falsifying the cut.
+                    if (closeAfterCreate)
+                        closeLiveForkTurn(agent.session, target.closeTurn);
+                    // Re-editing starts with no historical pending work. Cancel through
+                    // the child's Inbox so a later resume cannot resurrect the queue.
+                    // A plain fork deliberately keeps its separate semantics.
+                    if (mode === 'rewind')
+                        agent.inbox.clear();
+                    return composed.setup?.(agentCtx, agent);
+                } : composed.setup,
+            })));
+        }
+        catch {
+            deps.notify(t('rewind-create-failed'), { color: 'error' });
+            return null;
+        }
+        if (!deps.binding.isCurrent(adoption)) {
+            await deps.binding.abandon(handle);
+            return null;
+        }
+        try {
+            await attachSessionToWorkspace(ctx, sourceCwd, childId);
+        }
+        catch (error) {
+            deps.notify(t('rewind-attach-failed', { err: error instanceof Error ? error.message : String(error) }), { color: 'warning', timeoutMs: 8000 });
+        }
+        if (!deps.owner.current() || deps.binding.agent.session !== entrySession) {
+            await deps.binding.abandon(handle);
+            deps.notify(t('rewind-session-changed'), { color: 'error' });
+            return null;
+        }
+        const replay = closeAfterCreate || mode === 'rewind' ? snapshotLiveSessionEvents(handle.agent.session) : seed;
+        const sourceSessionId = deps.adoptForkedAgent(handle, adoption, replay, composed.agentPreset, childId);
+        deps.notifySessionSwitched(mode === 'fork' ? 'fork' : 'rewind', String(childId), sourceSessionId);
+        return restoredText;
+    };
+}

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

@@ -0,0 +1,10 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import { type SessionTreeData } from '../sessionTree.js';
+import type { ChannelUi } from '../../adapter/ports/channel-ui.js';
+import type { ChannelOwner } from './owner.js';
+/** Bounded family-tree assembly owns budgets; binding remains the caller's authority. */
+export declare function createSessionTreeReader(ctx: Context, binding: {
+    readonly agent: Agent;
+}, cwd: () => string, notify: ChannelUi['notify'], owner: ChannelOwner): () => Promise<SessionTreeData | null>;
+//# sourceMappingURL=session-tree.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"session-tree.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/session-tree.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAA;AAenD,OAAO,EAAwD,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAC9G,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mCAAmC,CAAA;AAClE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAE9C,yFAAyF;AACzF,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE;IAAE,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;CAAE,EAAE,GAAG,EAAE,MAAM,MAAM,EAAE,MAAM,EAAE,SAAS,CAAC,QAAQ,CAAC,EAAE,KAAK,EAAE,YAAY,SAClI,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAiezD"}