sh3-core 0.13.4 → 0.14.3

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

@@ -0,0 +1,73 @@
+import { describe, it, expect } from 'vitest';
+import { Scrollback } from './scrollback.svelte';
+import { makeShellModeOutput } from './output';
+const FakeComponent = (() => { });
+const stubBusy = () => () => { };
+const stubInvoke = async () => { };
+describe('makeShellModeOutput', () => {
+    it('text() pushes coalescing text entries', () => {
+        const sb = new Scrollback();
+        const out = makeShellModeOutput({ scrollback: sb, busy: stubBusy, invoke: stubInvoke });
+        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({ scrollback: sb, busy: stubBusy, invoke: stubInvoke });
+        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({ scrollback: sb, busy: stubBusy, invoke: stubInvoke });
+        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({ scrollback: sb, busy: stubBusy, invoke: stubInvoke });
+        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({ scrollback: sb, busy: stubBusy, invoke: stubInvoke });
+        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/);
+    });
+});
+describe('makeShellModeOutput — busy', () => {
+    it('forwards busy() to the controller and clear() is idempotent', () => {
+        const calls = [];
+        let cleared = 0;
+        const sb = new Scrollback();
+        const busy = (label) => {
+            calls.push(`acquire:${label !== null && label !== void 0 ? label : ''}`);
+            return () => { cleared++; };
+        };
+        const out = makeShellModeOutput({ scrollback: sb, busy, invoke: stubInvoke });
+        const h = out.busy('thinking');
+        expect(calls).toEqual(['acquire:thinking']);
+        h.clear();
+        h.clear();
+        expect(cleared).toBe(1);
+    });
+});

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/registry-resolve.test.d.ts

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

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

@@ -0,0 +1,26 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { VerbRegistry } from './registry';
+import { registerVerb, __resetViewRegistryForTest } from '../shards/registry';
+const sh3Verb = { name: 'apps', summary: '', async run() { } };
+const globalVerb = { name: 'clear', summary: '', globalVerb: true, async run() { } };
+describe('VerbRegistry.resolve — globalOnly option', () => {
+    beforeEach(() => {
+        __resetViewRegistryForTest();
+        registerVerb('apps', sh3Verb);
+        registerVerb('clear', globalVerb);
+    });
+    it('without globalOnly resolves any registered verb', () => {
+        const r = new VerbRegistry();
+        expect(r.resolve('apps').kind).toBe('local');
+        expect(r.resolve('clear').kind).toBe('local');
+    });
+    it('with globalOnly only resolves globalVerb=true entries', () => {
+        const r = new VerbRegistry();
+        expect(r.resolve('apps', { globalOnly: true }).kind).toBe('forward');
+        expect(r.resolve('clear', { globalOnly: true }).kind).toBe('local');
+    });
+    it('the $ escape always forwards regardless of globalOnly', () => {
+        const r = new VerbRegistry();
+        expect(r.resolve('$ ls', { globalOnly: true }).kind).toBe('forward');
+    });
+});

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

@@ -3,5 +3,16 @@ export type { Verb, VerbContext, Resolution, ShellApi };
 export declare class VerbRegistry {
     list(): Verb[];
     get(name: string): Verb | undefined;
-    resolve(line: string): Resolution;
+    /**
+     * Resolve a submitted line to a local verb or a forward instruction.
+     *
+     * @param line The user-submitted line.
+     * @param opts.globalOnly When true, only verbs declared with `globalVerb:
+     *   true` resolve locally; everything else forwards. Used by the dispatch
+     *   path to gate sh3-domain verbs to sh3 mode while keeping framework
+     *   controls (clear, mode) reachable from every mode.
+     */
+    resolve(line: string, opts?: {
+        globalOnly?: boolean;
+    }): Resolution;
 }

package/dist/shell-shard/registry.js

@@ -14,7 +14,16 @@ export class VerbRegistry {
     get(name) {
         return getVerb(name);
     }
-    resolve(line) {
+    /**
+     * Resolve a submitted line to a local verb or a forward instruction.
+     *
+     * @param line The user-submitted line.
+     * @param opts.globalOnly When true, only verbs declared with `globalVerb:
+     *   true` resolve locally; everything else forwards. Used by the dispatch
+     *   path to gate sh3-domain verbs to sh3 mode while keeping framework
+     *   controls (clear, mode) reachable from every mode.
+     */
+    resolve(line, opts = {}) {
         const trimmed = line.trim();
         if (!trimmed)
             return { kind: 'forward', line };
@@ -32,6 +41,8 @@ export class VerbRegistry {
         const verb = getVerb(head);
         if (!verb)
             return { kind: 'forward', line };
+        if (opts.globalOnly && !verb.globalVerb)
+            return { kind: 'forward', line };
         // Simple space-split for args — verbs can re-tokenize if they need quoting
         const args = rest.length ? rest.split(/\s+/) : [];
         return { kind: 'local', verb, args, line };

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() },
@@ -15,38 +15,45 @@ function scaffold(modeId) {
     const fs = {};
     const shell = {};
     const resolver = {
-        resolve: (line) => line.startsWith('pwd')
-            ? { kind: 'local', verb: { name: 'pwd', run: async () => { } }, args: [], line }
-            : { kind: 'forward', line },
+        resolve: (line, opts = {}) => {
+            // The test only exercises 'pwd' (sh3-domain) and unknown lines.
+            // Under globalOnly, 'pwd' should forward.
+            if (line.startsWith('pwd') && !opts.globalOnly) {
+                return { kind: 'local', verb: { name: 'pwd', run: async () => { } }, args: [], line };
+            }
+            return { kind: 'forward', line };
+        },
     };
-    const dispatch = makeDispatch({
+    const { dispatch } = makeDispatch({
         mode: () => mode,
+        role: () => (modeId === 'bash' ? 'admin' : 'user'),
         resolver,
         scrollback,
         session,
         shell,
         fs,
         cwd: () => '/',
+        busy: () => () => { },
     });
     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/BusySlot.svelte

@@ -0,0 +1,35 @@
+<script lang="ts">
+  interface Props {
+    active: boolean;
+    label: string | null;
+  }
+  let { active, label }: Props = $props();
+</script>
+
+{#if active}
+  <div class="busy" role="status" aria-live="polite">
+    <span class="spinner" aria-hidden="true"></span>
+    {#if label}<span class="label">{label}</span>{/if}
+  </div>
+{/if}
+
+<style>
+  .busy {
+    display: inline-flex;
+    align-items: center;
+    gap: 6px;
+    color: var(--shell-fg-muted, #aaa);
+    font-size: 0.85em;
+  }
+  .spinner {
+    width: 12px;
+    height: 12px;
+    border: 2px solid var(--shell-fg-muted, #aaa);
+    border-top-color: transparent;
+    border-radius: 50%;
+    animation: busy-spin 0.8s linear infinite;
+  }
+  @keyframes busy-spin {
+    to { transform: rotate(360deg); }
+  }
+</style>

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

@@ -0,0 +1,7 @@
+interface Props {
+    active: boolean;
+    label: string | null;
+}
+declare const BusySlot: import("svelte").Component<Props, {}, "">;
+type BusySlot = ReturnType<typeof BusySlot>;
+export default BusySlot;

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/clear.js

@@ -1,6 +1,7 @@
 export const clearVerb = {
     name: 'clear',
     summary: 'Clear the scrollback (local only — other views are unaffected).',
+    globalVerb: true,
     async run(ctx) {
         ctx.scrollback.clear();
     },

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,29 @@
+export const modeVerb = {
+    name: 'mode',
+    summary: 'List or switch shell modes. Usage: mode | mode <id>',
+    globalVerb: true,
+    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;
@@ -79,6 +90,14 @@ export interface VerbContext {
 export interface Verb {
     name: string;
     summary: string;
+    /**
+     * When true, this verb resolves in every shell mode — including bash and
+     * external shards' custom modes. Defaults to false: sh3-domain verbs only
+     * resolve when `mode.id === 'sh3'`. Reserve this flag for verbs whose
+     * action is mode-agnostic (e.g. `clear` clears the local scrollback,
+     * `mode` switches modes — both make sense everywhere).
+     */
+    globalVerb?: boolean;
     run(ctx: VerbContext, args: string[]): Promise<void>;
 }
 export type Resolution = {

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.3";

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.3';

package/package.json

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