sh3-core 0.15.0 → 0.15.2

package/dist/shell-shard/Terminal.svelte

@@ -1,6 +1,9 @@
 <script lang="ts">
   import { onMount, onDestroy, untrack } from 'svelte';
-  import { Scrollback } from './scrollback.svelte';
+  import { ModeBuffer } from './mode-buffer.svelte';
+  import { BufferStore } from './buffer-store';
+  import { applyReplayEvents } from './replay';
+  import { shortenCwd } from './display-cwd';
   import ScrollbackView from './ScrollbackView.svelte';
   import InputLine from './InputLine.svelte';
   import { SessionClient } from './session-client.svelte';
@@ -33,7 +36,24 @@
   }
   let { shell, wsUrl, userId, role, contributions }: Props = $props();
 
-  const scrollback = new Scrollback();
+  // Per-mode buffer map. Each ModeBuffer bundles a Scrollback + history +
+  // locked flag and is materialized lazily on first switch into that mode.
+  // ScrollbackView, InputLine, and dispatch all read from the active mode's
+  // buffer; switching mode rebinds without losing the previous buffer.
+  // BufferStore hydrates from the workspace zone on first access of each
+  // mode's buffer, restoring scrollback + history across page reloads (SH8).
+  const bufferStore = untrack(() => new BufferStore());
+  const buffers = new Map<string, ModeBuffer>();
+  function getBuffer(modeId: string): ModeBuffer {
+    let b = buffers.get(modeId);
+    if (!b) {
+      b = new ModeBuffer(modeId);
+      bufferStore.hydrate(b);
+      buffers.set(modeId, b);
+    }
+    return b;
+  }
+
   const resolver = new VerbRegistry();
   const fs = new TenantFsClient();
 
@@ -65,6 +85,7 @@
       requiresRole: d.requiresRole,
       transport: 'custom',
       autoRelocate: d.autoRelocate ?? false,
+      showCwd: d.showCwd ?? false,
     };
   }
 
@@ -95,6 +116,39 @@
     }),
   );
 
+  // Active-mode buffer derivation. Reads `mode.id` reactively so that
+  // mode-switch flips ScrollbackView and InputLine bindings in lockstep.
+  const currentBuffer = $derived(getBuffer(mode.id));
+
+  // Mirror the server's per-mode history bundle into each ModeBuffer.
+  // The bundle arrives on attach and re-arrives on each reconnect. We
+  // only overwrite a buffer's history when the server has more lines
+  // than the client — preserves optimistic appends made between submits
+  // and the server's authoritative reply.
+  $effect(() => {
+    for (const [modeId, lines] of Object.entries(session.historyByMode)) {
+      const buf = getBuffer(modeId);
+      if (buf.history.length < lines.length) {
+        buf.history = [...lines];
+      }
+    }
+  });
+
+  // Persist the active buffer on every meaningful change. The flush is
+  // debounced 200ms inside BufferStore, so a stream of stdout chunks
+  // results in a single zone write per quiescent moment. The bash
+  // buffer additionally stamps session.lastSeq so a page reload can ask
+  // the server for replay events newer than the persisted snapshot.
+  $effect(() => {
+    void currentBuffer.scrollback.entries.length;
+    void currentBuffer.history.length;
+    if (currentBuffer.modeId === 'bash') {
+      bufferStore.flush(currentBuffer, session.lastSeq);
+    } else {
+      bufferStore.flush(currentBuffer);
+    }
+  });
+
   function setMode(id: string): void {
     const next = visibleModes.find((m) => m.id === id);
     if (!next) return;
@@ -104,9 +158,6 @@
     cancelDispatch();
     mode = next;
     writeLastMode(userId, id);
-    if (next.transport !== 'ws') {
-      scrollback.push({ kind: 'status', text: 'mode switch: reload to take effect for server-shell changes', level: 'info', ts: Date.now() });
-    }
   }
 
   // If the active mode disappears (shard unloaded), fall back to sh3 — or
@@ -118,7 +169,7 @@
         const lostId = mode.id;
         mode = fallback;
         writeLastMode(userId, fallback.id);
-        scrollback.push({
+        getBuffer(fallback.id).scrollback.push({
           kind: 'status',
           text: `mode '${lostId}' is no longer available — switched to '${fallback.id}'`,
           level: 'warn',
@@ -143,6 +194,7 @@
       return true;
     },
     listModes: () => visibleModes.map((m) => ({ id: m.id, label: m.label })),
+    getMode: () => ({ id: mode.id, label: mode.label }),
   }));
 
   // wsUrl is a prop read at construction only. untrack prevents Svelte 5's
@@ -181,7 +233,7 @@
     mode: () => mode,
     role: () => role,
     resolver,
-    scrollback,
+    buffer: () => currentBuffer,
     session,
     shell: shellWithModes,
     fs,
@@ -190,8 +242,6 @@
     customMode: (id: string) => contributedModes.find((d) => d.id === id) ?? null,
   }));
 
-  let locked = $state(false);
-
   // ---------------------------------------------------------------------------
   // Auto-relocate: track the focused shard and update session.cwd when focus
   // changes to a shard whose documents directory exists. focusLocked and
@@ -265,18 +315,30 @@
   });
 
   function handleServerMessage(msg: ServerMessage) {
+    if (msg.t === 'replay') {
+      // Server's ring-buffer events between the last snapshot and now.
+      // Fold into the bash buffer using the same routing as live events.
+      applyReplayEvents(getBuffer('bash'), msg.events);
+      return;
+    }
     if (msg.t !== 'event') return;
     const e = msg.event;
+    // WS events always route to the bash buffer regardless of the active
+    // mode, so output keeps accumulating while the user is viewing sh3 or
+    // a custom mode. The bash buffer's locked flag tracks the running
+    // process; switching to a non-bash buffer naturally unlocks the input
+    // bar because each ModeBuffer carries its own locked state.
+    const bashBuf = getBuffer('bash');
     switch (e.kind) {
       case 'prompt':
-        scrollback.push({ kind: 'prompt', cwd: e.cwd, line: e.line, ts: e.ts });
-        locked = true;
+        bashBuf.scrollback.push({ kind: 'prompt', cwd: e.cwd, line: e.line, ts: e.ts });
+        bashBuf.locked = true;
         break;
       case 'stdout':
-        scrollback.push({ kind: 'text', stream: 'stdout', chunks: [e.data], ts: e.ts });
+        bashBuf.scrollback.push({ kind: 'text', stream: 'stdout', chunks: [e.data], ts: e.ts });
         break;
       case 'stderr':
-        scrollback.push({ kind: 'text', stream: 'stderr', chunks: [e.data], ts: e.ts });
+        bashBuf.scrollback.push({ kind: 'text', stream: 'stderr', chunks: [e.data], ts: e.ts });
         break;
       case 'exit':
         // Match real-shell UX: stay silent on clean exit. Only surface
@@ -284,7 +346,7 @@
         // processes (SIGINT, spawn errors, etc.). `code === null` with
         // no signal happens on clean close too — treat as success.
         if (e.signal || (e.code !== null && e.code !== 0)) {
-          scrollback.push({
+          bashBuf.scrollback.push({
             kind: 'status',
             text: e.signal
               ? `shell: process exited (${e.signal})`
@@ -293,10 +355,10 @@
             ts: e.ts,
           });
         }
-        locked = false;
+        bashBuf.locked = false;
         break;
       case 'status':
-        scrollback.push({ kind: 'status', text: e.text, level: e.level, ts: e.ts });
+        bashBuf.scrollback.push({ kind: 'status', text: e.text, level: e.level, ts: e.ts });
         break;
     }
   }
@@ -305,9 +367,18 @@
 
   onMount(() => {
     unsub = session.onMessage(handleServerMessage);
-    if (mode.transport === 'ws') {
-      session.connect();
+    // Pre-warm the bash buffer + seed lastSeq so the WS hello replays
+    // only events newer than the persisted snapshot. This closes the
+    // gap between last flush and reconnect on page reload.
+    getBuffer('bash');
+    const persistedSeq = bufferStore.readLastSeq('bash');
+    if (persistedSeq !== undefined) {
+      session.lastSeq = persistedSeq;
     }
+    // Always-connect: shell-shard is admin-gated, idle WS cost is
+    // negligible, and non-bash modes still need to log mode-tagged
+    // history server-side via history-log messages.
+    session.connect();
   });
 
   onDestroy(() => {
@@ -327,11 +398,12 @@
       'target-shard': { target: targetShard },
     }}
   />
-  <ScrollbackView {scrollback} />
+  <ScrollbackView showPromptCwd={mode.showCwd || false} scrollback={currentBuffer.scrollback} />
   <InputLine
-    cwd={session.cwd}
-    {locked}
-    history={session.history}
+    cwd={shortenCwd(session.cwd, session.tenantRoot)}
+    showCwd={mode.showCwd !== false}
+    locked={currentBuffer.locked}
+    history={currentBuffer.history}
     {session}
     onSubmit={dispatch}
   />

package/dist/shell-shard/buffer-store.d.ts

@@ -0,0 +1,15 @@
+import { ModeBuffer } from './mode-buffer.svelte';
+export declare class BufferStore {
+    private timers;
+    /** Restore a ModeBuffer's contents from the workspace zone, if any. */
+    hydrate(buffer: ModeBuffer): void;
+    /** Schedule a debounced write of the buffer's current state. */
+    flush(buffer: ModeBuffer, lastSeq?: number): void;
+    /** Force a synchronous write, bypassing debounce. Used on shard deactivate. */
+    forceFlush(buffer: ModeBuffer, lastSeq?: number): void;
+    /** Read the persisted lastSeq for a mode, if any. */
+    readLastSeq(modeId: string): number | undefined;
+    private write;
+    private toPersisted;
+    private toLive;
+}

package/dist/shell-shard/buffer-store.js

@@ -0,0 +1,124 @@
+/*
+ * BufferStore — serialize ModeBuffer state into the shell-shard's
+ * workspace zone with a 200ms debounce, cap at 500 entries per mode,
+ * and gracefully degrade non-serializable rich entries.
+ *
+ * Hydrate fills a fresh ModeBuffer from a previously-persisted snapshot.
+ * Flush schedules a debounced write of the buffer's current state. The
+ * bash buffer additionally carries a `lastSeq` cursor so the WS hello
+ * after reload can ask the server for replay events newer than the
+ * persisted snapshot.
+ */
+import { ModeBuffer } from './mode-buffer.svelte';
+import { readBuffer, writeBuffer, } from './buffer-zone-state.svelte';
+const PERSIST_CAP = 500;
+const DEBOUNCE_MS = 200;
+export class BufferStore {
+    constructor() {
+        this.timers = new Map();
+    }
+    /** Restore a ModeBuffer's contents from the workspace zone, if any. */
+    hydrate(buffer) {
+        const persisted = readBuffer(buffer.modeId);
+        if (!persisted)
+            return;
+        const live = [];
+        for (const p of persisted.entries) {
+            live.push(this.toLive(p));
+        }
+        // restore() splices in place AND bumps the module-scoped id counter past
+        // the restored max — without that bump, the next push() after a reload
+        // would mint an id colliding with a hydrated key and crash the keyed
+        // {#each} in ScrollbackView.
+        buffer.scrollback.restore(live);
+        buffer.history = [...persisted.history];
+    }
+    /** Schedule a debounced write of the buffer's current state. */
+    flush(buffer, lastSeq) {
+        const existing = this.timers.get(buffer.modeId);
+        if (existing)
+            clearTimeout(existing);
+        const timer = setTimeout(() => {
+            this.timers.delete(buffer.modeId);
+            this.write(buffer, lastSeq);
+        }, DEBOUNCE_MS);
+        this.timers.set(buffer.modeId, timer);
+    }
+    /** Force a synchronous write, bypassing debounce. Used on shard deactivate. */
+    forceFlush(buffer, lastSeq) {
+        const existing = this.timers.get(buffer.modeId);
+        if (existing) {
+            clearTimeout(existing);
+            this.timers.delete(buffer.modeId);
+        }
+        this.write(buffer, lastSeq);
+    }
+    /** Read the persisted lastSeq for a mode, if any. */
+    readLastSeq(modeId) {
+        var _a;
+        return (_a = readBuffer(modeId)) === null || _a === void 0 ? void 0 : _a.lastSeq;
+    }
+    write(buffer, lastSeq) {
+        const entries = buffer.scrollback.entries.slice(-PERSIST_CAP).map((e) => this.toPersisted(e));
+        const persisted = Object.assign({ entries, history: [...buffer.history] }, (lastSeq !== undefined ? { lastSeq } : {}));
+        writeBuffer(buffer.modeId, persisted);
+    }
+    toPersisted(e) {
+        if (e.kind === 'rich') {
+            const key = e.componentKey;
+            if (!key) {
+                return {
+                    id: e.id,
+                    kind: 'status',
+                    text: '<rich entry: not restorable (no componentKey)>',
+                    level: 'info',
+                    ts: e.ts,
+                };
+            }
+            try {
+                const propsJson = JSON.stringify(e.props);
+                return {
+                    id: e.id,
+                    kind: 'rich',
+                    componentKey: key,
+                    props: JSON.parse(propsJson),
+                    ts: e.ts,
+                };
+            }
+            catch (_a) {
+                return {
+                    id: e.id,
+                    kind: 'status',
+                    text: `<rich entry: ${key} not restorable>`,
+                    level: 'info',
+                    ts: e.ts,
+                };
+            }
+        }
+        if (e.kind === 'prompt')
+            return { id: e.id, kind: 'prompt', cwd: e.cwd, line: e.line, ts: e.ts };
+        if (e.kind === 'text')
+            return { id: e.id, kind: 'text', stream: e.stream, chunks: [...e.chunks], ts: e.ts };
+        return { id: e.id, kind: 'status', text: e.text, level: e.level, ts: e.ts };
+    }
+    toLive(p) {
+        if (p.kind === 'rich') {
+            // Component is recovered at render-time via lookupRichComponent in
+            // ScrollbackView. The live entry's `component` field is unused after
+            // hydration; pass an empty placeholder to satisfy the type.
+            return {
+                id: p.id,
+                kind: 'rich',
+                componentKey: p.componentKey,
+                component: undefined,
+                props: p.props,
+                ts: p.ts,
+            };
+        }
+        if (p.kind === 'prompt')
+            return { id: p.id, kind: 'prompt', cwd: p.cwd, line: p.line, ts: p.ts };
+        if (p.kind === 'text')
+            return { id: p.id, kind: 'text', stream: p.stream, chunks: [...p.chunks], ts: p.ts };
+        return { id: p.id, kind: 'status', text: p.text, level: p.level, ts: p.ts };
+    }
+}

package/dist/shell-shard/buffer-store.svelte.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/shell-shard/buffer-store.svelte.test.js

@@ -0,0 +1,107 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { __resetForTests as resetZone, readBuffer, writeBuffer, } from './buffer-zone-state.svelte';
+import { BufferStore } from './buffer-store';
+import { ModeBuffer } from './mode-buffer.svelte';
+describe('BufferStore', () => {
+    beforeEach(() => {
+        resetZone();
+        vi.useFakeTimers();
+    });
+    it('hydrates an empty buffer when zone has nothing', () => {
+        const store = new BufferStore();
+        const buf = new ModeBuffer('sh3');
+        store.hydrate(buf);
+        expect(buf.scrollback.entries).toEqual([]);
+        expect(buf.history).toEqual([]);
+    });
+    it('persists a serializable buffer after debounce', () => {
+        const store = new BufferStore();
+        const buf = new ModeBuffer('sh3');
+        buf.scrollback.push({ kind: 'prompt', cwd: '/', line: 'ls', ts: 1 });
+        buf.history.push('ls');
+        store.flush(buf);
+        vi.advanceTimersByTime(200);
+        const persisted = readBuffer('sh3');
+        expect(persisted === null || persisted === void 0 ? void 0 : persisted.entries).toHaveLength(1);
+        expect(persisted === null || persisted === void 0 ? void 0 : persisted.history).toEqual(['ls']);
+    });
+    it('coalesces back-to-back flushes within debounce window', () => {
+        const store = new BufferStore();
+        const buf = new ModeBuffer('sh3');
+        buf.scrollback.push({ kind: 'prompt', cwd: '/', line: 'a', ts: 1 });
+        store.flush(buf);
+        buf.scrollback.push({ kind: 'prompt', cwd: '/', line: 'b', ts: 2 });
+        store.flush(buf);
+        vi.advanceTimersByTime(200);
+        const persisted = readBuffer('sh3');
+        expect(persisted === null || persisted === void 0 ? void 0 : persisted.entries).toHaveLength(2);
+    });
+    it('caps persisted entries at 500 (most recent)', () => {
+        const store = new BufferStore();
+        const buf = new ModeBuffer('sh3');
+        for (let i = 0; i < 600; i++) {
+            buf.scrollback.push({ kind: 'prompt', cwd: '/', line: `cmd${i}`, ts: i });
+        }
+        store.flush(buf);
+        vi.advanceTimersByTime(200);
+        const persisted = readBuffer('sh3');
+        expect(persisted === null || persisted === void 0 ? void 0 : persisted.entries).toHaveLength(500);
+        const first = persisted.entries[0];
+        expect(first.kind === 'prompt' && first.line).toBe('cmd100');
+    });
+    it('hydrates a previously persisted buffer', () => {
+        writeBuffer('sh3', {
+            entries: [{ id: 'e1', kind: 'prompt', cwd: '/', line: 'restored', ts: 1 }],
+            history: ['restored'],
+        });
+        const store = new BufferStore();
+        const buf = new ModeBuffer('sh3');
+        store.hydrate(buf);
+        expect(buf.scrollback.entries).toHaveLength(1);
+        expect(buf.history).toEqual(['restored']);
+    });
+    it('hydrate prevents id collisions on subsequent pushes', () => {
+        // Persisted id well above any test-time mkId() counter so the bug
+        // would reproduce (duplicate keys) if hydrate did not bump the
+        // module-scoped id sequence past the restored max.
+        writeBuffer('sh3', {
+            entries: [{ id: 'e9999', kind: 'prompt', cwd: '/', line: 'restored', ts: 1 }],
+            history: [],
+        });
+        const store = new BufferStore();
+        const buf = new ModeBuffer('sh3');
+        store.hydrate(buf);
+        buf.scrollback.push({ kind: 'prompt', cwd: '/', line: 'next', ts: 2 });
+        const ids = buf.scrollback.entries.map((e) => e.id);
+        expect(new Set(ids).size).toBe(ids.length);
+        expect(Number(ids[1].slice(1))).toBeGreaterThan(9999);
+    });
+    it('non-serializable rich props degrade to status entry on persist', () => {
+        const store = new BufferStore();
+        const buf = new ModeBuffer('sh3');
+        const circular = {};
+        circular.self = circular;
+        buf.scrollback.push({
+            kind: 'rich',
+            componentKey: 'apps-table',
+            component: {},
+            props: circular,
+            ts: 1,
+        });
+        store.flush(buf);
+        vi.advanceTimersByTime(200);
+        const persisted = readBuffer('sh3');
+        expect(persisted === null || persisted === void 0 ? void 0 : persisted.entries).toHaveLength(1);
+        expect(persisted === null || persisted === void 0 ? void 0 : persisted.entries[0].kind).toBe('status');
+    });
+    it('persists lastSeq when provided', () => {
+        var _a;
+        const store = new BufferStore();
+        const buf = new ModeBuffer('bash');
+        buf.scrollback.push({ kind: 'prompt', cwd: '/', line: 'ls', ts: 1 });
+        store.flush(buf, 42);
+        vi.advanceTimersByTime(200);
+        expect((_a = readBuffer('bash')) === null || _a === void 0 ? void 0 : _a.lastSeq).toBe(42);
+        expect(store.readLastSeq('bash')).toBe(42);
+    });
+});

package/dist/shell-shard/buffer-zone-state.svelte.d.ts

@@ -0,0 +1,38 @@
+import type { StateZones } from '../state/zones.svelte';
+export interface PersistedEntryBase {
+    id: string;
+    ts: number;
+}
+export type PersistedEntry = (PersistedEntryBase & {
+    kind: 'prompt';
+    cwd: string;
+    line: string;
+}) | (PersistedEntryBase & {
+    kind: 'text';
+    stream: 'stdout' | 'stderr';
+    chunks: string[];
+}) | (PersistedEntryBase & {
+    kind: 'rich';
+    componentKey: string;
+    props: unknown;
+}) | (PersistedEntryBase & {
+    kind: 'status';
+    text: string;
+    level: 'info' | 'warn' | 'error';
+});
+export interface PersistedBuffer {
+    entries: PersistedEntry[];
+    history: string[];
+    /** Only meaningful for the bash buffer — server's seq cursor at last flush. */
+    lastSeq?: number;
+}
+export interface ShellWorkspaceZoneSchema {
+    workspace: {
+        buffers: Record<string, PersistedBuffer>;
+    };
+}
+export declare function __bindZone(s: StateZones<ShellWorkspaceZoneSchema>): void;
+export declare function __unbindZone(): void;
+export declare function readBuffer(modeId: string): PersistedBuffer | undefined;
+export declare function writeBuffer(modeId: string, buf: PersistedBuffer): void;
+export declare function __resetForTests(): void;

package/dist/shell-shard/buffer-zone-state.svelte.js

@@ -0,0 +1,31 @@
+/*
+ * Reactive proxy bound at activate-time to the shell-shard's workspace
+ * zone. Mirrors the layouts-shard pattern (layoutsState.svelte.ts) so
+ * tests can swap the live proxy for an in-memory shim.
+ *
+ * Holds the per-mode buffer snapshots that BufferStore reads/writes.
+ */
+let zoneState = null;
+export function __bindZone(s) {
+    zoneState = s;
+}
+export function __unbindZone() {
+    zoneState = null;
+}
+export function readBuffer(modeId) {
+    return zoneState === null || zoneState === void 0 ? void 0 : zoneState.workspace.buffers[modeId];
+}
+export function writeBuffer(modeId, buf) {
+    if (!zoneState)
+        return;
+    zoneState.workspace.buffers = Object.assign(Object.assign({}, zoneState.workspace.buffers), { [modeId]: buf });
+}
+export function __resetForTests() {
+    zoneState = {
+        ephemeral: {},
+        session: {},
+        workspace: { buffers: {} },
+        user: {},
+    };
+}
+__resetForTests();

package/dist/shell-shard/contract.d.ts

@@ -17,6 +17,13 @@ export interface ShellModeDescriptor {
     runsOn: ShellModeRunsOn;
     /** Whether the shell auto-relocates cwd when a shard takes focus. */
     autoRelocate?: boolean;
+    /**
+     * Whether the input prompt shows the current working directory in front
+     * of the cursor. Defaults to false for custom modes — most LLM/agent
+     * shells don't have a meaningful cwd to display. Builtin sh3 and bash
+     * always show it.
+     */
+    showCwd?: boolean;
     /** Brain: receives input and pushes output. */
     dispatch: ShellModeDispatchHandler;
     /** Optional lifecycle hook fired when the mode is selected. */

package/dist/shell-shard/dispatch-custom.test.js

@@ -3,6 +3,8 @@ import { makeDispatch } from './dispatch';
 function makeStubDeps(mode, customMode) {
     const pushed = [];
     const scrollback = { push: (e) => pushed.push(e) };
+    const history = [];
+    const buffer = { scrollback, history };
     const session = {
         history: { push: vi.fn() },
         send: () => { },
@@ -18,7 +20,7 @@ function makeStubDeps(mode, customMode) {
             mode: () => mode,
             role: () => 'user',
             resolver,
-            scrollback,
+            buffer: () => buffer,
             session,
             shell,
             fs,

package/dist/shell-shard/dispatch-gating.test.js

@@ -13,6 +13,8 @@ function scaffold(mode) {
     const sent = [];
     const pushed = [];
     const scrollback = { push: (e) => pushed.push(e), clear: () => { } };
+    const history = [];
+    const buffer = { scrollback, history };
     const session = { history: { push: vi.fn() }, send: (m) => sent.push(m), cwd: '/', connected: true, connect: vi.fn() };
     const fs = {};
     const shell = {};
@@ -32,7 +34,7 @@ function scaffold(mode) {
         mode: () => mode,
         role: () => (mode.requiresRole === 'admin' ? 'admin' : 'user'),
         resolver,
-        scrollback,
+        buffer: () => buffer,
         session,
         shell,
         fs,
@@ -47,7 +49,9 @@ describe('dispatch — mode-gated verb resolution', () => {
     it('sh3 mode resolves sh3-domain verbs locally', async () => {
         const { dispatch, sent } = scaffold(sh3Mode);
         await dispatch('apps');
-        expect(sent).toEqual([]);
+        // sh3 verbs run locally; the only WS traffic is the per-mode
+        // history-log entry tagged 'sh3'.
+        expect(sent).toEqual([{ t: 'history-log', line: 'apps', mode: 'sh3' }]);
     });
     it('bash mode forwards sh3-domain verbs to ws', async () => {
         const { dispatch, sent } = scaffold(bashMode);

package/dist/shell-shard/dispatch-invoke.test.js

@@ -13,6 +13,8 @@ function scaffold(opts) {
     const pushed = [];
     const connectSpy = vi.fn();
     const scrollback = { push: (e) => pushed.push(e), clear: () => { } };
+    const history = [];
+    const buffer = { scrollback, history };
     const session = {
         history: { push: vi.fn() },
         send: (m) => sent.push(m),
@@ -34,7 +36,7 @@ function scaffold(opts) {
         mode: () => opts.current,
         role: () => opts.role,
         resolver,
-        scrollback,
+        buffer: () => buffer,
         session,
         shell,
         fs,
@@ -88,7 +90,7 @@ describe('output.invoke — sh3 target', () => {
     });
 });
 describe('output.invoke — bash target', () => {
-    it('admin invocation lazy-connects and forwards', async () => {
+    it('admin invocation forwards a bash submit', async () => {
         const customs = [{
                 id: 'gemini',
                 label: 'Gemini',
@@ -97,16 +99,15 @@ describe('output.invoke — bash target', () => {
                     await output.invoke('bash', 'ls');
                 },
             }];
-        const { dispatch, sent, connectSpy } = scaffold({
+        const { dispatch, sent } = scaffold({
             current: customMode('gemini'),
             role: 'admin',
             customs,
         });
         await dispatch('hello');
-        expect(connectSpy).toHaveBeenCalledTimes(1);
-        expect(sent.some((m) => m.t === 'submit' && m.line === 'ls')).toBe(true);
+        expect(sent.some((m) => m.t === 'submit' && m.line === 'ls' && m.mode === 'bash')).toBe(true);
     });
-    it('lazy-connect only fires once across multiple invokes', async () => {
+    it('multiple invokes each forward a bash submit', async () => {
         const customs = [{
                 id: 'gemini',
                 label: 'Gemini',
@@ -116,13 +117,14 @@ describe('output.invoke — bash target', () => {
                     await output.invoke('bash', 'pwd');
                 },
             }];
-        const { dispatch, connectSpy } = scaffold({
+        const { dispatch, sent } = scaffold({
             current: customMode('gemini'),
             role: 'admin',
             customs,
         });
         await dispatch('hello');
-        expect(connectSpy).toHaveBeenCalledTimes(1);
+        const submits = sent.filter((m) => m.t === 'submit');
+        expect(submits.map((m) => m.line)).toEqual(['ls', 'pwd']);
     });
     it('non-admin invoking bash throws', async () => {
         let caught;