sh3-core 0.13.4 → 0.14.0

package/dist/shell-shard/modes/prefs.test.js

@@ -15,8 +15,8 @@ beforeEach(() => {
 });
 describe('readLastMode / writeLastMode', () => {
     it('round-trips a mode id for a user', () => {
-        writeLastMode('alice', 'user');
-        expect(readLastMode('alice')).toBe('user');
+        writeLastMode('alice', 'sh3');
+        expect(readLastMode('alice')).toBe('sh3');
     });
     it('returns null when nothing persisted', () => {
         expect(readLastMode('bob')).toBeNull();
@@ -25,22 +25,22 @@ describe('readLastMode / writeLastMode', () => {
 describe('resolveInitialMode', () => {
     const reg = new ShellModeRegistry();
     registerBuiltinModes(reg);
-    it('admin with no pref → dev', () => {
-        expect(resolveInitialMode(reg, 'alice', 'admin').id).toBe('dev');
+    it('admin with no pref → bash', () => {
+        expect(resolveInitialMode(reg, 'alice', 'admin').id).toBe('bash');
     });
-    it('user with no pref → user', () => {
-        expect(resolveInitialMode(reg, 'alice', 'user').id).toBe('user');
+    it('user with no pref → sh3', () => {
+        expect(resolveInitialMode(reg, 'alice', 'user').id).toBe('sh3');
     });
-    it('admin with persisted user → user', () => {
-        writeLastMode('alice', 'user');
-        expect(resolveInitialMode(reg, 'alice', 'admin').id).toBe('user');
+    it('admin with persisted sh3 → sh3', () => {
+        writeLastMode('alice', 'sh3');
+        expect(resolveInitialMode(reg, 'alice', 'admin').id).toBe('sh3');
     });
-    it('user with persisted dev (not allowed) → falls back to user', () => {
-        writeLastMode('alice', 'dev');
-        expect(resolveInitialMode(reg, 'alice', 'user').id).toBe('user');
+    it('user with persisted bash (not allowed) → falls back to sh3', () => {
+        writeLastMode('alice', 'bash');
+        expect(resolveInitialMode(reg, 'alice', 'user').id).toBe('sh3');
     });
     it('persisted unknown id → role default', () => {
         writeLastMode('alice', 'nonsense');
-        expect(resolveInitialMode(reg, 'alice', 'admin').id).toBe('dev');
+        expect(resolveInitialMode(reg, 'alice', 'admin').id).toBe('bash');
     });
 });

package/dist/shell-shard/modes/registry.test.js

@@ -1,7 +1,7 @@
 import { describe, it, expect, beforeEach } from 'vitest';
 import { ShellModeRegistry } from './registry';
-const dev = { id: 'dev', label: 'Dev', requiresRole: 'admin', transport: 'ws', autoRelocate: false };
-const user = { id: 'user', label: 'User', transport: 'none', autoRelocate: true };
+const bash = { id: 'bash', label: 'Bash', requiresRole: 'admin', transport: 'ws', autoRelocate: false };
+const sh3 = { id: 'sh3', label: 'SH3', transport: 'none', autoRelocate: true };
 const ssh = { id: 'ssh', label: 'SSH', requiresRole: 'admin', transport: 'custom', autoRelocate: false };
 describe('ShellModeRegistry', () => {
     let reg;
@@ -9,27 +9,27 @@ describe('ShellModeRegistry', () => {
         reg = new ShellModeRegistry();
     });
     it('registers and retrieves modes', () => {
-        reg.register(dev);
-        expect(reg.get('dev')).toEqual(dev);
+        reg.register(bash);
+        expect(reg.get('bash')).toEqual(bash);
     });
     it('list(user) excludes admin-only modes', () => {
-        reg.register(dev);
-        reg.register(user);
+        reg.register(bash);
+        reg.register(sh3);
         reg.register(ssh);
         const ids = reg.list('user').map((m) => m.id);
-        expect(ids).toEqual(['user']);
+        expect(ids).toEqual(['sh3']);
     });
     it('list(admin) includes all modes', () => {
-        reg.register(dev);
-        reg.register(user);
+        reg.register(bash);
+        reg.register(sh3);
         reg.register(ssh);
         const ids = reg.list('admin').map((m) => m.id).sort();
-        expect(ids).toEqual(['dev', 'ssh', 'user']);
+        expect(ids).toEqual(['bash', 'sh3', 'ssh']);
     });
     it('re-registering same id replaces the mode', () => {
         var _a;
-        reg.register(dev);
-        reg.register(Object.assign(Object.assign({}, dev), { label: 'Dev+' }));
-        expect((_a = reg.get('dev')) === null || _a === void 0 ? void 0 : _a.label).toBe('Dev+');
+        reg.register(bash);
+        reg.register(Object.assign(Object.assign({}, bash), { label: 'Bash+' }));
+        expect((_a = reg.get('bash')) === null || _a === void 0 ? void 0 : _a.label).toBe('Bash+');
     });
 });

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

@@ -0,0 +1,3 @@
+import type { Scrollback } from './scrollback.svelte';
+import type { ShellModeOutput } from './contract';
+export declare function makeShellModeOutput(sb: Scrollback): ShellModeOutput;

package/dist/shell-shard/output.js

@@ -0,0 +1,75 @@
+/*
+ * makeShellModeOutput — wraps a Scrollback in the typed ShellModeOutput
+ * surface external mode shards consume. The framework is the only writer to
+ * scrollback shapes; mode authors talk to this handle.
+ *
+ * Streaming entries carry a `__streamState` prop set to 'streaming' on push,
+ * 'complete' on complete(), 'error' on error(). The entry's component is
+ * expected to read this prop (or ignore it — it's optional).
+ */
+function findRich(sb, entryId) {
+    return sb.entries.find((e) => e.kind === 'rich' && e.id === entryId);
+}
+function makeRichHandle(sb, entryId) {
+    return {
+        update(patch) {
+            const entry = findRich(sb, entryId);
+            if (!entry)
+                return;
+            Object.assign(entry.props, patch);
+        },
+    };
+}
+function lastRichId(sb) {
+    const last = sb.entries[sb.entries.length - 1];
+    return last.id;
+}
+export function makeShellModeOutput(sb) {
+    return {
+        text(stream, chunk) {
+            sb.push({ kind: 'text', stream, chunks: [chunk], ts: Date.now() });
+        },
+        status(level, msg) {
+            sb.push({ kind: 'status', text: msg, level, ts: Date.now() });
+        },
+        rich(component, props) {
+            sb.push({ kind: 'rich', component, props: Object.assign({}, props), ts: Date.now() });
+            return makeRichHandle(sb, lastRichId(sb));
+        },
+        stream(component, initialProps) {
+            sb.push({
+                kind: 'rich',
+                component,
+                props: Object.assign(Object.assign({}, initialProps), { __streamState: 'streaming' }),
+                ts: Date.now(),
+            });
+            const id = lastRichId(sb);
+            return {
+                append(patch) {
+                    const entry = findRich(sb, id);
+                    if (!entry)
+                        return;
+                    Object.assign(entry.props, patch);
+                },
+                complete() {
+                    const entry = findRich(sb, id);
+                    if (!entry)
+                        return;
+                    entry.props.__streamState = 'complete';
+                },
+                error(err) {
+                    var _a;
+                    const entry = findRich(sb, id);
+                    if (entry)
+                        entry.props.__streamState = 'error';
+                    sb.push({
+                        kind: 'status',
+                        text: `mode: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : String(err)}`,
+                        level: 'error',
+                        ts: Date.now(),
+                    });
+                },
+            };
+        },
+    };
+}

package/dist/shell-shard/output.test.d.ts

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

package/dist/shell-shard/output.test.js

@@ -0,0 +1,54 @@
+import { describe, it, expect } from 'vitest';
+import { Scrollback } from './scrollback.svelte';
+import { makeShellModeOutput } from './output';
+const FakeComponent = (() => { });
+describe('makeShellModeOutput', () => {
+    it('text() pushes coalescing text entries', () => {
+        const sb = new Scrollback();
+        const out = makeShellModeOutput(sb);
+        out.text('stdout', 'hello ');
+        out.text('stdout', 'world');
+        const text = sb.entries.filter((e) => e.kind === 'text');
+        expect(text).toHaveLength(1);
+        expect(text[0].chunks.join('')).toBe('hello world');
+    });
+    it('status() pushes a status entry with the right level', () => {
+        const sb = new Scrollback();
+        const out = makeShellModeOutput(sb);
+        out.status('warn', 'careful');
+        const s = sb.entries.find((e) => e.kind === 'status');
+        expect(s).toBeDefined();
+        expect(s.level).toBe('warn');
+        expect(s.text).toBe('careful');
+    });
+    it('rich().update() mutates the live entry props', () => {
+        const sb = new Scrollback();
+        const out = makeShellModeOutput(sb);
+        const handle = out.rich(FakeComponent, { tokens: 'a' });
+        handle.update({ tokens: 'ab' });
+        const entry = sb.entries.find((e) => e.kind === 'rich');
+        expect(entry.props.tokens).toBe('ab');
+    });
+    it('stream() marks the entry mid-stream until complete()', () => {
+        const sb = new Scrollback();
+        const out = makeShellModeOutput(sb);
+        const h = out.stream(FakeComponent, { tokens: '' });
+        let entry = sb.entries.find((e) => e.kind === 'rich');
+        expect(entry.props.__streamState).toBe('streaming');
+        h.append({ tokens: 'a' });
+        expect(entry.props.tokens).toBe('a');
+        h.complete();
+        expect(entry.props.__streamState).toBe('complete');
+    });
+    it('stream().error() marks the entry errored and pushes a status', () => {
+        const sb = new Scrollback();
+        const out = makeShellModeOutput(sb);
+        const h = out.stream(FakeComponent, { tokens: '' });
+        h.error(new Error('boom'));
+        const entry = sb.entries.find((e) => e.kind === 'rich');
+        expect(entry.props.__streamState).toBe('error');
+        const s = sb.entries.find((e) => e.kind === 'status' && e.level === 'error');
+        expect(s).toBeDefined();
+        expect(s.text).toMatch(/boom/);
+    });
+});

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

@@ -0,0 +1,13 @@
+import type { ShardContext } from '../shards/types';
+import { type ShellModeDescriptor } from './contract';
+/**
+ * Register a shell-mode descriptor from a shard's `activate(ctx)`. The mode
+ * appears in the picker and in `mode` verb output; submitted lines that don't
+ * match a local verb route to `descriptor.dispatch(input, output)`.
+ *
+ * Thin wrapper around `ctx.contributions.register` so authors get
+ * type-checking without `ShardContext` growing another method. Returns the
+ * upstream disposer; calling it is optional — the framework auto-unregisters
+ * when the owning shard deactivates.
+ */
+export declare function registerShellMode(ctx: ShardContext, descriptor: ShellModeDescriptor): () => void;

package/dist/shell-shard/registerShellMode.js

@@ -0,0 +1,14 @@
+import { SHELL_MODE_CONTRIBUTION_POINT } from './contract';
+/**
+ * Register a shell-mode descriptor from a shard's `activate(ctx)`. The mode
+ * appears in the picker and in `mode` verb output; submitted lines that don't
+ * match a local verb route to `descriptor.dispatch(input, output)`.
+ *
+ * Thin wrapper around `ctx.contributions.register` so authors get
+ * type-checking without `ShardContext` growing another method. Returns the
+ * upstream disposer; calling it is optional — the framework auto-unregisters
+ * when the owning shard deactivates.
+ */
+export function registerShellMode(ctx, descriptor) {
+    return ctx.contributions.register(SHELL_MODE_CONTRIBUTION_POINT, descriptor);
+}

package/dist/shell-shard/registerShellMode.test.d.ts

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

package/dist/shell-shard/registerShellMode.test.js

@@ -0,0 +1,19 @@
+import { describe, it, expect, vi } from 'vitest';
+import { registerShellMode } from './registerShellMode';
+import { SHELL_MODE_CONTRIBUTION_POINT } from './contract';
+describe('registerShellMode', () => {
+    it('registers under the canonical contribution point id', () => {
+        const dispose = vi.fn();
+        const register = vi.fn(() => dispose);
+        const ctx = { contributions: { register } };
+        const desc = {
+            id: 'gemini',
+            label: 'Gemini',
+            runsOn: 'client',
+            dispatch: async () => { },
+        };
+        const ret = registerShellMode(ctx, desc);
+        expect(register).toHaveBeenCalledWith(SHELL_MODE_CONTRIBUTION_POINT, desc);
+        expect(ret).toBe(dispose);
+    });
+});

package/dist/shell-shard/shellShard.svelte.js

@@ -163,6 +163,13 @@ function makeShellApi(_ctx) {
                 admin: isAdmin(),
             };
         },
+        // Mode switching is per-view state owned by Terminal.svelte; the base
+        // ShellApi cannot reach it from the shard scope. Terminal.svelte wraps
+        // this object and overrides setMode/listModes with the live registry +
+        // setMode closure. Verbs called outside a terminal context fall through
+        // these stubs (no-op switch, empty list).
+        setMode(_id) { return false; },
+        listModes() { return []; },
     };
 }
 /**
@@ -205,7 +212,7 @@ export const shellShard = {
                 const role = isAdmin() ? 'admin' : 'user';
                 const instance = mount(Terminal, {
                     target: container,
-                    props: { shell, wsUrl, userId, role },
+                    props: { shell, wsUrl, userId, role, contributions: ctx.contributions },
                 });
                 return {
                     unmount() {

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

@@ -3,9 +3,9 @@ import { makeDispatch } from './dispatch';
 function scaffold(modeId) {
     const sent = [];
     const pushed = [];
-    const mode = modeId === 'dev'
-        ? { id: 'dev', label: 'Dev', transport: 'ws', autoRelocate: false, requiresRole: 'admin' }
-        : { id: 'user', label: 'User', transport: 'none', autoRelocate: true };
+    const mode = modeId === 'bash'
+        ? { id: 'bash', label: 'Bash', transport: 'ws', autoRelocate: false, requiresRole: 'admin' }
+        : { id: 'sh3', label: 'SH3', transport: 'none', autoRelocate: true };
     const scrollback = { push: (e) => pushed.push(e) };
     const session = {
         history: { push: vi.fn() },
@@ -19,7 +19,7 @@ function scaffold(modeId) {
             ? { kind: 'local', verb: { name: 'pwd', run: async () => { } }, args: [], line }
             : { kind: 'forward', line },
     };
-    const dispatch = makeDispatch({
+    const { dispatch } = makeDispatch({
         mode: () => mode,
         resolver,
         scrollback,
@@ -30,23 +30,23 @@ function scaffold(modeId) {
     });
     return { dispatch, sent, pushed };
 }
-describe('dispatch — user mode', () => {
+describe('dispatch — sh3 mode', () => {
     it('unknown verbs print error, do not send', async () => {
-        const { dispatch, sent, pushed } = scaffold('user');
+        const { dispatch, sent, pushed } = scaffold('sh3');
         await dispatch('foo');
         expect(sent).toEqual([]);
         expect(pushed.some((e) => e.kind === 'status' && /unknown verb/.test(e.text))).toBe(true);
     });
     it('$ escape prints error', async () => {
-        const { dispatch, sent, pushed } = scaffold('user');
+        const { dispatch, sent, pushed } = scaffold('sh3');
         await dispatch('$ ls');
         expect(sent).toEqual([]);
         expect(pushed.some((e) => e.kind === 'status' && /server shell not available/.test(e.text))).toBe(true);
     });
 });
-describe('dispatch — dev mode', () => {
+describe('dispatch — bash mode', () => {
     it('forwards unknown verbs to server', async () => {
-        const { dispatch, sent } = scaffold('dev');
+        const { dispatch, sent } = scaffold('bash');
         await dispatch('foo');
         expect(sent.some((m) => m.t === 'submit' && m.line === 'foo')).toBe(true);
     });

package/dist/shell-shard/toolbar/slots/ModeSlot.svelte

@@ -1,67 +1,27 @@
 <script lang="ts">
-  import type { ShellMode, ShellRole } from '../../modes/types';
-  import type { ShellModeRegistry } from '../../modes/registry';
+  import type { ShellMode } from '../../modes/types';
+  import Segmented from '../../../primitives/widgets/Segmented.svelte';
+  import type { SegmentedOption } from '../../../primitives/widgets/Segmented';
 
   interface Props {
     mode: ShellMode;
-    role: ShellRole;
-    registry: ShellModeRegistry;
+    modes: ShellMode[];
     onSelect: (id: string) => void;
   }
+  let { mode, modes, onSelect }: Props = $props();
 
-  let { mode, role, registry, onSelect }: Props = $props();
-
-  let modes = $derived(registry.list(role));
+  let options: SegmentedOption[] = $derived(
+    modes.map((m) => ({ value: m.id, label: m.label })),
+  );
 </script>
 
-{#if role === 'admin'}
-  <div class="mode-bar" role="toolbar" aria-label="Shell mode">
-    {#each modes as m (m.id)}
-      <button
-        type="button"
-        class="mode-btn"
-        class:active={m.id === mode.id}
-        aria-pressed={m.id === mode.id}
-        onclick={() => onSelect(m.id)}
-      >
-        {m.label}
-      </button>
-    {/each}
-  </div>
-{:else}
+{#if modes.length >= 2}
+  <Segmented {options} value={mode.id} size="sm" onchange={(next) => onSelect(next)} />
+{:else if modes.length === 1}
   <span class="mode-label">{mode.label}</span>
 {/if}
 
 <style>
-  .mode-bar {
-    display: inline-flex;
-    gap: 2px;
-    padding: 1px;
-    border: 1px solid var(--shell-border, #444);
-    border-radius: 3px;
-  }
-
-  .mode-btn {
-    background: none;
-    border: none;
-    color: var(--shell-fg-dim, var(--shell-fg-muted, #888));
-    padding: 2px 8px;
-    border-radius: 2px;
-    cursor: pointer;
-    font-size: 0.85em;
-    line-height: 1.4;
-  }
-
-  .mode-btn:hover {
-    background: var(--shell-hover, color-mix(in srgb, var(--shell-fg, #ddd) 10%, transparent));
-    color: var(--shell-fg, #ddd);
-  }
-
-  .mode-btn.active {
-    background: var(--shell-accent, #7c7cf0);
-    color: var(--shell-bg, #1a1a2e);
-  }
-
   .mode-label {
     font-size: 0.85em;
     color: var(--shell-fg-dim, var(--shell-fg-muted, #888));

package/dist/shell-shard/toolbar/slots/ModeSlot.svelte.d.ts

@@ -1,9 +1,7 @@
-import type { ShellMode, ShellRole } from '../../modes/types';
-import type { ShellModeRegistry } from '../../modes/registry';
+import type { ShellMode } from '../../modes/types';
 interface Props {
     mode: ShellMode;
-    role: ShellRole;
-    registry: ShellModeRegistry;
+    modes: ShellMode[];
     onSelect: (id: string) => void;
 }
 declare const ModeSlot: import("svelte").Component<Props, {}, "">;

package/dist/shell-shard/toolbar/slots.test.js

@@ -2,27 +2,27 @@ import { describe, it, expect } from 'vitest';
 import { ToolbarSlotRegistry } from './slots';
 const A = { id: 'a', order: 20, visible: () => true, component: {} };
 const B = { id: 'b', order: 10, visible: () => true, component: {} };
-const C = { id: 'c', order: 30, visible: (ctx) => ctx.mode.id === 'user', component: {} };
-const userCtx = { mode: { id: 'user', label: 'User', transport: 'none', autoRelocate: true }, role: 'user' };
-const devCtx = { mode: { id: 'dev', label: 'Dev', transport: 'ws', autoRelocate: false, requiresRole: 'admin' }, role: 'admin' };
+const C = { id: 'c', order: 30, visible: (ctx) => ctx.mode.id === 'sh3', component: {} };
+const sh3Ctx = { mode: { id: 'sh3', label: 'SH3', transport: 'none', autoRelocate: true }, role: 'user' };
+const bashCtx = { mode: { id: 'bash', label: 'Bash', transport: 'ws', autoRelocate: false, requiresRole: 'admin' }, role: 'admin' };
 describe('ToolbarSlotRegistry', () => {
     it('lists visible slots in order', () => {
         const r = new ToolbarSlotRegistry();
         r.register(A);
         r.register(B);
         r.register(C);
-        expect(r.list(userCtx).map((s) => s.id)).toEqual(['b', 'a', 'c']);
+        expect(r.list(sh3Ctx).map((s) => s.id)).toEqual(['b', 'a', 'c']);
     });
     it('filters by visible', () => {
         const r = new ToolbarSlotRegistry();
         r.register(A);
         r.register(C);
-        expect(r.list(devCtx).map((s) => s.id)).toEqual(['a']);
+        expect(r.list(bashCtx).map((s) => s.id)).toEqual(['a']);
     });
     it('re-registering by id replaces', () => {
         const r = new ToolbarSlotRegistry();
         r.register(A);
         r.register(Object.assign(Object.assign({}, A), { order: 99 }));
-        expect(r.list(userCtx)[0].order).toBe(99);
+        expect(r.list(sh3Ctx)[0].order).toBe(99);
     });
 });

package/dist/shell-shard/verbs/index.js

@@ -4,6 +4,7 @@
  */
 import { makeHelpVerb } from './help';
 import { clearVerb } from './clear';
+import { modeVerb } from './mode';
 import { historyVerb } from './history';
 import { appsVerb, appVerb } from './apps';
 import { shardsVerb } from './shards';
@@ -17,6 +18,7 @@ import { resetVerb } from './reset';
 export function registerV1Verbs(ctx) {
     ctx.registerVerb(makeHelpVerb());
     ctx.registerVerb(clearVerb);
+    ctx.registerVerb(modeVerb);
     ctx.registerVerb(historyVerb);
     ctx.registerVerb(appsVerb);
     ctx.registerVerb(appVerb);

package/dist/shell-shard/verbs/mode.d.ts

@@ -0,0 +1,2 @@
+import type { Verb } from '../../verbs/types';
+export declare const modeVerb: Verb;

package/dist/shell-shard/verbs/mode.js

@@ -0,0 +1,28 @@
+export const modeVerb = {
+    name: 'mode',
+    summary: 'List or switch shell modes. Usage: mode | mode <id>',
+    async run(ctx, args) {
+        const ts = Date.now();
+        if (args.length === 0) {
+            const modes = ctx.shell.listModes();
+            const lines = modes.map((m) => `  ${m.id.padEnd(12)} ${m.label}`);
+            ctx.scrollback.push({
+                kind: 'text',
+                stream: 'stdout',
+                chunks: [['Available modes:', ...lines].join('\n') + '\n'],
+                ts,
+            });
+            return;
+        }
+        const id = args[0];
+        const ok = ctx.shell.setMode(id);
+        if (!ok) {
+            ctx.scrollback.push({
+                kind: 'status',
+                text: `mode: unknown or restricted mode '${id}'`,
+                level: 'error',
+                ts,
+            });
+        }
+    },
+};

package/dist/shell-shard/verbs/mode.test.d.ts

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

package/dist/shell-shard/verbs/mode.test.js

@@ -0,0 +1,43 @@
+import { describe, it, expect, vi } from 'vitest';
+import { modeVerb } from './mode';
+function makeShell(modes = [{ id: 'bash', label: 'Bash' }, { id: 'sh3', label: 'SH3' }]) {
+    const setMode = vi.fn((id) => modes.some((m) => m.id === id));
+    const listModes = () => modes;
+    return { setMode, listModes };
+}
+function makeCtx(shellExt) {
+    const pushed = [];
+    const ctx = {
+        shell: { setMode: shellExt.setMode, listModes: shellExt.listModes },
+        scrollback: { push: (e) => pushed.push(e) },
+        session: {},
+        cwd: '/',
+        dispatch: async () => { },
+        fs: {},
+    };
+    return { ctx, pushed };
+}
+describe('mode verb', () => {
+    it('lists modes when called with no args', async () => {
+        const shell = makeShell();
+        const { ctx, pushed } = makeCtx(shell);
+        await modeVerb.run(ctx, []);
+        const dump = JSON.stringify(pushed);
+        expect(dump).toMatch(/bash/);
+        expect(dump).toMatch(/sh3/);
+    });
+    it('switches mode when called with a known id', async () => {
+        const shell = makeShell();
+        const { ctx } = makeCtx(shell);
+        await modeVerb.run(ctx, ['bash']);
+        expect(shell.setMode).toHaveBeenCalledWith('bash');
+    });
+    it('emits an error status when the id is unknown', async () => {
+        const shell = makeShell();
+        const { ctx, pushed } = makeCtx(shell);
+        await modeVerb.run(ctx, ['nope']);
+        const err = pushed.find((e) => e.kind === 'status' && e.level === 'error');
+        expect(err).toBeDefined();
+        expect(err.text).toMatch(/nope/);
+    });
+});

package/dist/verbs/types.d.ts

@@ -66,6 +66,17 @@ export interface ShellApi {
         userId: string;
         admin: boolean;
     };
+    /**
+     * Switch the active shell mode. The mode must be registered and visible
+     * to the current role. Returns true on success, false on unknown or
+     * role-restricted id (so verbs can surface a status).
+     */
+    setMode(id: string): boolean;
+    /** List currently visible modes for the current role. */
+    listModes(): readonly {
+        id: string;
+        label: string;
+    }[];
 }
 export interface VerbContext {
     shell: ShellApi;

package/dist/version.d.ts

@@ -1,2 +1,2 @@
 /** Auto-generated from package.json — do not edit manually. */
-export declare const VERSION = "0.13.4";
+export declare const VERSION = "0.14.0";

package/dist/version.js

@@ -1,2 +1,2 @@
 /** Auto-generated from package.json — do not edit manually. */
-export const VERSION = '0.13.4';
+export const VERSION = '0.14.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sh3-core",
-  "version": "0.13.4",
+  "version": "0.14.0",
   "type": "module",
   "files": [
     "dist"