@harness-nexus/cli 0.1.0-alpha.2 → 0.1.0-alpha.4

package/dist/daemon/chat.js

@@ -1,23 +1,230 @@
 import { randomUUID } from 'node:crypto';
-import { acpPermissionOptionSchema, acpToolCallViewSchema, chatPermissionRespondEventSchema, chatPromptEventSchema, chatSessionCloseEventSchema, chatSessionStartEventSchema, chatTurnCancelEventSchema, } from '@harness-nexus/shared';
+import { closeSync, fstatSync, openSync, readSync, readdirSync, readFileSync, statSync, } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { acpPermissionOptionSchema, acpToolCallViewSchema, chatConfigSetEventSchema, chatPermissionRespondEventSchema, chatPromptEventSchema, chatReconcileEventSchema, adaptersReportRequestSchema, chatSessionCloseEventSchema, chatSessionResyncEventSchema, chatSessionStartEventSchema, chatTurnCancelEventSchema, sessionConfigOptionSchema, sessionModeStateSchema, } from '@harness-nexus/shared';
 import { AcpAgentConnection } from './acp/agent-connection.js';
 import { resolveAcpCommand } from './acp/adapters.js';
+import { auditAdapterLedger, writeAdapterLedgerEntry } from './adapter-ledger.js';
+import { createDshLiveMapper, decodeTranscript, dshHistoryItems, findTranscript, nativeZstd, TranscriptTail, } from './dsh-sessions.js';
+import { TapListener, tapPluginAvailable, tapPluginPath, writeTapPatch, } from './dsh-tap-listener.js';
+const HISTORY_MAX = 2000;
+/** How long after arming the tap plugin may take to say hello (design: 3s). */
+const TAP_HANDSHAKE_MS = 3000;
+/**
+ * codex-acp's unknown-model notice (see `mapAcpUpdate`'s agent_message_chunk
+ * arm). Anchored on the stable prefix; the model id varies.
+ */
+const CODEX_MODEL_METADATA_NOTICE = /^Model metadata for `[^`]*` not found\./;
+/** Node fs surface for TranscriptTail. */
+const nodeTailFs = {
+    size(path) {
+        try {
+            return statSync(path).size;
+        }
+        catch {
+            return null;
+        }
+    },
+    readEnd(path, start) {
+        const fd = openSync(path, 'r');
+        try {
+            const len = fstatSync(fd).size - start;
+            if (len <= 0)
+                return Buffer.alloc(0);
+            const buf = Buffer.alloc(len);
+            readSync(fd, buf, 0, len, start);
+            return buf;
+        }
+        finally {
+            closeSync(fd);
+        }
+    },
+};
 export function attachChatHandlers(socket, opts = {}) {
     const env = opts.env ?? process.env;
+    const home = opts.homeDir ?? homedir();
     const sessions = new Map();
-    const emitEvent = (sessionId, event) => {
-        socket.emit('chat:event', { sessionId, event });
+    /**
+     * Ids whose `chat:session.close` arrived BEFORE the session registered. A
+     * close can race the establishment: the channel dies server-side (a fast row
+     * hop, a page exit) while the adapter is still spawning, so the close finds
+     * no session to tear down and used to be dropped — the establishment then
+     * finished and registered an orphan process nobody could ever close. The
+     * start handler consumes the id at its checkpoints and aborts instead.
+     */
+    const closedBeforeReady = new Set();
+    const CLOSED_BEFORE_READY_MAX = 64;
+    /**
+     * 9 W11 E — starts currently mid-establishment (spawn → registration).
+     * `chat:reconcile` reports these (when their id is still listed server-side)
+     * as held, and flags UNLISTED ones into `closedBeforeReady` so the
+     * establishment aborts — a row the server no longer knows must not finish
+     * into an unjoinable orphan.
+     */
+    const inFlightStarts = new Set();
+    const emitEvent = (session, event) => {
+        pushHistory(session, { type: 'event', event });
+        socket.emit('chat:event', { sessionId: session.sessionId, event });
+    };
+    const pushHistory = (session, item) => {
+        session.history.push(item);
+        if (session.history.length > HISTORY_MAX) {
+            session.history.splice(0, session.history.length - HISTORY_MAX);
+        }
+    };
+    const emitHistory = (session, items) => {
+        if (items.length === 0)
+            return;
+        for (const item of items)
+            pushHistory(session, item);
+        socket.emit('chat:history', {
+            sessionId: session.sessionId,
+            items: session.history.slice(-HISTORY_MAX),
+        });
+    };
+    /**
+     * 9 W9 A — emit the session's FULL merged config snapshot as a
+     * `session_config` stream event (into the ring and the live room). The
+     * browser's selectors settle exclusively through these events — the
+     * daemon-side optimistic merge after `chat:config.set` reuses this path.
+     */
+    const emitConfig = (session) => {
+        emitEvent(session, {
+            kind: 'session_config',
+            ...(session.config.modes !== undefined ? { modes: { ...session.config.modes } } : {}),
+            ...(session.config.options.length > 0 ? { configOptions: session.config.options } : {}),
+        });
     };
     const teardown = (session, reason) => {
         if (sessions.get(session.sessionId) !== session)
             return;
         sessions.delete(session.sessionId);
+        session.tail?.stop();
+        session.tap?.close();
         for (const [, p] of session.permissions)
             clearTimeout(p.timer);
         session.permissions.clear();
         session.conn.kill();
+        // 9 W11 A — the kill path does NOT unlink the ledger file: if the daemon
+        // hard-dies inside the SIGTERM→SIGKILL grace, an unlinked file would
+        // lose accounting (the group survives with no record). The audit below
+        // removes it once the group is gone.
         socket.emit('chat:session.closed', { sessionId: session.sessionId, reason });
     };
+    // 9 W11 A — periodic audit: the only runtime remover of ledger files
+    // (entries whose process group is gone), and the backstop for a session
+    // whose group died without the exit event reaching teardown.
+    const auditMs = opts.auditIntervalMs ?? 60_000;
+    if (auditMs > 0) {
+        const auditTimer = setInterval(() => {
+            auditAdapterLedger(home);
+            for (const session of [...sessions.values()]) {
+                if (!session.conn.isGroupAlive())
+                    teardown(session, 'agent-exited');
+            }
+        }, auditMs);
+        auditTimer.unref();
+    }
+    /**
+     * 9 W11 E — disconnect grace window. `HN_TEARDOWN_GRACE_MS` (default 8000;
+     * 0 restores the pre-W11 immediate teardown). Socket.IO reconnects from a
+     * transport blip within ~1s, so holding channels (and in-flight turns) for
+     * the window survives the blip; the server delays its offline reap by the
+     * same window and reconciles on reconnect.
+     */
+    const graceMs = (() => {
+        const raw = Number.parseInt(env.HN_TEARDOWN_GRACE_MS ?? '', 10);
+        return Number.isFinite(raw) ? Math.max(raw, 0) : 8000;
+    })();
+    let graceTimer = null;
+    // In-flight tail attachments by native session id (one per session).
+    const tailAttaches = new Map();
+    /**
+     * 9 W7.1 — arm the in-process dsh event tap BEFORE the spawn (the child
+     * needs the listener port/token in its env): render the spawn overlay into
+     * `~/.hnx/dsh-tap.patch.yml` and open the localhost listener the plugin
+     * dials. Null = not applicable (non-deepseek, `HN_DISABLE_DSH_TAP=1` A/B
+     * switch, assets missing, patch write or listen failure) — the transcript
+     * tail then streams exactly as before. The handshake races the spawn (the
+     * plugin loads during dsh's composition, i.e. typically before initialize
+     * resolves); no hello within the window → the caller closes the listener
+     * and falls through to the tail.
+     */
+    const armTap = (target) => {
+        if (target !== 'deepseek' || env.HN_DISABLE_DSH_TAP === '1')
+            return Promise.resolve(null);
+        if (!tapPluginAvailable())
+            return Promise.resolve(null);
+        const patchPath = writeTapPatch(home, tapPluginPath());
+        if (patchPath === null)
+            return Promise.resolve(null);
+        let sink = null;
+        let loss = null;
+        return TapListener.create({
+            onEvent: (sessionId, event) => sink?.(sessionId, event),
+            onLoss: () => loss?.(),
+        })
+            .then((listener) => ({
+            listener,
+            patchPath,
+            hello: listener.waitHello(Date.now() + TAP_HANDSHAKE_MS),
+            bind: (fnSink, fnLoss) => {
+                sink = fnSink;
+                loss = fnLoss;
+            },
+        }))
+            .catch(() => null);
+    };
+    /**
+     * dsh streaming — attach the transcript tail if it isn't live yet. Called
+     * at session ready AND at each prompt start: a NEW session's transcript is
+     * materialized lazily (the file appears only when the first prompt's user
+     * event flushes), so the ready-time attempt may legitimately find nothing.
+     * A late-attached tail misses the turn's first deltas — the mapper's
+     * committed fallback then emits the complete blocks, nothing is lost.
+     */
+    const ensureTail = (session) => {
+        // 9 W7.1 — the tap and the tail are mutually exclusive streaming
+        // sources: a live tap owns the session, and a DEAD one leaves it
+        // committed-only (a fresh tail mapper would double-render streamed steps).
+        if (session.target !== 'deepseek' || session.tail !== null)
+            return;
+        if (session.tap !== null || session.tapDead)
+            return;
+        if (tailAttaches.has(session.acpSessionId))
+            return;
+        const attach = (async () => {
+            let tailRef = null;
+            const tail = await attachTranscriptTail(home, session.acpSessionId, (event) => {
+                if (sessions.get(session.sessionId) === session)
+                    emitEvent(session, event);
+            }, (reason) => {
+                // Mid-file corruption: stop and lift the wire suppression so the
+                // adapter's committed chunks carry the rest of the turn (a partially
+                // streamed message may render once more — rare, never silent loss).
+                console.warn(`[chat] dsh ${reason} — falling back to committed updates`);
+                if (session.tail === tailRef)
+                    session.tail = null;
+            });
+            tailRef = tail;
+            if (tail !== null && session.tail === null && sessions.get(session.sessionId) === session) {
+                session.tail = tail;
+                // Byte-0 replay only for a NEW session whose file appeared mid-turn:
+                // it can hold nothing but the un-rendered in-flight turn (a resumed
+                // session's file pre-exists with rendered history; wire-rendered text
+                // likewise rules replay out — either way skip to EOF).
+                const replay = session.tailReplayEligible && !session.wireTextEmitted;
+                session.tailReplayEligible = false;
+                tail.start(replay);
+            }
+            else {
+                tail?.stop();
+            }
+        })().catch(() => { }); // attachment is best-effort; committed-only is the fallback
+        void attach.then(() => tailAttaches.delete(session.acpSessionId));
+        tailAttaches.set(session.acpSessionId, attach);
+    };
     // ---- server → daemon: spawn the channel ----
     socket.on('chat:session.start', (payload, ack) => {
         const parsed = chatSessionStartEventSchema.safeParse(payload);
@@ -26,8 +233,9 @@ export function attachChatHandlers(socket, opts = {}) {
             return;
         }
         ack?.({ accepted: true });
-        const { sessionId, target, cwd } = parsed.data;
+        const { sessionId, target, cwd, resume } = parsed.data;
         void (async () => {
+            inFlightStarts.add(sessionId);
             const cmd = resolveAcpCommand(target, env);
             if (cmd === null) {
                 socket.emit('chat:session.ready', {
@@ -36,41 +244,232 @@ export function attachChatHandlers(socket, opts = {}) {
                 });
                 return;
             }
+            // A failed establishment (resume model/cwd mismatch, "already active",
+            // the startup race giving up, initialize timeout) must NOT leave the
+            // spawned adapter running: the channel dies server-side, so nothing
+            // would ever kill it. Track the connection from spawn to outcome.
+            let liveConn = null;
+            // 9 W7.1 — arm the tap before the spawn (the child needs the port/token
+            // env); the spawn and the plugin's hello then race in parallel.
+            const tapArmed = await armTap(target);
+            // Consumes the id: true once the channel was closed while we were busy.
+            // Called at every checkpoint — a close that raced the establishment must
+            // not leave the spawned adapter behind with no channel to own it.
+            const abortIfClosed = () => {
+                if (!closedBeforeReady.delete(sessionId))
+                    return false;
+                tapArmed?.listener.close();
+                liveConn?.kill();
+                return true;
+            };
+            if (abortIfClosed())
+                return;
             try {
-                const { conn, agentInfo } = await AcpAgentConnection.start(cmd.command, cmd.args, {
+                // 9 W11 A — ledger the process group the moment it exists (inside
+                // start, right after the detached spawn and before initialize): a
+                // hard death during establishment still leaves a boot-sweepable
+                // record. The entry is re-written after registration with the native
+                // session id; removal is the audit's job, never a kill path.
+                const ledgerStartedAt = Date.now();
+                let ledgerPgid = null;
+                const onSpawned = (pgid) => {
+                    ledgerPgid = pgid;
+                    writeAdapterLedgerEntry(home, {
+                        pgid,
+                        target,
+                        command: cmd.command,
+                        wireSessionId: sessionId,
+                        startedAt: ledgerStartedAt,
+                    });
+                };
+                const spawnOpts = {
                     cwd,
-                    ...(opts.spawnEnv !== undefined ? { env: opts.spawnEnv } : {}),
-                });
-                const created = (await conn.request('session/new', { cwd }, 20000));
+                    onSpawned,
+                    ...(tapArmed === null
+                        ? opts.spawnEnv !== undefined
+                            ? { env: opts.spawnEnv }
+                            : {}
+                        : {
+                            env: {
+                                ...(opts.spawnEnv ?? {}),
+                                HNX_TAP_PORT: String(tapArmed.listener.port),
+                                HNX_TAP_TOKEN: tapArmed.listener.token,
+                            },
+                        }),
+                };
+                const args = tapArmed === null ? cmd.args : [...cmd.args, '--patch', tapArmed.patchPath];
+                let started;
+                let tapLive = false;
+                if (tapArmed === null) {
+                    started = await AcpAgentConnection.start(cmd.command, args, spawnOpts);
+                }
+                else {
+                    [started, tapLive] = await Promise.all([
+                        AcpAgentConnection.start(cmd.command, args, spawnOpts),
+                        tapArmed.hello,
+                    ]);
+                }
+                const { conn, agentInfo, sessionCaps, promptCaps } = started;
+                liveConn = conn;
+                // `mcpServers` is sent explicitly (spec: an array): ACP wrappers
+                // (zed 0.23.x AND the @agentclientprotocol one we ship for claude-code)
+                // zod-validate session establishment and reject an absent field with
+                // `Invalid params` — adapters are
+                // pulled latest by `npx -y`, so the client must be maximally
+                // spec-shaped. Startup race (seen on real dsh 0.1.2-rc.1): an
+                // establishment fired the instant initialize resolves can beat the
+                // agent's model-adapter REGISTRATION ("-32605 no adapter registered
+                // for provider …"). Retry that specific failure a few times.
+                let acpSessionId;
+                let history = [];
+                // 9 W9 A — the establishment response's session-config snapshot
+                // (modes + configOptions). Read from whichever arm established the
+                // session; null when the adapter advertised nothing (or only junk).
+                let establishedConfig = null;
+                if (resume === undefined) {
+                    const created = (await establish(conn, 'session/new', { cwd, mcpServers: [] }));
+                    acpSessionId = created?.sessionId ?? sessionId;
+                    establishedConfig = takeSessionConfig(created);
+                }
+                else {
+                    // 9 W7 — pick the method from the ADVERTISED capability: `load`
+                    // replays history (captured below), `resume` does not (dsh → we
+                    // parse its transcript file instead).
+                    if (sessionCaps.load) {
+                        const captured = [];
+                        const stopCapture = wireCapture(conn, captured);
+                        try {
+                            const loaded = (await establish(conn, 'session/load', {
+                                sessionId: resume.sessionId,
+                                cwd,
+                                mcpServers: [],
+                            }));
+                            acpSessionId = loaded?.sessionId ?? resume.sessionId;
+                            history = finishCaptured(captured);
+                            establishedConfig = takeSessionConfig(loaded);
+                        }
+                        finally {
+                            stopCapture();
+                        }
+                    }
+                    else if (sessionCaps.resume) {
+                        const resumed = (await establish(conn, 'session/resume', {
+                            sessionId: resume.sessionId,
+                            cwd,
+                            mcpServers: [],
+                        }));
+                        acpSessionId = resume.sessionId;
+                        establishedConfig = takeSessionConfig(resumed);
+                        history =
+                            target === 'deepseek' ? await dshTranscriptHistory(home, resume.sessionId) : [];
+                    }
+                    else {
+                        throw new Error(`ACP adapter for '${target}' supports no session resume`);
+                    }
+                }
+                // Registration is the point of no return: after it, `teardown` owns the
+                // connection. Re-check the close flag here — there is no await between
+                // this test and `sessions.set`, so no interleaving can slip past.
+                if (abortIfClosed())
+                    return;
                 const session = {
                     sessionId,
-                    acpSessionId: created?.sessionId ?? sessionId,
+                    acpSessionId,
+                    target,
+                    command: cmd.command,
+                    startedAt: ledgerStartedAt,
                     conn,
                     busy: false,
                     permissions: new Map(),
+                    config: establishedConfig ?? { options: [] },
+                    history: [],
+                    wireTextEmitted: false,
+                    tailReplayEligible: resume === undefined,
+                    tail: null,
+                    tap: null,
+                    tapMapper: null,
+                    tapTurnEndAt: 0,
+                    tapDead: false,
                 };
                 sessions.set(sessionId, session);
+                liveConn = null; // registered — teardown owns the connection from here
+                // 9 W11 A — enrich the ledger entry with the native session id (the
+                // adapter report in slice C and post-mortem forensics key off it).
+                if (ledgerPgid !== null) {
+                    writeAdapterLedgerEntry(home, {
+                        pgid: ledgerPgid,
+                        target,
+                        command: cmd.command,
+                        wireSessionId: sessionId,
+                        nativeSessionId: acpSessionId,
+                        startedAt: ledgerStartedAt,
+                    });
+                }
                 wireSession(session, emitEvent);
                 conn.onExit(() => {
                     // Crash/quit outside our control — end the channel honestly.
                     if (sessions.get(sessionId) === session)
                         teardown(session, 'agent-exited');
                 });
+                // 9 W7.1 — the tap won the handshake race: it IS the streaming
+                // source and the transcript tail never attaches. A lost race closes
+                // the listener (a late plugin hello finds a dead port and goes
+                // dormant) and ensureTail streams exactly as in W7.
+                if (tapArmed !== null) {
+                    if (tapLive) {
+                        session.tap = tapArmed.listener;
+                        session.tapMapper = createDshLiveMapper();
+                        tapArmed.bind((sid, busEvent) => {
+                            if (sessions.get(sessionId) !== session || sid !== session.acpSessionId)
+                                return;
+                            if (busEvent['type'] === 'turn/end')
+                                session.tapTurnEndAt = Date.now();
+                            for (const event of session.tapMapper?.(busEvent) ?? []) {
+                                emitEvent(session, event);
+                            }
+                        }, () => {
+                            if (sessions.get(sessionId) !== session)
+                                return;
+                            session.tap = null;
+                            session.tapMapper = null;
+                            session.tapDead = true;
+                            console.warn('[chat] dsh event tap lost — committed-only streaming for this session');
+                        });
+                    }
+                    else {
+                        tapArmed.listener.close();
+                    }
+                }
+                // dsh streaming: fire-and-forget the tail attach (a resume's file
+                // exists already; a new session's appears at first prompt — ensureTail
+                // re-runs then). Suppression is keyed off the live tail, never a
+                // pending attach, so it cannot be active without the tail.
+                ensureTail(session);
+                emitHistory(session, history);
+                // 9 W9 A — the authoritative config snapshot rides AFTER the replayed
+                // history (a load's replay patches settle first; last write wins) and
+                // enters the ring, so a resync restores the selectors.
+                if (establishedConfig !== null)
+                    emitConfig(session);
                 socket.emit('chat:session.ready', {
                     sessionId,
+                    nativeSessionId: acpSessionId,
                     ...(agentInfo.name !== undefined ? { agentName: agentInfo.name } : {}),
                     ...(agentInfo.version !== undefined ? { agentVersion: agentInfo.version } : {}),
+                    promptCapabilities: promptCaps,
                 });
             }
             catch (e) {
+                tapArmed?.listener.close();
+                liveConn?.kill();
                 socket.emit('chat:session.ready', {
                     sessionId,
                     error: e instanceof Error ? e.message : String(e),
                 });
             }
-        })();
+        })().finally(() => inFlightStarts.delete(sessionId));
     });
-    // ---- server → daemon: prompt / cancel / permission / close ----
+    // ---- server → daemon: prompt / cancel / permission / disconnect / resync ----
     socket.on('chat:message.send', (payload, ack) => {
         const parsed = chatPromptEventSchema.safeParse(payload);
         if (!parsed.success) {
@@ -84,12 +483,16 @@ export function attachChatHandlers(socket, opts = {}) {
         }
         if (session.busy) {
             // Lost the race against the server's busy gate — resync it.
-            emitEvent(session.sessionId, { kind: 'session_status', state: 'active' });
+            emitEvent(session, { kind: 'session_status', state: 'active' });
             ack?.({ error: 'session-busy' });
             return;
         }
         ack?.({ accepted: true });
-        void runPrompt(session, parsed.data.prompt, emitEvent, teardown);
+        // The history ring must know the user turn too — a resync rebuilds the
+        // fold from items alone (no optimistic browser echo on that path).
+        pushHistory(session, { type: 'user', blocks: parsed.data.prompt });
+        ensureTail(session); // lazy materialization: a new dsh file appears now
+        void runPrompt(session, parsed.data.prompt, emitEvent);
     });
     socket.on('chat:turn.cancel', (payload, ack) => {
         const parsed = chatTurnCancelEventSchema.safeParse(payload);
@@ -106,6 +509,44 @@ export function attachChatHandlers(socket, opts = {}) {
         // The pending session/prompt resolves as 'cancelled' → turn_result fires.
         void session.conn.request('session/cancel', {}, 5000).catch(() => { });
     });
+    // 9 W9 A — switch the live session's permission mode / one config option.
+    // NOT busy-gated: dsh pins the selection per PROMPT (a mid-turn set applies
+    // to the next turn) and the UI disables the selectors during a turn anyway.
+    socket.on('chat:config.set', (payload, ack) => {
+        const parsed = chatConfigSetEventSchema.safeParse(payload);
+        if (!parsed.success) {
+            ack?.({ error: 'proto:invalid' });
+            return;
+        }
+        const session = sessions.get(parsed.data.sessionId);
+        if (session === undefined) {
+            ack?.({ error: 'unknown-session' });
+            return;
+        }
+        const set = parsed.data;
+        const request = set.kind === 'mode' ? 'session/set_mode' : 'session/set_config_option';
+        const params = set.kind === 'mode'
+            ? { sessionId: session.acpSessionId, modeId: set.modeId }
+            : { sessionId: session.acpSessionId, configId: set.configId, value: set.value };
+        void session.conn.request(request, params, 15000).then(() => {
+            // Optimistic daemon-side merge: adapters confirm/correct through
+            // config pushes, but codex does not reliably push after a set —
+            // without this the selector would sit on the stale value.
+            if (set.kind === 'mode') {
+                session.config.modes = {
+                    currentModeId: set.modeId,
+                    availableModes: session.config.modes?.availableModes ?? [],
+                };
+            }
+            else {
+                session.config.options = session.config.options.map((o) => o.id === set.configId ? { ...o, currentValue: set.value } : o);
+            }
+            emitConfig(session);
+            ack?.({ accepted: true });
+        }, (e) => {
+            ack?.({ error: e instanceof Error ? e.message : String(e) });
+        });
+    });
     socket.on('chat:permission.respond', (payload, ack) => {
         const parsed = chatPermissionRespondEventSchema.safeParse(payload);
         if (!parsed.success) {
@@ -138,25 +579,258 @@ export function attachChatHandlers(socket, opts = {}) {
         }
         const session = sessions.get(parsed.data.sessionId);
         if (session !== undefined) {
-            // Best-effort session/close, then SIGTERM (kill is on a 3s grace).
+            // Best-effort session/close, then SIGTERM (kill is on a 3s grace). The
+            // AGENT's session survives this (9 W7) — only the subprocess ends.
             void session.conn.request('session/close', {}, 3000).catch(() => { });
             teardown(session, parsed.data.reason ?? 'user');
         }
+        else {
+            // Possibly mid-establishment — let the start handler abort. The reply is
+            // `{closed:true}` either way: the channel IS gone from the caller's view.
+            if (closedBeforeReady.size >= CLOSED_BEFORE_READY_MAX)
+                closedBeforeReady.clear();
+            closedBeforeReady.add(parsed.data.sessionId);
+        }
         ack?.({ closed: true });
     });
-    socket.on('disconnect', () => {
-        // No resume in v1 — every channel dies with the daemon's connection.
-        for (const session of [...sessions.values()])
-            teardown(session, 'daemon-disconnected');
+    // 9 W7 — a viewer (re)joined a live channel (page refresh): re-emit the
+    // history ring so the rebuilt fold shows what already happened.
+    socket.on('chat:session.resync', (payload, ack) => {
+        const parsed = chatSessionResyncEventSchema.safeParse(payload);
+        if (!parsed.success) {
+            ack?.({ error: 'proto:invalid' });
+            return;
+        }
+        const session = sessions.get(parsed.data.sessionId);
+        if (session !== undefined && session.history.length > 0) {
+            socket.emit('chat:history', {
+                sessionId: session.sessionId,
+                items: session.history.slice(-HISTORY_MAX),
+            });
+        }
+        ack?.({ accepted: true });
+    });
+    // 9 W11 C — the adapter report: present-tense process truth from the live
+    // sessions map (the LEDGER is crash accounting, not a status surface; a
+    // report built from it could list processes that already died). Instant by
+    // construction — no spawn, no round-trip beyond the socket.
+    socket.on('adapters:report', (payload, ack) => {
+        const parsed = adaptersReportRequestSchema.safeParse(payload);
+        if (!parsed.success) {
+            ack?.({ error: 'proto:invalid' });
+            return;
+        }
+        ack?.({ accepted: true });
+        socket.emit('adapters:report:result', {
+            requestId: parsed.data.requestId,
+            adapters: [...sessions.values()].map((s) => ({
+                wireSessionId: s.sessionId,
+                target: s.target,
+                pgid: s.conn.pgid ?? 0,
+                nativeSessionId: s.acpSessionId,
+                startedAt: s.startedAt,
+                command: s.command,
+            })),
+        });
+    });
+    // 9 W11 E — the server's live rows for this machine, sent on EVERY /ctl
+    // (re)connect. Drop what it disowned; report what we still hold.
+    socket.on('chat:reconcile', (payload, ack) => {
+        const parsed = chatReconcileEventSchema.safeParse(payload);
+        if (!parsed.success) {
+            ack?.({ error: 'proto:invalid' });
+            return;
+        }
+        const listed = new Set(parsed.data.sessionIds);
+        // A session whose row is gone server-side (reaped past the server's
+        // grace, or the server restarted) is unjoinable and invisible — no tab,
+        // no closer — tear it down now instead of leaking the adapter.
+        for (const session of [...sessions.values()]) {
+            if (!listed.has(session.sessionId))
+                teardown(session, 'reconciled');
+        }
+        // The same orphan risk exists MID-ESTABLISHMENT: flag unlisted starts so
+        // they abort at their checkpoints (the close-consume path).
+        for (const id of inFlightStarts) {
+            if (listed.has(id))
+                continue;
+            if (closedBeforeReady.size >= CLOSED_BEFORE_READY_MAX)
+                closedBeforeReady.clear();
+            closedBeforeReady.add(id);
+        }
+        // Held = registered sessions + establishments in flight for rows the
+        // server still knows (reporting an unlisted in-flight start as held
+        // would keep a ghost row alive).
+        const held = [...sessions.keys(), ...[...inFlightStarts].filter((id) => listed.has(id))];
+        ack?.({ held: held.slice(0, 64) });
+    });
+    // A reconnect within the grace window revives every channel: cancel the
+    // pending teardown BEFORE the server's reconcile lands (its list decides
+    // what survives; the grace only buys time for the reconnect itself).
+    socket.on('connect', () => {
+        if (graceTimer !== null) {
+            clearTimeout(graceTimer);
+            graceTimer = null;
+        }
+    });
+    socket.on('disconnect', (reason) => {
+        // 9 W11 E — a deliberate stop ('io client disconnect': SIGTERM → stop())
+        // or the kill-switch (HN_TEARDOWN_GRACE_MS=0) tears down immediately,
+        // exactly as before. A transport blip instead HOLDS every channel for
+        // the grace window: Socket.IO reconnects within ~1s, the server mirrors
+        // the grace on its reap, and a mid-grace turn keeps running against the
+        // local adapter (packets buffer; the viewer resyncs on rejoin).
+        if (graceMs <= 0 || reason === 'io client disconnect') {
+            if (graceTimer !== null) {
+                clearTimeout(graceTimer);
+                graceTimer = null;
+            }
+            for (const session of [...sessions.values()])
+                teardown(session, 'daemon-disconnected');
+            return;
+        }
+        if (graceTimer !== null)
+            return; // already armed by an earlier blip cycle
+        graceTimer = setTimeout(() => {
+            graceTimer = null;
+            for (const session of [...sessions.values()])
+                teardown(session, 'daemon-disconnected');
+        }, graceMs);
+        graceTimer.unref();
     });
 }
+/**
+ * Session establishment (`session/new` / `session/load` / `session/resume`)
+ * with a retry for the agent-startup registration race: a rejection
+ * mentioning "no adapter registered" is retried with a short backoff — the
+ * adapter finishes registering moments later.
+ */
+async function establish(conn, method, params, attempt = 1) {
+    try {
+        return await conn.request(method, params, 20000);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        if (attempt < 4 && /no adapter registered/i.test(msg)) {
+            await new Promise((r) => setTimeout(r, 600 * attempt));
+            return establish(conn, method, params, attempt + 1);
+        }
+        throw e;
+    }
+}
+/**
+ * Capture `session/update` notifications into `items` instead of emitting —
+ * used while `session/load` replays an agent's history (claude/codex replay
+ * BEFORE the load response resolves). `user_message_chunk` becomes a USER
+ * item (on the live path it is dropped as a browser echo); everything else
+ * maps through the ordinary update mapping. Returns the deactivation.
+ */
+function wireCapture(conn, items) {
+    const handler = (method, params) => {
+        if (method !== 'session/update')
+            return;
+        const update = (params.update ?? {});
+        if (update.sessionUpdate === 'user_message_chunk') {
+            const text = textOf(update.contentBlock) || textOf(update.content);
+            if (text !== '')
+                items.push({ type: 'user', blocks: [{ type: 'text', text }] });
+            return;
+        }
+        const mapped = mapAcpUpdate(params);
+        if (mapped !== null)
+            items.push({ type: 'event', event: mapped });
+    };
+    conn.setNotificationHandler(handler);
+    return () => conn.setNotificationHandler(() => { });
+}
+/** Close the captured batch: guarantee a trailing turn_result so the fold settles. */
+function finishCaptured(items) {
+    const last = items[items.length - 1];
+    if (last !== undefined && last.type === 'event' && last.event.kind !== 'turn_result') {
+        items.push({ type: 'event', event: { kind: 'turn_result', stopReason: 'end_turn' } });
+    }
+    return items;
+}
+/**
+ * dsh resume history — the adapter restores the log WITHOUT replaying, so the
+ * transcript file is the source. Best-effort by design: a missing/unreadable
+ * transcript (or no zstd on this Node) resumes WITHOUT history rather than
+ * failing the channel.
+ */
+async function dshTranscriptHistory(home, sessionId) {
+    try {
+        const root = join(home, '.dsh', 'sessions');
+        const zstd = nativeZstd();
+        if (zstd === null)
+            return [];
+        for (const slug of readdirSync(root)) {
+            const candidate = join(root, slug, sessionId, 'session.jsonl.zstd');
+            try {
+                return dshHistoryItems(decodeTranscript(readFileSync(candidate), zstd));
+            }
+            catch {
+                // not under this slug (or undecodable) — try the next
+            }
+        }
+        return [];
+    }
+    catch {
+        return [];
+    }
+}
 /** Hook ACP frames for one live session onto the semantic stream. */
 function wireSession(session, emitEvent) {
     const { conn } = session;
     conn.setNotificationHandler((method, params) => {
-        const mapped = method === 'session/update' ? mapAcpUpdate(params) : null;
-        if (mapped !== null)
-            emitEvent(session.sessionId, mapped);
+        if (method !== 'session/update')
+            return;
+        const update = (params.update ?? {});
+        // 9 W9 A — session-config pushes merge into the daemon's snapshot and
+        // re-emit it in full (needs the session state, so they are intercepted
+        // BEFORE the stateless mapping below).
+        if (update.sessionUpdate === 'current_mode_update') {
+            const modeId = typeof update.currentModeId === 'string' && update.currentModeId !== ''
+                ? update.currentModeId
+                : null;
+            if (modeId !== null) {
+                session.config.modes = {
+                    currentModeId: modeId,
+                    availableModes: session.config.modes?.availableModes ?? [],
+                };
+                emitEvent(session, { kind: 'session_config', modes: { ...session.config.modes } });
+            }
+            return;
+        }
+        if (update.sessionUpdate === 'config_option_update') {
+            const options = takeConfigOptions(update.configOptions);
+            if (options !== null) {
+                session.config.options = options;
+                emitEvent(session, { kind: 'session_config', configOptions: options });
+            }
+            return;
+        }
+        // dsh commits block-level text at turn end — while a streaming source is
+        // live (the transcript tail OR the 9 W7.1 event tap), its deltas already
+        // streamed this content AND its mapper emits the complete blocks for
+        // steps whose deltas it never saw, so the wire's committed chunk is
+        // redundant in every case; letting it through would double-render the
+        // message. Tools/usage still flow (idempotent by callId / field-merged).
+        if ((session.tail !== null || session.tap !== null) &&
+            (update.sessionUpdate === 'agent_message_chunk' ||
+                update.sessionUpdate === 'agent_thought_chunk')) {
+            return;
+        }
+        const mapped = mapAcpUpdate(params);
+        if (mapped !== null) {
+            if ((mapped.kind === 'message_delta' || mapped.kind === 'thought_delta') &&
+                session.tail === null &&
+                session.tap === null) {
+                // Committed text rendered through the wire — a FUTURE tail attach
+                // must skip the file's existing bytes (replaying would duplicate).
+                session.wireTextEmitted = true;
+            }
+            emitEvent(session, mapped);
+        }
     });
     conn.setPermissionHandler((jsonrpcId, params) => {
         const requestId = randomUUID();
@@ -165,14 +839,14 @@ function wireSession(session, emitEvent) {
             // guarantees the agent never waits forever even if the server is gone.
             session.permissions.delete(requestId);
             conn.respondPermission(jsonrpcId, { outcome: 'cancelled' });
-            emitEvent(session.sessionId, {
+            emitEvent(session, {
                 kind: 'permission_resolved',
                 requestId,
                 outcome: 'timeout',
             });
         }, 75000);
         session.permissions.set(requestId, { jsonrpcId, timer });
-        emitEvent(session.sessionId, {
+        emitEvent(session, {
             kind: 'permission_request',
             requestId,
             toolCall: toolCallView(params.toolCall),
@@ -180,9 +854,10 @@ function wireSession(session, emitEvent) {
         });
     });
 }
-async function runPrompt(session, prompt, emitEvent, teardown) {
+async function runPrompt(session, prompt, emitEvent) {
+    const promptStartedAt = Date.now();
     session.busy = true;
-    emitEvent(session.sessionId, { kind: 'session_status', state: 'active' });
+    emitEvent(session, { kind: 'session_status', state: 'active' });
     try {
         // No client-side timeout: a turn can legitimately run for minutes; the
         // recovery story is cancel or channel close, not a timer.
@@ -190,46 +865,171 @@ async function runPrompt(session, prompt, emitEvent, teardown) {
         const stopReason = ['end_turn', 'cancelled', 'max_tokens', 'refusal'].includes(result?.stopReason)
             ? result.stopReason
             : 'end_turn';
-        emitEvent(session.sessionId, { kind: 'turn_result', stopReason });
+        // dsh: the wire settles when the agent idles, but the streaming source's
+        // final bytes can land a beat LATER — the transcript's write-behind
+        // batch (tail) or the bus `turn/end` (tap — typically already there,
+        // the adapter derives its updates from committed session events).
+        // Emitting turn_result before them would render the message tail as a
+        // post-turn bubble (the fold opens a new step after turn_result). So
+        // drain, then wait briefly for the turn/end signal of whichever source
+        // is live.
+        if (session.tail !== null) {
+            session.tail.flush();
+            const deadline = Date.now() + 600;
+            while (session.tail !== null &&
+                !session.tail.turnEndSeenSince(promptStartedAt) &&
+                Date.now() < deadline) {
+                await new Promise((r) => setTimeout(r, 50));
+                session.tail?.flush();
+            }
+        }
+        else if (session.tap !== null) {
+            const deadline = Date.now() + 600;
+            while (session.tap !== null &&
+                session.tapTurnEndAt < promptStartedAt &&
+                Date.now() < deadline) {
+                await new Promise((r) => setTimeout(r, 25));
+            }
+        }
+        emitEvent(session, { kind: 'turn_result', stopReason });
     }
     catch (e) {
-        emitEvent(session.sessionId, {
+        // A rejected prompt is a TURN error (adapters answer protocol failures —
+        // "Authentication required", upstream API errors — through JSON-RPC
+        // errors while staying alive), not a dead subprocess. Real process death
+        // is conn.onExit's job. Surface the error, end the turn, keep the channel.
+        emitEvent(session, {
             kind: 'raw',
             method: 'hnx/prompt-error',
             params: { message: e instanceof Error ? e.message : String(e) },
         });
-        emitEvent(session.sessionId, { kind: 'turn_result', stopReason: 'end_turn' });
-        // The subprocess is unusable — end the channel honestly.
-        teardown(session, 'agent-exited');
-        return;
+        session.tail?.flush();
+        emitEvent(session, { kind: 'turn_result', stopReason: 'end_turn' });
     }
     finally {
         session.busy = false;
-        emitEvent(session.sessionId, { kind: 'session_status', state: 'idle' });
+        emitEvent(session, { kind: 'session_status', state: 'idle' });
+    }
+}
+/**
+ * Attach a dsh transcript tail (short retry — the file materializes with the
+ * session header at creation; write lag is the only window). Null = no tail
+ * (committed-only streaming — today's behavior).
+ */
+async function attachTranscriptTail(home, acpSessionId, onEvent, onFatal) {
+    const zstd = nativeZstd();
+    if (zstd === null)
+        return null;
+    const root = join(home, '.dsh', 'sessions');
+    for (let attempt = 0; attempt < 6; attempt++) {
+        const file = findTranscript(root, acpSessionId, (p) => readdirSync(p));
+        if (file !== null) {
+            return new TranscriptTail(file, nodeTailFs, zstd, onEvent, { onFatal });
+        }
+        await new Promise((r) => setTimeout(r, 200));
     }
+    return null;
+}
+/**
+ * 9 W9 A — validate an adapter's `configOptions` array down to the
+ * platform's bounded view: only `type:'select'` rows survive (the three
+ * shipped adapters expose mode/model/effort as selects; boolean options from
+ * future adapters are dropped rather than half-surfaced). Null = nothing
+ * usable in the payload.
+ */
+export function takeConfigOptions(raw) {
+    if (!Array.isArray(raw))
+        return null;
+    const out = [];
+    for (const row of raw) {
+        if (typeof row !== 'object' || row === null)
+            continue;
+        const r = row;
+        if (r['type'] !== undefined && r['type'] !== 'select')
+            continue;
+        const parsed = sessionConfigOptionSchema.safeParse(r);
+        if (parsed.success)
+            out.push(parsed.data);
+    }
+    return out.length > 0 ? out : null;
+}
+/**
+ * 9 W9 A — the session-config slice of an establishment response
+ * (`session/new` / `load` / `resume`): `modes` + `configOptions`, each
+ * independently validated. Null = the adapter advertised nothing usable.
+ */
+export function takeSessionConfig(result) {
+    const r = (result ?? {});
+    const modes = sessionModeStateSchema.safeParse(r['modes']);
+    const options = takeConfigOptions(r['configOptions']);
+    if (!modes.success && options === null)
+        return null;
+    return {
+        ...(modes.success ? { modes: modes.data } : {}),
+        options: options ?? [],
+    };
 }
 /** Map one ACP `session/update` params object; null = drop (user echo). */
 export function mapAcpUpdate(params) {
     const update = (params.update ?? {});
     switch (update.sessionUpdate) {
-        case 'agent_message_chunk':
-            return { kind: 'message_delta', delta: textOf(update.contentBlock) };
+        // 9 W9 A — config pushes on the CAPTURE path (session/load replay: no
+        // session state to merge into, so the adapter's patch maps verbatim).
+        case 'current_mode_update': {
+            const modeId = typeof update.currentModeId === 'string' && update.currentModeId !== ''
+                ? update.currentModeId
+                : null;
+            return modeId === null ? null : { kind: 'session_config', modes: { currentModeId: modeId } };
+        }
+        case 'config_option_update': {
+            const options = takeConfigOptions(update.configOptions);
+            return options === null ? null : { kind: 'session_config', configOptions: options };
+        }
+        case 'agent_message_chunk': {
+            const delta = chunkText(update);
+            // codex-acp announces an unknown gateway model id by streaming a
+            // diagnostic AS AN ASSISTANT CHUNK, so it lands mid-transcript as if the
+            // model had said it. It is not model output; drop it. (The underlying
+            // condition — codex's built-in registry not knowing the custom model id —
+            // is what makes it fall back to a default context window; a root-level
+            // `model_context_window` in config.toml overrides that window, verified
+            // against codex-acp 0.16, but does not silence this notice.)
+            return CODEX_MODEL_METADATA_NOTICE.test(delta) ? null : { kind: 'message_delta', delta };
+        }
         case 'agent_thought_chunk':
-            return { kind: 'thought_delta', delta: textOf(update.contentBlock) };
+            return { kind: 'thought_delta', delta: chunkText(update) };
         case 'tool_call':
-        case 'tool_call_update':
-            return { kind: 'tool_call', call: toolCallView(update.toolCallUpdate) };
+        case 'tool_call_update': {
+            // Claude adapters ride the registry key on the envelope's `_meta`.
+            const meta = (params._meta ?? null);
+            const cc = meta !== null && meta.claudeCode !== null && typeof meta.claudeCode === 'object'
+                ? meta.claudeCode
+                : null;
+            const metaToolName = cc !== null && typeof cc.toolName === 'string' && cc.toolName !== ''
+                ? cc.toolName
+                : undefined;
+            // Two dialects: Zed adapters nest under `toolCallUpdate`; dsh's native
+            // adapter spreads the fields FLAT on the update object.
+            return {
+                kind: 'tool_call',
+                call: toolCallView(update.toolCallUpdate ?? update, metaToolName),
+            };
+        }
         case 'usage_update': {
             const usage = (update.usage ?? {});
             return {
                 kind: 'usage',
                 ...(typeof usage.inputTokens === 'number' ? { inputTokens: usage.inputTokens } : {}),
                 ...(typeof usage.outputTokens === 'number' ? { outputTokens: usage.outputTokens } : {}),
+                // dsh reports context occupancy (`used` of `size`) instead of
+                // per-turn token counts.
+                ...(typeof update.used === 'number' ? { contextUsed: update.used } : {}),
+                ...(typeof update.size === 'number' ? { contextSize: update.size } : {}),
             };
         }
         case 'user_message_chunk':
-            // The browser echoes the user's message optimistically; there is no
-            // replay in v1, so a live echo would double-render.
+            // The browser echoes the user's message optimistically on the live
+            // path; history batches (capture mode) turn these into USER items.
             return null;
         default:
             return { kind: 'raw', method: 'session/update', params: update };
@@ -253,18 +1053,132 @@ export function textOf(contentBlock) {
             return '';
     }
 }
+/**
+ * Text of one message/thought chunk across the two adapter dialects: Zed
+ * adapters carry `contentBlock`; dsh's native ACP adapter carries `content`
+ * (a ContentBlock-shaped object without the wrapper name).
+ */
+function chunkText(update) {
+    const fromBlock = textOf(update.contentBlock);
+    if (fromBlock !== '')
+        return fromBlock;
+    return textOf(update.content);
+}
 /**
  * Defensive view of an ACP ToolCallUpdate: shared-schema-validated, falling
  * back to the bare id when an adapter sends something malformed (the server
  * re-validates everything crossing the wire).
+ *
+ * 9 W6 enrichment: carries `toolName` (the card registry key — from the
+ * update itself or the Claude `_meta.claudeCode.toolName` on the envelope),
+ * `rawInput` (dropped when oversized — Write-style file bodies), structured
+ * `content` (diff/text/terminal items), and the `rawOutput` text — the rich
+ * tool cards' rendering inputs.
  */
-export function toolCallView(toolCallUpdate) {
-    const parsed = acpToolCallViewSchema.safeParse(toolCallUpdate);
+export function toolCallView(toolCallUpdate, metaToolName) {
+    const t = (toolCallUpdate ?? {});
+    const parsed = acpToolCallViewSchema.safeParse(buildView(t, metaToolName));
     if (parsed.success)
         return parsed.data;
-    const t = (toolCallUpdate ?? {});
     return { toolCallId: String(t.toolCallId ?? 'unknown') };
 }
+const TOOL_KINDS = new Set([
+    'read',
+    'edit',
+    'delete',
+    'move',
+    'search',
+    'execute',
+    'think',
+    'fetch',
+    'switch_mode',
+    'other',
+]);
+/** Spec form is the short kind; some adapters send `readTool`-style variants. */
+function normalizeKind(raw) {
+    if (typeof raw !== 'string' || raw === '')
+        return undefined;
+    const k = raw.toLowerCase().replace(/tool$/, '');
+    return TOOL_KINDS.has(k) ? k : undefined;
+}
+const TOOL_STATUSES = new Set(['pending', 'in_progress', 'completed', 'failed']);
+function boundedString(raw, max) {
+    if (typeof raw !== 'string' || raw === '')
+        return undefined;
+    return raw.length <= max ? raw : raw.slice(0, max);
+}
+const RAW_INPUT_MAX = 32 * 1024;
+/** Field-by-field extraction with every bound enforced before the parse. */
+function buildView(t, metaToolName) {
+    const toolName = typeof t.toolName === 'string' && t.toolName !== ''
+        ? t.toolName
+        : typeof metaToolName === 'string' && metaToolName !== ''
+            ? metaToolName
+            : undefined;
+    let rawInput;
+    if (t.rawInput !== null && typeof t.rawInput === 'object' && !Array.isArray(t.rawInput)) {
+        const entries = Object.entries(t.rawInput).filter(([key]) => key.length <= 128);
+        try {
+            if (JSON.stringify(Object.fromEntries(entries)).length <= RAW_INPUT_MAX) {
+                rawInput = Object.fromEntries(entries);
+            }
+        }
+        catch {
+            rawInput = undefined; // unserializable values — drop rather than fail
+        }
+    }
+    let content;
+    if (Array.isArray(t.content)) {
+        content = t.content
+            .filter((c) => c !== null && typeof c === 'object')
+            .slice(0, 16)
+            .map((c) => ({
+            type: c.type,
+            ...(c.content !== null && typeof c.content === 'object' && !Array.isArray(c.content)
+                ? {
+                    content: {
+                        type: String(c.content.type ?? ''),
+                        ...('text' in c.content
+                            ? { text: boundedString(c.content.text, 100000) }
+                            : {}),
+                    },
+                }
+                : {}),
+            ...(typeof c.path === 'string' ? { path: boundedString(c.path, 1024) } : {}),
+            ...(typeof c.oldText === 'string' ? { oldText: boundedString(c.oldText, 100000) } : {}),
+            ...(typeof c.newText === 'string' ? { newText: boundedString(c.newText, 100000) } : {}),
+            ...(typeof c.terminalId === 'string'
+                ? { terminalId: boundedString(c.terminalId, 128) }
+                : {}),
+        }));
+    }
+    const locations = Array.isArray(t.locations)
+        ? t.locations
+            .filter((l) => l !== null && typeof l === 'object')
+            .slice(0, 16)
+            .map((l) => ({
+            path: String(l.path ?? ''),
+            ...(typeof l.line === 'number' ? { line: l.line } : {}),
+            ...(typeof l.lineEnd === 'number' ? { lineEnd: l.lineEnd } : {}),
+        }))
+            .filter((l) => l.path !== '')
+        : undefined;
+    return {
+        toolCallId: String(t.toolCallId ?? ''),
+        ...(typeof t.title === 'string' && t.title !== ''
+            ? { title: boundedString(t.title, 512) }
+            : {}),
+        ...(toolName !== undefined ? { toolName: boundedString(toolName, 128) } : {}),
+        ...(normalizeKind(t.kind) !== undefined ? { kind: normalizeKind(t.kind) } : {}),
+        ...(typeof t.status === 'string' && TOOL_STATUSES.has(t.status) ? { status: t.status } : {}),
+        ...(locations !== undefined && locations.length > 0 ? { locations } : {}),
+        ...(rawInput !== undefined ? { rawInput } : {}),
+        ...(content !== undefined ? { content } : {}),
+        ...(typeof t.rawOutput === 'string' && t.rawOutput !== ''
+            ? { output: boundedString(t.rawOutput, 100000) }
+            : {}),
+    };
+}
 /** Permission options, shared-schema-validated; malformed entries dropped. */
 function permissionOptions(options) {
     if (!Array.isArray(options))