@deepseek-harness-tui/dsh-tui 0.11.0 → 0.11.2

package/lib/types/screens/sessionSupervisor/useSessionSupervisor.js

@@ -17,7 +17,22 @@ import { t } from '../../i18n.js';
 import { normalizeWorkspaceCwd } from '../../sessions/view.js';
 import { readSessionPins, setSessionPinned } from '../../sessionPins.js';
 import { readSessionOwners } from '../../sessionMounts.js';
-import { RAIL_CHROME_ROWS, WORKSPACE_ROW_LINES, RAIL_MIN_TOTAL_COLUMNS, RAIL_WIDTH_MIN, RAIL_WIDTH_MAX, SESSION_ROW_LINES, SESSION_PANE_CHROME_ROWS, MENU_ACTIONS, UNREGISTERED_RAIL_ID, message, samePath, sessionMatchesQuery } from './model.js';
+import { resumeFailureText } from '../../sessions/resumeFailure.js';
+import { RAIL_CHROME_ROWS, WORKSPACE_ROW_LINES, RAIL_MIN_TOTAL_COLUMNS, RAIL_WIDTH_MIN, RAIL_WIDTH_MAX, SESSION_ROW_LINES, SESSION_PANE_CHROME_ROWS, noticeLines, MENU_ACTIONS, UNREGISTERED_RAIL_ID, message, samePath, sessionMatchesQuery } from './model.js';
+const listingSnapshots = new WeakMap();
+/**
+ * The snapshot slot for one channel, created on first use.
+ * @param channel - The screen's channel, which owns the rows.
+ * @returns The channel's slot, empty when it has never listed.
+ */
+function snapshotSlot(channel) {
+    let slot = listingSnapshots.get(channel);
+    if (slot === undefined) {
+        slot = { rows: undefined, requestGeneration: 0 };
+        listingSnapshots.set(channel, slot);
+    }
+    return slot;
+}
 /**
  * Derive the whole screen model.
  * @param input - Channel, home, the opening/stop actions and the live lookup.
@@ -26,8 +41,26 @@ import { RAIL_CHROME_ROWS, WORKSPACE_ROW_LINES, RAIL_MIN_TOTAL_COLUMNS, RAIL_WID
 export function useSessionSupervisor(input) {
     const { channel, home, onOpenSession, onNewSession, onStopSession, liveStateOf, columns, rows } = input;
     const [entries, setEntries] = useState([]);
-    const [sessions, setSessions] = useState([]);
-    const [loading, setLoading] = useState(true);
+    // Lazy so a non-empty snapshot from this channel's previous mount paints as
+    // the first frame, including after restart; undefined alone means unknown.
+    const [sessions, setSessions] = useState(() => {
+        const slot = snapshotSlot(channel);
+        // Recheck the provider's scope on every mount (including service replacement).
+        if (typeof channel.cachedSessions === 'function') {
+            try {
+                slot.rows = channel.cachedSessions();
+            }
+            catch {
+                slot.rows = undefined;
+            }
+        }
+        return slot.rows ?? [];
+    });
+    const [loading, setLoading] = useState(() => {
+        const snapshot = snapshotSlot(channel).rows;
+        return snapshot === undefined;
+    });
+    const [refreshing, setRefreshing] = useState(true);
     const [notice, setNotice] = useState(undefined);
     /** Live status and occupancy are re-read on their own clock, not the listing's. */
     const [pulse, setPulse] = useState(0);
@@ -219,6 +252,13 @@ export function useSessionSupervisor(input) {
      * this screen cannot work without, so it must survive a missing ledger.
      */
     const reload = useCallback(async () => {
+        // Claim this reload's generation before the first await: everything below
+        // only publishes while it is still the newest request, so a slower earlier
+        // one that lands later cannot repaint the screen (or the snapshot) with
+        // rows the newer listing has already corrected.
+        const slot = snapshotSlot(channel);
+        const generation = ++slot.requestGeneration;
+        setRefreshing(true);
         // The two reads are independent, and the session listing is the half this
         // screen cannot work without: a registry that rejects (bare composition,
         // unmounted service, a provider throwing) must not take the history down
@@ -227,10 +267,30 @@ export function useSessionSupervisor(input) {
         await Promise.all([
             (async () => {
                 try {
-                    setSessions(await channel.listSessions());
+                    const fresh = await channel.listSessions(enriched => {
+                        if (slot.requestGeneration !== generation)
+                            return;
+                        slot.rows = slot.rows?.map(row => row.id === enriched.id ? enriched : row);
+                        setSessions(current => current.map(row => row.id === enriched.id ? enriched : row));
+                    }, partial => {
+                        // Keep a complete cached list over a partial cold scan. With no
+                        // snapshot, show useful rows now rather than waiting for every log.
+                        if (slot.requestGeneration !== generation || slot.rows !== undefined)
+                            return;
+                        setSessions(partial);
+                        setLoading(false);
+                    });
+                    // Recorded only after success: a failed listing keeps the previous
+                    // snapshot, and only the newest reload may write it.
+                    if (slot.requestGeneration !== generation)
+                        return;
+                    slot.rows = fresh;
+                    setSessions(fresh);
                     setNotice(current => (current?.tone === 'error' ? undefined : current));
                 }
                 catch (error) {
+                    if (slot.requestGeneration !== generation)
+                        return;
                     setNotice({ text: t('home-sessions-failed', { err: message(error) }), tone: 'error' });
                 }
             })(),
@@ -239,20 +299,30 @@ export function useSessionSupervisor(input) {
                     const registry = typeof channel.listWorkspaceRegistry === 'function'
                         ? await channel.listWorkspaceRegistry()
                         : [];
+                    if (slot.requestGeneration !== generation)
+                        return;
                     setEntries(registry.map(entry => ({ ...entry, from: 'registry' })));
                 }
                 catch {
                     // An unreadable registry is not an empty history: the sessions stay
                     // listed (and resumable) under the cwd-derived fallback groups.
+                    if (slot.requestGeneration !== generation)
+                        return;
                     setEntries([]);
                 }
             })(),
         ]);
-        setLoading(false);
+        if (slot.requestGeneration === generation) {
+            setLoading(false);
+            setRefreshing(false);
+        }
     }, [channel]);
     React.useEffect(() => {
         void reload();
     }, [reload]);
+    React.useEffect(() => () => {
+        snapshotSlot(channel).requestGeneration++;
+    }, [channel]);
     // Selection follows the terminal's own directory, then the ledger: the rail
     // must open on the workspace this terminal is IN, not on whichever record
     // sorts first — otherwise launching in a workspace you have never opened
@@ -390,7 +460,16 @@ export function useSessionSupervisor(input) {
      * clipped the focused one out of the viewport.
      */
     const railEntryCapacity = Math.max(1, Math.floor(railListHeight / WORKSPACE_ROW_LINES));
-    const sessionListHeight = Math.max(SESSION_ROW_LINES, rows - SESSION_PANE_CHROME_ROWS);
+    /**
+     * The notice wraps (a mount refusal carries the adapter's full error), and
+     * every row it takes beyond its reserved one comes out of the list window —
+     * otherwise the list would overflow and clip the focused row instead.
+     */
+    // Wrapped to the VISIBLE width: below 20 columns the pane keeps its 20-cell
+    // floor and the renderer clips at the terminal edge, which would cut every
+    // notice row short of the reason it carries.
+    const noticeRows = noticeLines(notice?.text, Math.max(0, Math.min(sessionWidth, columns) - 3));
+    const sessionListHeight = Math.max(SESSION_ROW_LINES, rows - SESSION_PANE_CHROME_ROWS - (noticeRows.length - 1));
     const report = useCallback((text, tone) => {
         setNotice({ text, tone });
     }, []);
@@ -424,14 +503,16 @@ export function useSessionSupervisor(input) {
         }
         setNotice(undefined);
         void onOpenSession(session.id)
-            .then((ok) => {
-            // The host owns the REASON: it is the layer that saw the mount result
-            // (Chat renders the real refusal through `resumeFailureText` and a
-            // notification). This screen only names WHICH session could not be
-            // entered — a notice that restated the generic failure would compete
-            // with, and read worse than, the host's own sentence.
-            if (!ok)
-                report(t('supervisor-open-failed', { name: session.title.text }), 'error');
+            .then((result) => {
+            // The reason is shown HERE, not in a channel notification: this
+            // screen replaces the conversation, so the composer that draws
+            // notifications is not mounted and a "see below" pointer led nowhere.
+            // `cancelled` stays silent (the user or a rival switch asked for it).
+            // A plain failure shows the bare error: "Could not enter" already says
+            // resuming failed, and the rows it would repeat are the error's own.
+            const reason = !result.ok && result.reason === 'failed' ? result.error : resumeFailureText(result);
+            if (reason !== undefined)
+                report(t('supervisor-open-failed', { name: session.title.text, reason }), 'error');
         })
             .catch(error => report(t('session-resume-failed', { err: message(error) }), 'error'));
     }, [holderOf, onOpenSession, report]);
@@ -541,6 +622,7 @@ export function useSessionSupervisor(input) {
         entries,
         sessions,
         loading,
+        refreshing,
         notice,
         setNotice,
         query,
@@ -577,6 +659,7 @@ export function useSessionSupervisor(input) {
         sessionWidth,
         railEntryCapacity,
         sessionListHeight,
+        noticeRows,
         persistPin,
         selectEntry,
         openSession,

package/lib/types/sessionHistory.d.ts

@@ -16,8 +16,8 @@ export declare function readResumeTarget(): string | undefined;
  * `dsh --profile tui` boot path forwards these args to the booted app
  * verbatim and never parses them into DSH_TUI_RESUME_SESSION, so the
  * in-profile plugin reads them itself. A bare flag with no id defers to the
- * exit-time marker, exactly like the bin.
- * @param argv - the app arguments (typically `process.argv.slice(2)`).
+ * exit-time marker, exactly like the bin. An app-level `--` ends option parsing.
+ * @param argv - the app arguments from cmdlineArgs, after the host's own options.
  * @returns The requested session id, or undefined when none was given.
  */
 export declare function resumeTargetFromArgv(argv: readonly string[]): string | undefined;

package/lib/types/sessionHistory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sessionHistory.d.ts","sourceRoot":"","sources":["../../src/sessionHistory.ts"],"names":[],"mappings":"AA8BA;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAGzD;AAED,qEAAqE;AACrE,wBAAgB,iBAAiB,IAAI,IAAI,CAMxC;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,GAAG,SAAS,CAOrD;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,GAAG,SAAS,CAehF;AAED;;;GAGG;AACH,wBAAgB,YAAY,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAiB/D;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAQpD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAUrD;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAiBxE;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAQ7D;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAU9D"}
+{"version":3,"file":"sessionHistory.d.ts","sourceRoot":"","sources":["../../src/sessionHistory.ts"],"names":[],"mappings":"AAyCA;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAGzD;AAED,qEAAqE;AACrE,wBAAgB,iBAAiB,IAAI,IAAI,CAMxC;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,GAAG,SAAS,CAOrD;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,GAAG,SAAS,CAgBhF;AAED;;;GAGG;AACH,wBAAgB,YAAY,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAyB/D;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAUpD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAYrD;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAiBxE;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAQ7D;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAU9D"}

package/lib/types/sessionHistory.js

@@ -8,12 +8,23 @@
  * touches so `/resume` can sort most-recently-used first (DSH session
  * headers carry only `createdAt`).
  */
-import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { DATA_DIR } from './utils/paths.js';
 const DIR = DATA_DIR;
 const RESUME_FILE = join(DIR, 'resume.txt');
 const LAST_USED_FILE = join(DIR, 'last-used.json');
+let lastUsedStamp;
+let lastUsedCache;
+function lastUsedFileStamp() {
+    try {
+        const stats = statSync(LAST_USED_FILE);
+        return `${stats.dev}:${stats.ino}:${stats.size}:${stats.mtimeMs}:${stats.ctimeMs}`;
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * The agent view's OWN ledger: session-id → epoch-ms of the moments this TUI
  * dispatched, backgrounded, or attached to a session FROM the agent view.
@@ -61,13 +72,15 @@ export function readResumeTarget() {
  * `dsh --profile tui` boot path forwards these args to the booted app
  * verbatim and never parses them into DSH_TUI_RESUME_SESSION, so the
  * in-profile plugin reads them itself. A bare flag with no id defers to the
- * exit-time marker, exactly like the bin.
- * @param argv - the app arguments (typically `process.argv.slice(2)`).
+ * exit-time marker, exactly like the bin. An app-level `--` ends option parsing.
+ * @param argv - the app arguments from cmdlineArgs, after the host's own options.
  * @returns The requested session id, or undefined when none was given.
  */
 export function resumeTargetFromArgv(argv) {
     for (let i = 0; i < argv.length; i++) {
         const a = argv[i];
+        if (a === '--')
+            break;
         if (a === '--resume' || a === '-c' || a === '--continue' || a.startsWith('--resume=')) {
             let sessionId = '';
             if (a.startsWith('--resume=')) {
@@ -89,10 +102,15 @@ export function resumeTargetFromArgv(argv) {
  * @returns The parsed map; best effort, an unreadable file yields {}.
  */
 export function readLastUsed() {
+    const stamp = lastUsedFileStamp();
+    if (lastUsedCache !== undefined && lastUsedStamp === stamp)
+        return lastUsedCache;
     try {
         const parsed = JSON.parse(readFileSync(LAST_USED_FILE, 'utf8'));
         if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
-            return {};
+            lastUsedCache = {};
+            lastUsedStamp = stamp;
+            return lastUsedCache;
         }
         const record = parsed;
         const result = {};
@@ -101,10 +119,14 @@ export function readLastUsed() {
                 result[id] = value;
             }
         }
+        lastUsedCache = result;
+        lastUsedStamp = stamp;
         return result;
     }
     catch {
-        return {};
+        lastUsedCache = {};
+        lastUsedStamp = stamp;
+        return lastUsedCache;
     }
 }
 /**
@@ -117,6 +139,8 @@ export function touchSession(sessionId) {
         ensureDir();
         const lastUsed = { ...readLastUsed(), [sessionId]: Date.now() };
         writeFileSync(LAST_USED_FILE, JSON.stringify(lastUsed));
+        lastUsedCache = lastUsed;
+        lastUsedStamp = lastUsedFileStamp();
     }
     catch {
         // Best effort — MRU ordering is a nicety.
@@ -135,6 +159,8 @@ export function forgetSession(sessionId) {
         delete lastUsed[sessionId];
         ensureDir();
         writeFileSync(LAST_USED_FILE, JSON.stringify(lastUsed));
+        lastUsedCache = lastUsed;
+        lastUsedStamp = lastUsedFileStamp();
     }
     catch {
         // Best effort — a stale entry only skews sort order.