@deepseek-harness-tui/dsh-tui 0.8.1 → 0.8.2

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

@@ -26,7 +26,12 @@ import { t } from '../i18n.js';
 import { modeDisplayName, resolveSessionModes } from '../sessionModes.js';
 import { ActivityTracker } from 'dsh-working-activity/status';
 import { attachSessionToWorkspace } from './workspace.js';
-import { createLocalWorkspaceRuntime } from './workspaces.js';
+import { createLocalWorkspaceRuntime, getHostWorkspaceRuntime } from './workspaces.js';
+import { getHostCommandTrees } from './command-trees.js';
+import { getHostSettingsSections } from './settings-sections.js';
+import { getHostSceneRuntime } from './scenes.js';
+import { getHostRenderers } from './renderers.js';
+import { getHostMessageObserver } from './message-observer.js';
 import { dispatchTuiDecision, dispatchTuiNotification, normalizeCancelDecision } from './extension-events.js';
 import { installDecisionGuard } from './decision-guard.js';
 import { commandOwner } from './command-attribution.js';
@@ -155,12 +160,25 @@ function preview(text, limit) {
  * a loadOlder() restore is not instantly undone. Returns the number of rows
  * folded.
  */
-function foldRows(rows, cap) {
+function foldRows(rows, cap, cursor) {
     const excess = rows.length - cap;
-    if (excess <= 0)
+    if (excess <= 0) {
+        if (cursor !== undefined)
+            cursor.index = 0;
+        return 0;
+    }
+    // Incremental pass: rows only ever append past the fold line and the
+    // folded/restored exemptions are permanent, so everything below a cursor
+    // over the SAME array identity needs no re-inspection. emit/emitStream
+    // fold on every frame during streaming — a full rescan of a long window
+    // there was the O(rows) per-frame term of long-session streaming.
+    const from = cursor === undefined ? 0 : cursor.rows === rows ? cursor.index : 0;
+    if (cursor !== undefined)
+        cursor.rows = rows;
+    if (excess <= from)
         return 0;
     let folded = 0;
-    for (const row of rows.slice(0, excess)) {
+    for (const row of rows.slice(from, excess)) {
         if (row.folded || row.restored)
             continue;
         if (row.kind !== 'user' && row.kind !== 'assistant' && row.kind !== 'reasoning' && row.kind !== 'tool')
@@ -182,6 +200,8 @@ function foldRows(rows, cap) {
             row.text = preview(row.text, 200);
         }
     }
+    if (cursor !== undefined)
+        cursor.index = excess;
     return folded;
 }
 /**
@@ -310,46 +330,44 @@ function restoreToolResult(row, event) {
     row.tool.resultFull = result || undefined;
 }
 /**
- * Coalesce runs of same-type assistant/chunk deltas into single synthetic
- * events for REPLAY only. A streamed turn logs one event per token (~100k
- * events in long sessions); replaying them one at a time costs per-chunk
- * string growth on every row (quadratic in the turn's length). Merging is
- * outcome-identical: ensureStreaming/ensureReasoning only read chunk.type
- * and the concatenated text, and the row's seq comes from the run's FIRST
- * chunk (the fork boundary rewindTo derives from it). Parts join once —
- * no quadratic concat. Live events never go through this.
+ * Prepare durable events for REPLAY (resume / rewind / model-switch fork):
+ * drop settled `assistant/chunk` stream deltas — the sealed
+ * `assistant/message` events carry the full text and reasoning blocks, so
+ * per-token chunks add nothing to the replayed transcript while costing a
+ * per-chunk renderEvent pass (a real 4.5MB session logs ~19k chunks against
+ * ~30 messages). The trailing chunk run AFTER the last message belongs to an
+ * unfinished step (crash-orphaned turn) and is kept, so a resumed session
+ * still shows its partial content. Storage-level packed rows
+ * (`text-chunks`/`reasoning-chunks`/`tool-call-chunks`) are dropped the
+ * same way — defensive: the jsonl reader expands them, but a future
+ * direct-pass path must not resurrect them. Replay-side tps sampling is
+ * lost with the chunks (a live metric; lastUsage comes from the message's
+ * own usage). Live events never go through this.
  */
-function coalesceReplayEvents(events) {
-    const out = [];
-    let run = null;
-    const flush = () => {
-        if (run === null)
-            return;
-        const chunk = run.event.data.chunk;
-        out.push({
-            ...run.event,
-            data: { ...run.event.data, chunk: { ...chunk, text: run.parts.join('') } },
-        });
-        run = null;
-    };
+function prepareReplayEvents(events) {
+    let lastMessageSeq = -1;
     for (const event of events) {
-        if (event.type === 'assistant/chunk' &&
-            (event.data.chunk.type === 'text-delta' || event.data.chunk.type === 'reasoning-delta')) {
-            if (run !== null && run.type === event.data.chunk.type) {
-                // oxlint-disable-next-line typescript/no-unnecessary-condition -- durable replay data may lack text
-                run.parts.push(event.data.chunk.text ?? '');
-                continue;
-            }
-            flush();
-            // oxlint-disable-next-line typescript/no-unnecessary-condition -- durable replay data may lack text
-            run = { event, type: event.data.chunk.type, parts: [event.data.chunk.text ?? ''] };
-            continue;
-        }
-        flush();
-        out.push(event);
+        if (event.type === 'assistant/message')
+            lastMessageSeq = event.seq;
     }
-    flush();
-    return out;
+    return events.filter(event => {
+        if (event.type === 'assistant/message')
+            return true;
+        if (event.type === 'assistant/chunk') {
+            // Keep only the in-flight tail (no message sealed after it).
+            return lastMessageSeq < 0 || event.seq > lastMessageSeq;
+        }
+        // Storage-level packed rows: not in the SessionEvent union (they exist
+        // only in the durable JSON), so compare through a widened view — the
+        // defensive drop is exactly for data the static type doesn't know.
+        const packedType = event.type;
+        if (packedType === 'text-chunks' ||
+            packedType === 'reasoning-chunks' ||
+            packedType === 'tool-call-chunks') {
+            return false;
+        }
+        return true;
+    });
 }
 /** Buffer below the context window at which CC warns (autoCompact.ts). */
 const CONTEXT_WARNING_BUFFER_TOKENS = 20_000;
@@ -406,13 +424,13 @@ export function createChannel(ctx, initialAgent, options) {
     // messages.observe broker (optional service, C-042): mounted by the
     // dsh-tui-plugin-host row; absent the row, publish is a no-op and nothing
     // else changes (soft degradation, #183).
-    const messageObserver = ctx.get('tuiMessageObserver');
+    const messageObserver = getHostMessageObserver(ctx.get('tuiMessageObserver'));
     // Workspace registry runtime (optional service, issue #183): mounted by
     // the bundle patch's dsh-tui-workspaces row; absent the row (stale patch
     // or a bare embedder), degrade to the local-only runtime. plugin.ts owns
     // the degraded-boot warning for profile launches.
-    const workspaceService = ctx.get('tuiWorkspaces') ?? createLocalWorkspaceRuntime();
-    const commandTrees = ctx.get('tuiCommandTrees');
+    const workspaceService = getHostWorkspaceRuntime(ctx.get('tuiWorkspaces')) ?? createLocalWorkspaceRuntime();
+    const commandTrees = getHostCommandTrees(ctx.get('tuiCommandTrees'));
     // The `/settings` screen reads its host on EVERY render, so the host must
     // be a stable object: a fresh literal per call would re-fire the screen's
     // host-keyed effects endlessly (render → new host → effect → state →
@@ -423,11 +441,12 @@ export function createChannel(ctx, initialAgent, options) {
     // Plugin scene runtime (optional service, same degradation rule as
     // tuiWorkspaces/tuiCommandTrees): mounted by the bundle patch's
     // dsh-tui-scenes row; absent the row, `pluginScene` simply stays undefined.
-    const sceneRuntime = ctx.get('tuiScenes');
+    const sceneRuntime = getHostSceneRuntime(ctx.get('tuiScenes'));
+    const settingsSectionsRuntime = getHostSettingsSections(ctx.get('tuiSettingsSections'));
     // Custom-entry text renderers (optional service, dsh-tui-extensions row):
     // absent the row, unknown plugin event types stay invisible in the
     // transcript, exactly as before the seam existed.
-    const rendererRuntime = ctx.get('tuiRenderers');
+    const rendererRuntime = getHostRenderers(ctx.get('tuiRenderers'));
     // Shift+Tab session-mode cycle: cordis.yml `modes` wins; absent/empty/
     // atom-less → the built-in default/plan/full cycle (sessionModes.ts).
     const { modes: sessionModes, dropped: droppedModeIds } = resolveSessionModes(options.modes);
@@ -437,6 +456,9 @@ export function createChannel(ctx, initialAgent, options) {
     const listeners = new Set();
     /** True while a frame-aligned stream notification is pending (emitStream). */
     let streamNotifyScheduled = false;
+    // foldRows incremental cursor (see foldRows): rows only append past the
+    // fold line, so each pass touches only newly-eligible rows.
+    const foldCursor = { rows: null, index: 0 };
     let nextNotificationId = 1;
     /** One-shot context-low warning per session (CC's TokenWarning). */
     let contextWarned = false;
@@ -945,6 +967,7 @@ export function createChannel(ctx, initialAgent, options) {
         workingActivity: undefined,
         activityFrames: options.activityFrames,
         diffLayout: options.diffLayout ?? 'auto',
+        thinkingFold: options.thinkingFold ?? 'preview',
         activityEnabled: options.activity !== false,
         contextBarEnabled: options.contextBar !== false,
         agentPreset: options.agentPreset,
@@ -993,7 +1016,7 @@ export function createChannel(ctx, initialAgent, options) {
             };
         },
         emit() {
-            foldRows(state.rows, MAX_ROWS);
+            foldRows(state.rows, MAX_ROWS, foldCursor);
             state.version += 1;
             for (const listener of listeners)
                 listener();
@@ -1011,7 +1034,7 @@ export function createChannel(ctx, initialAgent, options) {
             streamNotifyScheduled = true;
             const timer = setTimeout(() => {
                 streamNotifyScheduled = false;
-                foldRows(state.rows, MAX_ROWS);
+                foldRows(state.rows, MAX_ROWS, foldCursor);
                 for (const listener of listeners)
                     listener();
             }, 16);
@@ -1280,6 +1303,10 @@ export function createChannel(ctx, initialAgent, options) {
             // counters land back at the rewind point, matching the fork).
             streaming = undefined;
             reasoning = undefined;
+            // Stale sealed/thinking bookkeeping belongs to the OLD agent's rows;
+            // keep it out of the next turn's settle logs and revive cache.
+            sealedReasoning.length = 0;
+            lastReasoningRow = undefined;
             toolCards.clear();
             nextRowId = 0;
             state.rows.length = 0;
@@ -1313,8 +1340,13 @@ export function createChannel(ctx, initialAgent, options) {
                 thinking: 0,
                 tools: 0,
             };
-            for (const event of coalesceReplayEvents(seed))
-                renderEvent(event);
+            replayEvents(seed);
+            settleStreaming();
+            // A seed ending mid-turn replays a turn/start that set working=true;
+            // the boot path resets this after replay — mirror it here so an idle
+            // rewound agent doesn't sit with a live spinner (a still-running
+            // agent re-asserts on its next event).
+            state.working = handle.agent.status === 'running';
             // Rebind subscriptions to the new agent, then free the old one.
             const oldHandle = currentHandle;
             const sourceSessionId = String(agent.session.id);
@@ -1373,18 +1405,18 @@ export function createChannel(ctx, initialAgent, options) {
             // resolving through DSH_TUI_RESUME_SESSION at boot).
             if (state.working) {
                 state.notify(t('resume-while-working'), { color: 'warning' });
-                return false;
+                return { ok: false, reason: 'working' };
             }
             const agents = ctx.get('agents');
             if (!agents) {
                 state.notify(t('resume-unavailable'), { color: 'error' });
-                return false;
+                return { ok: false, reason: 'unavailable' };
             }
             // Plugin veto point (tui/session-switch): before any read of the
             // target — a veto leaves the live session and its transcript
             // untouched.
             if (await sessionSwitchVetoed('resume', sessionId))
-                return false;
+                return { ok: false, reason: 'cancelled' };
             let handle;
             // Compat boundary: register vouched-for legacy event types (e.g.
             // activity/status from pre-#143 logs) in every reachable dsh-session
@@ -1415,7 +1447,7 @@ export function createChannel(ctx, initialAgent, options) {
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);
                 state.notify(t('resume-failed', { err: message }), { color: 'error', timeoutMs: 8000 });
-                return false;
+                return { ok: false, reason: 'failed', error: message };
             }
             try {
                 // `/resume` is an explicit adoption of this persisted conversation.
@@ -1430,6 +1462,10 @@ export function createChannel(ctx, initialAgent, options) {
             // rewindTo, plus the context window which the replay re-derives).
             streaming = undefined;
             reasoning = undefined;
+            // Stale sealed/thinking bookkeeping belongs to the OLD agent's rows;
+            // keep it out of the next turn's settle logs and revive cache.
+            sealedReasoning.length = 0;
+            lastReasoningRow = undefined;
             toolCards.clear();
             nextRowId = 0;
             state.rows.length = 0;
@@ -1482,9 +1518,12 @@ export function createChannel(ctx, initialAgent, options) {
                 thinking: 0,
                 tools: 0,
             };
-            for (const event of coalesceReplayEvents(handle.agent.session.events))
-                renderEvent(event);
+            replayEvents(handle.agent.session.events);
             settleStreaming();
+            // A log ending mid-turn replays a turn/start that set working=true;
+            // mirror the boot path's post-replay reset (a still-running agent
+            // re-asserts on its next event).
+            state.working = handle.agent.status === 'running';
             // Rebind subscriptions to the resumed agent, then free the old one.
             const oldHandle = currentHandle;
             const previousSessionId = String(agent.session.id);
@@ -1502,7 +1541,7 @@ export function createChannel(ctx, initialAgent, options) {
             void oldHandle?.dispose().catch(() => { });
             clearStagedImages();
             notifySessionSwitched('resume', sessionId, previousSessionId);
-            return true;
+            return { ok: true };
         },
         async newSession() {
             // `/new` — start a fresh conversation: brand-new agent + session, the
@@ -1579,6 +1618,10 @@ export function createChannel(ctx, initialAgent, options) {
             }
             streaming = undefined;
             reasoning = undefined;
+            // Stale sealed/thinking bookkeeping belongs to the OLD agent's rows;
+            // keep it out of the next turn's settle logs and revive cache.
+            sealedReasoning.length = 0;
+            lastReasoningRow = undefined;
             toolCards.clear();
             nextRowId = 0;
             state.rows.length = 0;
@@ -1752,6 +1795,10 @@ export function createChannel(ctx, initialAgent, options) {
             }
             streaming = undefined;
             reasoning = undefined;
+            // Stale sealed/thinking bookkeeping belongs to the OLD agent's rows;
+            // keep it out of the next turn's settle logs and revive cache.
+            sealedReasoning.length = 0;
+            lastReasoningRow = undefined;
             toolCards.clear();
             nextRowId = 0;
             state.rows.length = 0;
@@ -1788,9 +1835,10 @@ export function createChannel(ctx, initialAgent, options) {
                 thinking: 0,
                 tools: 0,
             };
-            for (const event of coalesceReplayEvents(seed))
-                renderEvent(event);
+            replayEvents(seed);
             settleStreaming();
+            // Same mid-turn-seed spinner reset as resume above.
+            state.working = handle.agent.status === 'running';
             const oldHandle = currentHandle;
             agent = handle.agent;
             currentHandle = handle;
@@ -1865,6 +1913,12 @@ export function createChannel(ctx, initialAgent, options) {
             state.diffLayout = layout;
             state.emit();
         },
+        setThinkingFold(mode) {
+            if (mode === state.thinkingFold)
+                return;
+            state.thinkingFold = mode;
+            state.emit();
+        },
         setActivityFrames(name) {
             if (!isPresetName(name)) {
                 state.notify(t('unknown-activity-preset', { name }), { color: 'error' });
@@ -2045,12 +2099,10 @@ export function createChannel(ctx, initialAgent, options) {
             return settingsHostCache;
         },
         settingsSections() {
-            const sections = ctx.get('tuiSettingsSections');
-            return sections?.list() ?? [];
+            return settingsSectionsRuntime?.list() ?? [];
         },
         subscribeSettingsSections(listener) {
-            const sections = ctx.get('tuiSettingsSections');
-            return sections?.subscribe(listener) ?? (() => { });
+            return settingsSectionsRuntime?.subscribe(listener) ?? (() => { });
         },
         providerSetup() {
             // The `/provider` wizard's runtime surface, over the dsh-base seams:
@@ -2995,16 +3047,60 @@ ${output}
         }
         return streaming;
     };
-    const ensureReasoning = (seq) => {
+    /** Latest reasoning row keyed by its (turn, step) — lets a resumed
+     *  mid-step stream REVIVE the row the replay sealed (crash-orphan tail:
+     *  replay folds the partial row, live continuation chunks would
+     *  otherwise open a SECOND row for the same step, splitting one
+     *  thinking block in two). */
+    let lastReasoningRow;
+    const ensureReasoning = (seq, turn, step) => {
         if (reasoning === undefined) {
+            // Same-step revive: the sealed row is this step's thinking — continue
+            // it (durationMs carried over via reasoningStart back-dating).
+            if (lastReasoningRow !== undefined &&
+                turn !== undefined &&
+                lastReasoningRow.turn === turn &&
+                lastReasoningRow.step === step) {
+                reasoning = lastReasoningRow.row;
+                reasoning.streaming = true;
+                const sealedIdx = sealedReasoning.indexOf(reasoning);
+                if (sealedIdx !== -1)
+                    sealedReasoning.splice(sealedIdx, 1);
+                reasoningStart = Date.now() - (reasoning.durationMs ?? 0);
+                logForDebugging('thinking: revived sealed reasoning row for same step');
+                return reasoning;
+            }
             reasoningStart = Date.now();
             reasoning = { id: nextRowId, kind: 'reasoning', text: '', streaming: true, ...seq !== undefined ? { seq } : {} };
             nextRowId += 1;
             state.rows.push(reasoning);
             logForDebugging('thinking: reasoning row open (expanded)');
         }
+        if (turn !== undefined && step !== undefined) {
+            lastReasoningRow = { row: reasoning, turn, step };
+        }
         return reasoning;
     };
+    /** Fold the live reasoning preview the moment the model moves PAST
+     *  thinking — the answer's first text token or a tool call — not at
+     *  `assistant/message` (end of step). A long reply pushes the thinking
+     *  block into terminal scrollback long before the message seals, and
+     *  scrollback rows cannot be repainted (the cursor cannot reach them),
+     *  so a late fold leaves a stale unfolded preview frozen above the
+     *  window — the user scrolls up and the thinking looks "not folded".
+     *  Folding while the block still sits in the live window keeps the
+     *  shrink inside the diff engine's reachable region. Preview mode only
+     *  (`full` holds every block open until turn settle by design). */
+    const foldLiveReasoning = (where) => {
+        if (reasoning === undefined || state.thinkingFold !== 'preview')
+            return;
+        const duration = Math.max(0, Date.now() - reasoningStart);
+        reasoning.durationMs = duration;
+        reasoning.streaming = false;
+        sealedReasoning.push(reasoning);
+        reasoning = undefined;
+        logForDebugging(`thinking: folded at ${where} (${duration}ms)`);
+    };
     const settleStreaming = () => {
         if (streaming !== undefined)
             streaming.streaming = false;
@@ -3070,6 +3166,24 @@ ${output}
             };
         }
     };
+    /** True while the durable transcript is being replayed (boot /resume /
+     *  rewind / model-switch fork). The assistant/message reasoning-rebuild
+     *  branch below must run ONLY on this path: in a live stream the chunks
+     *  already created the reasoning row, and foldLiveReasoning clears the
+     *  `reasoning` handle before assistant/message arrives — so
+     *  `reasoning === undefined` alone cannot tell replay from live, and
+     *  using it would rebuild a second thinking block per step. */
+    let replaying = false;
+    const replayEvents = (events) => {
+        replaying = true;
+        try {
+            for (const event of prepareReplayEvents(events))
+                renderEvent(event);
+        }
+        finally {
+            replaying = false;
+        }
+    };
     const renderEvent = (event) => {
         switch (event.type) {
             case 'user/message': {
@@ -3151,13 +3265,18 @@ ${output}
                 const chunk = event.data.chunk;
                 if (chunk.type === 'text-delta') {
                     if (chunk.text) {
+                        // Fold the thinking preview while it is still in the live
+                        // window (see foldLiveReasoning) — before this text grows the
+                        // transcript and pushes the block into scrollback.
+                        foldLiveReasoning('first text token');
                         ensureStreaming(event.seq).text += chunk.text;
                         state.responseChars += chunk.text.length;
                     }
                 }
                 else if (chunk.type === 'reasoning-delta') {
-                    if (chunk.text)
-                        ensureReasoning(event.seq).text += chunk.text;
+                    if (chunk.text) {
+                        ensureReasoning(event.seq, event.data.turn, event.data.step).text += chunk.text;
+                    }
                 }
                 const step = tpsStep;
                 if (step !== undefined &&
@@ -3178,6 +3297,30 @@ ${output}
             }
             case 'assistant/message': {
                 const text = textOf(event.data.message.content);
+                // Replay without chunk deltas (prepareReplayEvents drops settled
+                // ones): rebuild the reasoning row from the sealed message's
+                // reasoning blocks. Replay-only — gated on the `replaying` flag,
+                // not on `reasoning === undefined`: a live stream's chunks already
+                // created the row, and foldLiveReasoning has cleared the `reasoning`
+                // handle by the time this event lands, so the undefined check alone
+                // would rebuild a duplicate thinking block per step. Pushed BEFORE
+                // the assistant row so the transcript order matches the live
+                // stream; settled (folded) immediately, durationMs unknown without
+                // a live clock.
+                if (replaying && reasoning === undefined) {
+                    const reasoningText = event.data.message.content
+                        .map(block => (block.type === 'reasoning' ? block.text : ''))
+                        .join('');
+                    if (reasoningText !== '') {
+                        state.rows.push({
+                            id: nextRowId,
+                            kind: 'reasoning',
+                            text: reasoningText,
+                            seq: event.seq,
+                        });
+                        nextRowId += 1;
+                    }
+                }
                 // Reasoning/tool-only steps emit no text: creating an assistant row
                 // anyway leaves an empty `●` bullet in the transcript. A pre-existing
                 // streaming row always has text (ensureStreaming is only reached on
@@ -3191,10 +3334,16 @@ ${output}
                 }
                 streaming = undefined;
                 if (reasoning !== undefined) {
-                    // Seal, don't fold: the per-step duration settles here, but the
-                    // row keeps streaming=true (expanded) until turn/end — WebUI
-                    // keepOpen parity. The next step's reasoning opens a fresh row.
+                    // Backstop fold: reasoning whose step ended with no text token
+                    // and no tool call (foldLiveReasoning handles those earlier —
+                    // while the block is still in the repaintable live window;
+                    // here a long reply may already have pushed it into scrollback,
+                    // where the shrink cannot be repainted). `full` mode
+                    // (/settings opt-in) keeps the block expanded until turn settle
+                    // — settleStreaming folds the sealed rows then.
                     reasoning.durationMs = Math.max(0, Date.now() - reasoningStart);
+                    if (state.thinkingFold === 'preview')
+                        reasoning.streaming = false;
                     sealedReasoning.push(reasoning);
                     logForDebugging(`thinking: step sealed (${reasoning.durationMs}ms), expanded until turn/end`);
                 }
@@ -3263,6 +3412,10 @@ ${output}
                 // no card is a no-op below.
                 if (event.data.name === 'ask_user_question')
                     break;
+                // Reasoning that led to a tool call is done thinking — fold the
+                // preview now, before the tool card grows the transcript past it
+                // (see foldLiveReasoning).
+                foldLiveReasoning('tool call');
                 const card = {
                     id: nextRowId,
                     kind: 'tool',
@@ -3459,8 +3612,7 @@ ${output}
         }
     };
     // Replay the durable transcript first, then follow live events.
-    for (const event of coalesceReplayEvents(agent.session.events))
-        renderEvent(event);
+    replayEvents(agent.session.events);
     settleStreaming();
     // Attached to an idle agent: any replayed turn/start belongs to a previous
     // session run, so the spinner must not come up on boot.
@@ -3756,47 +3908,60 @@ function usageOutputTokens(usage) {
         : undefined;
 }
 /**
- * Recursive `@` file listing through the leaf's fs service (dsh-fs-local):
- * walks up to MAX_DEPTH levels below `root`, skipping VCS/dependency dirs,
- * returning relative paths (directories with a trailing `/`, matching the
- * FileSuggestions tag logic) capped at MAX_FILES entries. Best-effort —
- * unreadable subtrees are skipped, not fatal.
+ * `@` file listing through the leaf's fs service (dsh-fs-local): skips
+ * VCS/dependency/build dirs and rotates across directory listings so one
+ * large subtree cannot consume the global MAX_FILES budget. That budget also
+ * bounds directory reads without imposing an arbitrary source-tree depth.
+ * Relative directories retain the trailing `/` that FileSuggestions expects.
+ * Unreadable subtrees are skipped, not fatal.
  */
 async function listFilesDeep(fs, root) {
     if (!fs)
         return [];
     const out = [];
-    const SKIP = new Set(['node_modules', '.git', '.hg', '.svn', '.DS_Store', 'dist', 'build']);
-    const MAX_DEPTH = 3;
+    const SKIP = new Set(['node_modules', '.git', '.hg', '.svn', '.DS_Store', 'dist']);
+    const BUILD_DIR = /^(?:build(?:[-_].*)?|cmake-build(?:[-_].*)?)$/i;
     const MAX_FILES = 100;
-    const walk = async (dir, prefix, depth) => {
-        if (depth > MAX_DEPTH || out.length >= MAX_FILES)
-            return;
-        let entries = [];
-        try {
-            const target = await fs.resolve(dir);
-            entries = await fs.listDir(target);
-        }
-        catch {
-            return; // unreadable subtree — skip
+    const directories = [{ dir: root, prefix: '', index: 0 }];
+    while (directories.length > 0 && out.length < MAX_FILES) {
+        const current = directories.shift();
+        if (!current)
+            continue;
+        if (!current.entries) {
+            try {
+                const target = await fs.resolve(current.dir);
+                current.entries = await fs.listDir(target);
+            }
+            catch {
+                continue; // unreadable subtree — skip
+            }
         }
-        for (const entry of entries) {
-            if (out.length >= MAX_FILES)
-                return;
-            if (SKIP.has(entry.name))
+        let entry;
+        while (current.index < current.entries.length) {
+            const candidate = current.entries[current.index++];
+            if (SKIP.has(candidate.name) || BUILD_DIR.test(candidate.name))
                 continue;
-            const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
-            if (entry.type === 'directory') {
-                out.push(`${rel}/`);
+            entry = candidate;
+            break;
+        }
+        if (!entry)
+            continue;
+        if (current.index < current.entries.length)
+            directories.push(current);
+        const rel = current.prefix ? `${current.prefix}/${entry.name}` : entry.name;
+        if (entry.type === 'directory') {
+            out.push(`${rel}/`);
+            directories.push({
                 // oxlint-disable-next-line typescript/no-unnecessary-condition -- runtime guard: symlink targets optional
-                await walk(entry.target?.displayPath ?? join(dir, entry.name), rel, depth + 1);
-            }
-            else if (entry.type === 'file') {
-                out.push(rel);
-            }
+                dir: entry.target?.displayPath ?? join(current.dir, entry.name),
+                prefix: rel,
+                index: 0,
+            });
         }
-    };
-    await walk(root, '', 1);
+        else if (entry.type === 'file') {
+            out.push(rel);
+        }
+    }
     return out;
 }
 /** One attached file's contribution is capped so an absent-minded `@` of a

package/lib/types/dsh-adapter/childStderr.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"childStderr.d.ts","sourceRoot":"","sources":["../../../src/dsh-adapter/childStderr.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAsDH;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAAG,MAAM,IAAI,CA8BhF;AAED,0EAA0E;AAC1E,MAAM,WAAW,iBAAiB;IAChC,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,GAAG,SAAS,GAAG,SAAS,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAA;CAChG;AAED,MAAM,WAAW,0BAA0B;IACzC,qFAAqF;IACrF,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,8EAA8E;IAC9E,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,yFAAyF;IACzF,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB;AAED,MAAM,WAAW,mBAAmB;IAClC,gCAAgC;IAChC,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,iDAAiD;IACjD,OAAO,IAAI,IAAI,CAAA;CAChB;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,iBAAiB,EACzB,OAAO,GAAE,0BAA+B,GACvC,mBAAmB,CA4CrB"}
+{"version":3,"file":"childStderr.d.ts","sourceRoot":"","sources":["../../../src/dsh-adapter/childStderr.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAsDH;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAAG,MAAM,IAAI,CA8BhF;AAED,0EAA0E;AAC1E,MAAM,WAAW,iBAAiB;IAChC,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,GAAG,SAAS,GAAG,SAAS,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAA;CAChG;AAED,MAAM,WAAW,0BAA0B;IACzC,qFAAqF;IACrF,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,8EAA8E;IAC9E,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,yFAAyF;IACzF,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB;AAED,MAAM,WAAW,mBAAmB;IAClC,gCAAgC;IAChC,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,iDAAiD;IACjD,OAAO,IAAI,IAAI,CAAA;CAChB;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,iBAAiB,EACzB,OAAO,GAAE,0BAA+B,GACvC,mBAAmB,CAqDrB"}

package/lib/types/dsh-adapter/childStderr.js

@@ -145,6 +145,16 @@ export function createChildStderrReporter(notify, options = {}) {
                 // A burst inside the cooldown window is counted but stays silent.
                 if ((mutedUntil.get(line) ?? 0) > Date.now())
                     return;
+                // Prune expired cooldowns on the way in: entries are child-stderr
+                // lines and a long-lived MCP reconnect loop would otherwise grow the
+                // dedup table without bound.
+                if (mutedUntil.size > 64) {
+                    const now = Date.now();
+                    for (const [key, until] of mutedUntil) {
+                        if (until <= now)
+                            mutedUntil.delete(key);
+                    }
+                }
                 mutedUntil.set(line, Date.now() + cooldownMs);
                 const text = group.count > 1
                     ? t('child-stderr-line-repeat', { line, count: group.count })

package/lib/types/dsh-adapter/command-attribution.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"command-attribution.d.ts","sourceRoot":"","sources":["../../../src/dsh-adapter/command-attribution.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAA;AAExE,MAAM,WAAW,YAAY;IAC3B,WAAW,EAAE,MAAM,CAAA;IACnB,YAAY,EAAE,MAAM,CAAA;IACpB,SAAS,EAAE,MAAM,CAAA;CAClB;AASD;;4DAE4D;AAC5D,wBAAgB,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAQhD;AAYD,oFAAoF;AACpF,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,OAAO,EACZ,UAAU,EAAE,OAAO,EACnB,QAAQ,EAAE,yBAAyB,EACnC,SAAS,EAAE,MAAM,GAChB,IAAI,CAUN;AAED,yEAAyE;AACzE,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI,CAMjG;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,GAAG,YAAY,GAAG,SAAS,CAKxF"}
+{"version":3,"file":"command-attribution.d.ts","sourceRoot":"","sources":["../../../src/dsh-adapter/command-attribution.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAA;AAGxE,MAAM,WAAW,YAAY;IAC3B,WAAW,EAAE,MAAM,CAAA;IACnB,YAAY,EAAE,MAAM,CAAA;IACpB,SAAS,EAAE,MAAM,CAAA;CAClB;AAQD;;4DAE4D;AAC5D,wBAAgB,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAQhD;AAYD,oFAAoF;AACpF,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,OAAO,EACZ,UAAU,EAAE,OAAO,EACnB,QAAQ,EAAE,yBAAyB,EACnC,SAAS,EAAE,MAAM,GAChB,IAAI,CAUN;AAED,yEAAyE;AACzE,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI,CAMjG;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,GAAG,YAAY,GAAG,SAAS,CAKxF"}