@deepseek-harness-tui/dsh-tui 0.13.0 → 0.14.0

package/lib/types/dsh-adapter/channel/core/sessions.js

@@ -0,0 +1,268 @@
+import { formatSessionRef } from '../../../agent/refs.js';
+import { t } from '../../../i18n.js';
+import { WORKING_GATE_NOTICES } from '../../../commands.js';
+import { occupancyOf, readSessionOwners } from '../../../sessionMounts.js';
+/** Preview text of a dry-run file restore (`3 files · +10 −2`). */
+function filesSummary(preview) {
+    const parts = [t('rewind-files-count', { n: preview.filesChanged.length })];
+    if (preview.insertions !== undefined || preview.deletions !== undefined)
+        parts.push(`+${preview.insertions ?? 0} −${preview.deletions ?? 0}`);
+    return parts.join(' · ');
+}
+const errorText = (error) => error instanceof Error ? error.message : String(error);
+export function createCoreSessionActions(deps) {
+    const { notify, unavailable } = deps;
+    const caps = () => deps.session().capabilities;
+    /** The last successful listing (the browser's first paint; may be stale). */
+    let cached;
+    const rowOf = (sessionId) => cached?.find(row => row.id === sessionId);
+    const isBound = (sessionId) => deps.session().ref.sessionId === sessionId;
+    const failed = (key, error) => {
+        if (deps.owner.current())
+            notify(t(key, { err: errorText(error) }), { color: 'error', timeoutMs: 8000 });
+    };
+    const delegates = {
+        cachedSessions: () => cached,
+        /**
+         * The bound backend's sessions: the working directory's first (painted
+         * at once through `onPartial`), then every project the backend knows,
+         * which the browser's rail groups by directory. A failing all-projects
+         * read keeps the directory's rows.
+         */
+        async listSessions(_onEnriched, onPartial) {
+            const catalog = deps.catalog;
+            if (catalog === undefined) {
+                unavailable('resume');
+                return [];
+            }
+            const local = await catalog.list({ cwd: deps.state().cwd });
+            onPartial?.(local);
+            let all;
+            try {
+                all = await catalog.list({ allProjects: true });
+            }
+            catch {
+                all = local;
+            }
+            const ids = new Set(all.map(row => row.id));
+            const merged = [...all, ...local.filter(row => !ids.has(row.id))].sort((a, b) => b.updatedAt - a.updatedAt);
+            cached = merged;
+            return merged;
+        },
+        async previewSession(sessionId) {
+            const preview = deps.catalog?.preview;
+            if (preview === undefined) {
+                unavailable('resume');
+                return [];
+            }
+            try {
+                const cwd = rowOf(sessionId)?.cwd;
+                return await preview(sessionId, { ...(cwd === undefined || cwd === '' ? {} : { cwd }) });
+            }
+            catch {
+                return [];
+            }
+        },
+        async renameSessionTo(sessionId, title) {
+            const rename = deps.catalog?.rename;
+            if (rename === undefined) {
+                unavailable('rename');
+                return false;
+            }
+            const next = title.trim();
+            if (next === '')
+                return false;
+            try {
+                await rename(sessionId, next, rowOf(sessionId)?.cwd);
+            }
+            catch (error) {
+                failed('rename-failed', error);
+                return false;
+            }
+            cached = cached?.map(row => row.id === sessionId ? { ...row, title: { text: next, source: 'renamed' } } : row);
+            if (isBound(sessionId) && deps.owner.current()) {
+                const state = deps.state();
+                state.sessionTitle = next;
+                state.emit();
+            }
+            return true;
+        },
+        /**
+         * Delete a stored session: never the bound one, and never one another
+         * TUI process has mounted (its transcript is being written). The MRU note
+         * and the launcher marker go with it.
+         */
+        async deleteSession(sessionId) {
+            const remove = deps.catalog?.delete;
+            if (remove === undefined) {
+                unavailable('resume');
+                return false;
+            }
+            if (isBound(sessionId))
+                return false;
+            const key = formatSessionRef({ backendId: deps.session().ref.backendId, sessionId });
+            const occupancy = occupancyOf(key, readSessionOwners());
+            if (occupancy.kind === 'occupied') {
+                notify(t('resume-session-occupied', { pid: occupancy.pid }), { color: 'error', timeoutMs: 8000 });
+                return false;
+            }
+            try {
+                await remove(sessionId, rowOf(sessionId)?.cwd);
+            }
+            catch (error) {
+                failed(deps.catalog?.deleteAction === 'archive' ? 'session-archive-failed' : 'session-delete-failed', error);
+                return false;
+            }
+            deps.prefs?.forget(sessionId);
+            cached = cached?.filter(row => row.id !== sessionId);
+            return true;
+        },
+        setResumeTarget(sessionId) {
+            if (deps.prefs === undefined) {
+                unavailable('resume');
+                return;
+            }
+            deps.prefs.setLastSession(sessionId);
+        },
+        async resumeTo(sessionId) {
+            if (!deps.canOpen) {
+                unavailable('resume');
+                return { ok: false, reason: 'unavailable' };
+            }
+            const result = await deps.resume(sessionId, 'resume');
+            if (result.ok)
+                deps.prefs?.setLastSession(sessionId);
+            return result;
+        },
+        /**
+         * `/fork`: a persisted copy of the bound session under a new id; the live
+         * session keeps running untouched (the DSH `/fork` semantics). The notice
+         * names how to enter the copy.
+         */
+        async forkSession() {
+            const fork = caps().fork;
+            if (fork === undefined) {
+                unavailable('fork');
+                return false;
+            }
+            if (deps.state().working) {
+                notify(t(WORKING_GATE_NOTICES.fork), { color: 'warning' });
+                return false;
+            }
+            let forked;
+            try {
+                forked = await fork.fork();
+            }
+            catch (error) {
+                failed('fork-failed', error);
+                return false;
+            }
+            if (!deps.owner.current())
+                return true;
+            const command = deps.resumeCommand?.(forked.sessionId) ?? `/resume ${forked.sessionId}`;
+            notify(t('fork-done', { id: forked.sessionId, command }), { timeoutMs: 8000 });
+            return true;
+        },
+        /**
+         * The double-Esc rewind: `files` restores the tracked files to their
+         * state at the picked message. The conversation rewind (the plain
+         * confirm, or `both` after the files) continues in the backend's fork cut
+         * just before that message, opened and adopted like a resume, and hands
+         * the picked message back for re-editing.
+         */
+        async rewindTo(row, mode = null) {
+            const rewind = caps().rewind;
+            if (rewind === undefined) {
+                unavailable('rewind');
+                return null;
+            }
+            if (row.anchor === undefined) {
+                notify(t('rewind-unanchored'), { color: 'warning', timeoutMs: 6000 });
+                return null;
+            }
+            if (deps.state().working) {
+                notify(t(WORKING_GATE_NOTICES.rewind), { color: 'warning' });
+                return null;
+            }
+            const kind = mode === 'files' ? 'files' : mode === 'both' ? 'both' : 'conversation';
+            const session = deps.session();
+            let outcome;
+            try {
+                outcome = await rewind.rewind(row.anchor, kind);
+            }
+            catch (error) {
+                failed('rewind-fork-failed', error);
+                return null;
+            }
+            if (!deps.owner.current())
+                return null;
+            if (outcome.kind === 'refused') {
+                notify(t('rewind-fork-failed', { err: outcome.reason }), { color: 'error', timeoutMs: 8000 });
+                return null;
+            }
+            if (outcome.files !== undefined)
+                notify(t('rewind-files-restored', { summary: filesSummary(outcome.files) }), { timeoutMs: 6000 });
+            if (outcome.conversationError !== undefined) {
+                // Half done: the files moved, the conversation did not.
+                notify(t('rewind-conversation-failed', { err: outcome.conversationError }), { color: 'warning', timeoutMs: 10000 });
+                return null;
+            }
+            if (kind === 'files' || outcome.session.sessionId === session.ref.sessionId)
+                return null;
+            const forkId = outcome.session.sessionId;
+            const forkKept = () => {
+                if (deps.owner.current()) {
+                    notify(t('rewind-fork-kept', { command: deps.resumeCommand?.(forkId) ?? `/resume ${forkId}` }), { color: 'warning', timeoutMs: 10000 });
+                }
+                return null;
+            };
+            // The fork is persisted whatever happens next, so a fork the channel
+            // does not adopt is named. The user may have moved to another session
+            // while the backend forked: that session stays.
+            if (deps.session() !== session)
+                return forkKept();
+            const adopted = await deps.resume(forkId, 'rewind');
+            if (!adopted.ok)
+                return forkKept();
+            return row.text;
+        },
+    };
+    /**
+     * The rewind confirm pane's choices: with a file restore available (a dry
+     * run reports changed files), "restore files" and "both" join the plain
+     * conversation rewind, each described by the dry run; otherwise the plain
+     * confirm. Plugin rewind modes (`tui/rewind-prompt`) are a DSH seam.
+     */
+    const promptRewind = async (row) => {
+        const rewind = caps().rewind;
+        if (rewind === undefined) {
+            unavailable('rewind');
+            return 'cancel';
+        }
+        if (row.anchor === undefined) {
+            notify(t('rewind-unanchored'), { color: 'warning', timeoutMs: 6000 });
+            return 'cancel';
+        }
+        if (rewind.preview === undefined)
+            return null;
+        let preview;
+        try {
+            preview = await rewind.preview(row.anchor);
+        }
+        catch {
+            // Nothing to restore (no checkpoint, or the files cannot be restored):
+            // the plain conversation rewind stays.
+            return null;
+        }
+        if (preview.filesChanged.length === 0)
+            return null;
+        const description = filesSummary(preview);
+        return {
+            modes: [
+                { id: 'both', label: t('rewind-mode-both'), description },
+                { id: 'files', label: t('rewind-mode-files'), description },
+            ],
+        };
+    };
+    return { delegates, promptRewind };
+}

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

@@ -1,4 +1,5 @@
 import type { TuiInputDecision, TuiRewindPromptDecision } from '../extension-events.js';
+import { NOTICE_CELLS } from '../sanitize.js';
 /** `tui/input` return normalization: transform/handled/cancel or no opinion.
  *  A blank `{ text }` rewrite is NOT a decision — it is logged and the chain
  *  continues so a later veto listener still runs. */
@@ -10,9 +11,9 @@ export declare function normalizeInputDecision(result: unknown, warn: (what: str
  *  Notices/reasons are toast-bound plugin text: sanitized too (see
  *  ./sanitize.js — the one implementation of the render-path contract). */
 export declare function normalizeRewindPromptDecision(result: unknown, warn: (what: string) => void): TuiRewindPromptDecision | undefined;
-/** Toast-bound plugin text (veto reasons, handled notices, rewind summaries)
- *  is render-path data too: same sanitization, toast-width cap. */
-export declare const NOTICE_CELLS = 200;
+/** Toast-width cap; defined beside the sanitizer it pairs with
+ *  (`src/channel/sanitize.ts`) and re-exported for existing importers. */
+export { NOTICE_CELLS };
 /** `tui/rewind-done` return normalization: the first non-empty STRING is the
  *  summary; anything else is not a decision. */
 export declare function normalizeRewindDoneSummary(result: unknown, warn: (what: string) => void): string | undefined;

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

@@ -1 +1 @@
-{"version":3,"file":"decisions.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/decisions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAEhB,uBAAuB,EACxB,MAAM,wBAAwB,CAAA;AAG/B;;qDAEqD;AACrD,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,OAAO,EACf,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAC3B,gBAAgB,GAAG,SAAS,CAwB9B;AAED;;;;;2EAK2E;AAC3E,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,OAAO,EACf,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAC3B,uBAAuB,GAAG,SAAS,CAkCrC;AAED;mEACmE;AACnE,eAAO,MAAM,YAAY,MAAM,CAAA;AAE/B;gDACgD;AAChD,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAAG,MAAM,GAAG,SAAS,CAQ5G"}
+{"version":3,"file":"decisions.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/decisions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAEhB,uBAAuB,EACxB,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EAAoC,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAE/E;;qDAEqD;AACrD,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,OAAO,EACf,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAC3B,gBAAgB,GAAG,SAAS,CAwB9B;AAED;;;;;2EAK2E;AAC3E,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,OAAO,EACf,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAC3B,uBAAuB,GAAG,SAAS,CAkCrC;AAED;0EAC0E;AAC1E,OAAO,EAAE,YAAY,EAAE,CAAA;AAEvB;gDACgD;AAChD,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAAG,MAAM,GAAG,SAAS,CAQ5G"}

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

@@ -1,4 +1,4 @@
-import { cleanRenderText, cleanScalarText } from '../sanitize.js';
+import { cleanRenderText, cleanScalarText, NOTICE_CELLS } from '../sanitize.js';
 /** `tui/input` return normalization: transform/handled/cancel or no opinion.
  *  A blank `{ text }` rewrite is NOT a decision — it is logged and the chain
  *  continues so a later veto listener still runs. */
@@ -73,9 +73,9 @@ export function normalizeRewindPromptDecision(result, warn) {
     warn('an unrecognized decision shape');
     return undefined;
 }
-/** Toast-bound plugin text (veto reasons, handled notices, rewind summaries)
- *  is render-path data too: same sanitization, toast-width cap. */
-export const NOTICE_CELLS = 200;
+/** Toast-width cap; defined beside the sanitizer it pairs with
+ *  (`src/channel/sanitize.ts`) and re-exported for existing importers. */
+export { NOTICE_CELLS };
 /** `tui/rewind-done` return normalization: the first non-empty STRING is the
  *  summary; anything else is not a decision. */
 export function normalizeRewindDoneSummary(result, warn) {

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

@@ -1,7 +1,20 @@
-import type { ChannelState } from './types.js';
+import type { ChannelState, ChatRow } from './types.js';
 export declare function createChannelEmitter(getState: () => Pick<ChannelState, 'rows' | 'version'>, 
 /** Returns true when the deferred projector changed renderer-visible data. */
-beforeStream: () => boolean): {
+beforeStream: () => boolean, options?: {
+    /**
+     * Fold rows past the transcript window (default on). Folding drops a
+     * row's full text on the promise that `loadOlder` restores it from the
+     * durable history; a session whose backend cannot slice its history
+     * keeps every row whole instead (and shows no "load earlier" divider).
+     * A function is read at every wake (the composition decides once its
+     * extension attached).
+     */
+    readonly fold?: boolean | (() => boolean);
+    /** Which rows the backend can restore (read at every fold pass);
+     *  absent = every foldable row. */
+    readonly restorable?: (row: ChatRow) => boolean;
+}): {
     subscribe(listener: () => void): () => void;
     emit(): void;
     emitStream(): void;

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

@@ -1 +1 @@
-{"version":3,"file":"emitter.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/emitter.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAE9C,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,MAAM,IAAI,CAAC,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;AACtD,8EAA8E;AAC9E,YAAY,EAAE,MAAM,OAAO;wBAmBL,MAAM,IAAI;;;;EAkCjC"}
+{"version":3,"file":"emitter.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/emitter.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,YAAY,CAAA;AAEvD,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,MAAM,IAAI,CAAC,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;AACtD,8EAA8E;AAC9E,YAAY,EAAE,MAAM,OAAO,EAC3B,OAAO,GAAE;IACP;;;;;;;OAOG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,GAAG,CAAC,MAAM,OAAO,CAAC,CAAA;IACzC;uCACmC;IACnC,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAA;CAC3C;wBAqBgB,MAAM,IAAI;;;;EAkCjC"}

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

@@ -3,9 +3,11 @@ import { swallowNestedUpdateOverflow } from '../../ink/update-overflow-guard.js'
 import { foldRows, MAX_ROWS } from './transcript.js';
 export function createChannelEmitter(getState, 
 /** Returns true when the deferred projector changed renderer-visible data. */
-beforeStream) {
+beforeStream, options = {}) {
+    const foldOption = options.fold;
+    const fold = typeof foldOption === 'function' ? foldOption : foldOption === false ? () => false : () => true;
     const listeners = new Set();
-    const foldCursor = { rows: undefined, index: 0 };
+    const foldCursor = { rows: undefined, index: 0, head: undefined };
     let timer;
     let disposed = false;
     const wake = (source) => {
@@ -13,7 +15,7 @@ beforeStream) {
         // Folding mutates retained transcript rows after a reader may have
         // cached the ingress revision. Publish that completed fold separately so
         // listeners cannot observe a stale or mixed same-version snapshot.
-        if (foldRows(state.rows, MAX_ROWS, foldCursor) > 0)
+        if (fold() && foldRows(state.rows, MAX_ROWS, foldCursor, options.restorable) > 0)
             state.version += 1;
         for (const listener of listeners) {
             try {

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

@@ -0,0 +1,36 @@
+/**
+ * The DSH extensions of the channel core: everything only a DSH session can
+ * serve, attached when the bound session carries `native.dsh`. The
+ * specialists live in their own modules; this file only wires them up.
+ *
+ * - transcript: the synchronous seed replay of the DSH log (subagent catalog
+ *   included), `/trace`, "load earlier" restored from the log, the DeepSeek
+ *   rate window for usage pricing, the job registry feed;
+ * - subagents and background jobs: projections, child listeners, controls;
+ * - sessions: `/resume`, `/home` and the agent view (MRU, background
+ *   sessions, `/bg`), rewind, the session tree, fork, the DSH `/new` create
+ *   path (preset, route, mount reservation, workspace ownership);
+ * - session metadata: recap and auto-recap on open, `/btw`, `/rename`,
+ *   `/color`, loaded context, skills, plugin (registry) commands;
+ * - controls: permission modes and presets, model / preset / effort, manual
+ *   compaction, the model-selection waterfalls and the child-route fill;
+ * - reports: `/doctor`, `/export` (from the log), `/mcp`, `/init`, `/balance`,
+ *   `/plugins`, `/login` credential descriptions.
+ *
+ * Construction order matters where it is observable: the job feed and
+ * pricing are installed before the seed replay, the replay runs before the
+ * model / mode actions read the replayed state, the child-route
+ * `agent/request` listener registers before the first bind's own, and the
+ * runtime starts keep their order around the core's host subscriptions.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { DshNative } from '../../agent/capabilities.js';
+import type { CoreChannel } from './core/compose.js';
+import { type ChannelLaunchOptions } from './state.js';
+/**
+ * Attach the DSH specialists to a core whose bound session is a DSH session.
+ * Called inside `createChannel`'s construction transaction: a throw here is
+ * rolled back by the caller through the core's owner.
+ */
+export declare function attachDshExtensions(core: CoreChannel, ctx: Context, initialNative: DshNative, options: ChannelLaunchOptions): void;
+//# sourceMappingURL=extensions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"extensions.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/extensions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAKlD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAA;AAoB5D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAyBpD,OAAO,EAAqB,KAAK,oBAAoB,EAAE,MAAM,YAAY,CAAA;AAoBzE;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,WAAW,EACjB,GAAG,EAAE,OAAO,EACZ,aAAa,EAAE,SAAS,EACxB,OAAO,EAAE,oBAAoB,GAC5B,IAAI,CA0qBN"}