sh3-core 0.14.0 → 0.15.0

package/dist/shell-shard/dispatch.js

@@ -11,6 +11,67 @@
 import { makeShellModeOutput } from './output';
 export function makeDispatch(deps) {
     let activeController = null;
+    /**
+     * Programmatic cross-mode dispatch. Validates target id, role gate, and
+     * self-invoke; routes to sh3 (full local resolution), bash (WS forward
+     * with lazy connect), or a custom descriptor (recursive desc.dispatch).
+     *
+     * sh3 path bypasses mode gating: a verb's globalVerb flag is irrelevant
+     * because the caller is a trusted mode shard, not user input from a
+     * different mode.
+     */
+    let bashConnected = false;
+    async function invoke(modeId, line) {
+        var _a, _b, _c, _d;
+        const current = deps.mode();
+        if (modeId === current.id) {
+            throw new Error(`invoke: cannot invoke own mode '${modeId}'`);
+        }
+        if (modeId === 'sh3') {
+            const resolution = deps.resolver.resolve(line, { globalOnly: false });
+            if (resolution.kind === 'forward') {
+                const head = (_a = line.trim().split(/\s+/)[0]) !== null && _a !== void 0 ? _a : '';
+                throw new Error(`invoke: unknown sh3 verb '${head}'`);
+            }
+            await resolution.verb.run({
+                shell: deps.shell,
+                scrollback: deps.scrollback,
+                session: deps.session,
+                cwd: deps.cwd(),
+                dispatch,
+                fs: deps.fs,
+            }, resolution.args);
+            return;
+        }
+        if (modeId === 'bash') {
+            if (deps.role() !== 'admin') {
+                throw new Error("invoke: 'bash' requires admin role");
+            }
+            if (!bashConnected) {
+                bashConnected = true;
+                deps.session.connect();
+            }
+            deps.session.send({ t: 'submit', line });
+            return;
+        }
+        // Custom mode
+        const desc = (_c = (_b = deps.customMode) === null || _b === void 0 ? void 0 : _b.call(deps, modeId)) !== null && _c !== void 0 ? _c : null;
+        if (!desc) {
+            throw new Error(`invoke: unknown mode '${modeId}'`);
+        }
+        if (desc.requiresRole && desc.requiresRole !== deps.role()) {
+            throw new Error(`invoke: mode '${modeId}' requires ${desc.requiresRole} role`);
+        }
+        if (desc.runsOn === 'server') {
+            throw new Error('invoke: server-side modes are not yet supported');
+        }
+        const subOutput = makeShellModeOutput({
+            scrollback: deps.scrollback,
+            busy: deps.busy,
+            invoke,
+        });
+        await desc.dispatch({ line, cwd: deps.cwd(), signal: (_d = activeController === null || activeController === void 0 ? void 0 : activeController.signal) !== null && _d !== void 0 ? _d : new AbortController().signal }, subOutput);
+    }
     async function dispatch(line) {
         var _a, _b, _c, _d;
         // Abort any in-flight custom dispatch when a new line is submitted.
@@ -25,7 +86,9 @@ export function makeDispatch(deps) {
             deps.scrollback.push({ kind: 'status', text: 'shell: server shell not available in user mode', level: 'error', ts: Date.now() });
             return;
         }
-        const resolution = deps.resolver.resolve(line);
+        const resolution = deps.resolver.resolve(line, {
+            globalOnly: mode.id !== 'sh3',
+        });
         if (resolution.kind === 'local') {
             // Log locally-dispatched verbs for shared history (ws only)
             if (mode.transport === 'ws') {
@@ -78,7 +141,12 @@ export function makeDispatch(deps) {
                 });
                 return;
             }
-            const output = makeShellModeOutput(deps.scrollback);
+            const output = makeShellModeOutput({
+                scrollback: deps.scrollback,
+                busy: deps.busy,
+                invoke,
+            });
+            const clearBusy = deps.busy();
             try {
                 await desc.dispatch({ line: resolution.line, cwd: deps.cwd(), signal: controller.signal }, output);
             }
@@ -95,6 +163,9 @@ export function makeDispatch(deps) {
                     });
                 }
             }
+            finally {
+                clearBusy();
+            }
             return;
         }
         // 'none' transport, unknown verb: print error

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

@@ -1,3 +1,10 @@
 import type { Scrollback } from './scrollback.svelte';
 import type { ShellModeOutput } from './contract';
-export declare function makeShellModeOutput(sb: Scrollback): ShellModeOutput;
+export interface ShellModeOutputDeps {
+    scrollback: Scrollback;
+    /** Acquire a busy indicator; returns a clear handle. */
+    busy: (label?: string) => () => void;
+    /** Programmatically dispatch a line through another mode's resolution path. */
+    invoke: (modeId: string, line: string) => Promise<void>;
+}
+export declare function makeShellModeOutput(deps: ShellModeOutputDeps): ShellModeOutput;

package/dist/shell-shard/output.js

@@ -24,7 +24,8 @@ function lastRichId(sb) {
     const last = sb.entries[sb.entries.length - 1];
     return last.id;
 }
-export function makeShellModeOutput(sb) {
+export function makeShellModeOutput(deps) {
+    const sb = deps.scrollback;
     return {
         text(stream, chunk) {
             sb.push({ kind: 'text', stream, chunks: [chunk], ts: Date.now() });
@@ -71,5 +72,20 @@ export function makeShellModeOutput(sb) {
                 },
             };
         },
+        busy(label) {
+            const clearController = deps.busy(label);
+            let cleared = false;
+            return {
+                clear() {
+                    if (cleared)
+                        return;
+                    cleared = true;
+                    clearController();
+                },
+            };
+        },
+        invoke(modeId, line) {
+            return deps.invoke(modeId, line);
+        },
     };
 }

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

@@ -2,10 +2,12 @@ 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(sb);
+        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');
@@ -14,7 +16,7 @@ describe('makeShellModeOutput', () => {
     });
     it('status() pushes a status entry with the right level', () => {
         const sb = new Scrollback();
-        const out = makeShellModeOutput(sb);
+        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();
@@ -23,7 +25,7 @@ describe('makeShellModeOutput', () => {
     });
     it('rich().update() mutates the live entry props', () => {
         const sb = new Scrollback();
-        const out = makeShellModeOutput(sb);
+        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');
@@ -31,7 +33,7 @@ describe('makeShellModeOutput', () => {
     });
     it('stream() marks the entry mid-stream until complete()', () => {
         const sb = new Scrollback();
-        const out = makeShellModeOutput(sb);
+        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');
@@ -42,7 +44,7 @@ describe('makeShellModeOutput', () => {
     });
     it('stream().error() marks the entry errored and pushes a status', () => {
         const sb = new Scrollback();
-        const out = makeShellModeOutput(sb);
+        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');
@@ -52,3 +54,20 @@ describe('makeShellModeOutput', () => {
         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/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, 'shell');
+        registerVerb('clear', globalVerb, 'shell');
+    });
+    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/shellApi.d.ts

@@ -0,0 +1,3 @@
+import type { ShellApi } from './registry';
+export declare function makeShellApiHeadless(): ShellApi;
+export declare function makeShellApiForTest(): ShellApi;

package/dist/shell-shard/shellApi.js

@@ -0,0 +1,142 @@
+/*
+ * Headless ShellApi factory.
+ *
+ * Built only from framework primitives (apps registry, layout inspection,
+ * auth, float manager). No Svelte component imports — safe to load from
+ * any test project, including the node-only project, and from
+ * runtime/runVerb.ts which builds a synthesized VerbContext.
+ *
+ * Mode-related methods (`setMode`, `listModes`) stub to false / [];
+ * Terminal.svelte wraps this with mode-aware closures.
+ */
+import { listRegisteredApps, getActiveApp } from '../apps/registry.svelte';
+import { launchApp } from '../apps/lifecycle';
+import { registeredShards, listStandaloneViews } from '../shards/activate.svelte';
+import { inspectActiveLayout, focusView, closeTab, popoutView, dockFloat, dockIntoActiveLayout, locateSlot as locateSlotInActiveLayout, } from '../layout/inspection';
+import { floatManager } from '../overlays/float';
+import { getUser, isAdmin } from '../auth/index';
+function collectTabEntries(node) {
+    if (node.type === 'tabs') {
+        return node.tabs.filter((t) => t.viewId !== null);
+    }
+    if (node.type === 'split') {
+        return node.children.flatMap(collectTabEntries);
+    }
+    if (node.viewId !== null) {
+        return [{ slotId: node.slotId, viewId: node.viewId, label: node.viewId }];
+    }
+    return [];
+}
+export function makeShellApiHeadless() {
+    return {
+        listApps() {
+            return listRegisteredApps().map((m) => ({ id: m.id, label: m.label }));
+        },
+        getActiveApp() {
+            const m = getActiveApp();
+            return m ? { id: m.id, label: m.label } : null;
+        },
+        launchApp(id) {
+            void launchApp(id);
+        },
+        listShards() {
+            return Array.from(registeredShards.values()).map((s) => ({
+                id: s.manifest.id,
+                label: s.manifest.label,
+                version: s.manifest.version,
+            }));
+        },
+        listViewsInCurrentLayout() {
+            try {
+                const { root } = inspectActiveLayout();
+                return collectTabEntries(root.docked).map((t) => {
+                    var _a;
+                    return ({
+                        slotId: t.slotId,
+                        viewId: (_a = t.viewId) !== null && _a !== void 0 ? _a : '',
+                        label: t.label,
+                    });
+                });
+            }
+            catch (_a) {
+                return [];
+            }
+        },
+        openViewInCurrentLayout(viewId) {
+            try {
+                if (focusView(viewId))
+                    return { ok: true };
+                const standalone = listStandaloneViews().find((v) => v.viewId === viewId);
+                if (standalone) {
+                    const slotId = `standalone:${viewId}:${Date.now()}`;
+                    const ok = dockIntoActiveLayout({ slotId, viewId, label: standalone.label });
+                    return ok ? { ok: true } : { ok: false, error: `could not dock "${viewId}" — no available slot` };
+                }
+                return { ok: false, error: `view "${viewId}" not found in current layout` };
+            }
+            catch (err) {
+                return { ok: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+        listStandaloneViews() {
+            return listStandaloneViews();
+        },
+        popoutSlot(slotId) {
+            try {
+                const floatId = popoutView(slotId);
+                return floatId ? { ok: true, floatId } : { ok: false, error: `slot "${slotId}" not found in docked tree` };
+            }
+            catch (err) {
+                return { ok: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+        dockFloat(floatId) {
+            try {
+                const ok = dockFloat(floatId);
+                return ok ? { ok: true } : { ok: false, error: `float "${floatId}" not found or has no dockable content` };
+            }
+            catch (err) {
+                return { ok: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+        locateSlot(slotId) {
+            try {
+                return locateSlotInActiveLayout(slotId);
+            }
+            catch (_a) {
+                return null;
+            }
+        },
+        listFloats() {
+            return floatManager.list().map((f) => {
+                var _a, _b, _c, _d, _e;
+                const tabs = f.content.type === 'tabs' ? f.content : null;
+                const active = tabs ? (_b = tabs.tabs[(_a = tabs.activeTab) !== null && _a !== void 0 ? _a : 0]) !== null && _b !== void 0 ? _b : tabs.tabs[0] : null;
+                return {
+                    floatId: f.id,
+                    viewId: (_c = active === null || active === void 0 ? void 0 : active.viewId) !== null && _c !== void 0 ? _c : null,
+                    label: (_e = (_d = f.title) !== null && _d !== void 0 ? _d : active === null || active === void 0 ? void 0 : active.label) !== null && _e !== void 0 ? _e : f.id,
+                };
+            });
+        },
+        closeSlot(slotId) {
+            void closeTab(slotId);
+            return { ok: true };
+        },
+        listZones(_shardId) { return []; },
+        readZone(_shardId, _zoneName) { return null; },
+        whoAmI() {
+            var _a;
+            const user = getUser();
+            return {
+                userId: (_a = user === null || user === void 0 ? void 0 : user.id) !== null && _a !== void 0 ? _a : 'guest',
+                admin: isAdmin(),
+            };
+        },
+        setMode(_id) { return false; },
+        listModes() { return []; },
+    };
+}
+export function makeShellApiForTest() {
+    return makeShellApiHeadless();
+}

package/dist/shell-shard/shellShard.svelte.d.ts

@@ -1,9 +1,3 @@
 import type { Shard } from '../api';
-import type { ShellApi } from './registry';
-/**
- * Test-only ShellApi constructor. Bypasses the admin gate and uses a
- * stub ShardContext. Only methods that do not consult `ctx` are
- * guaranteed to work — `locateSlot`, `listFloats`, `listApps`, etc.
- */
-export declare function makeShellApiForTest(): ShellApi;
+export { makeShellApiHeadless, makeShellApiForTest } from './shellApi';
 export declare const shellShard: Shard;

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

@@ -11,180 +11,25 @@
  *
  * autostart() is defined so the shard activates at boot without requiring
  * a dedicated app to launch it first, matching the __sh3core__ pattern.
+ *
+ * The headless ShellApi factory lives in ./shellApi.ts so non-DOM callers
+ * (node-only test project, runtime/runVerb) can build a ShellApi without
+ * pulling in Terminal.svelte.
  */
 import { mount, unmount } from 'svelte';
 import { manifest } from './manifest';
 import Terminal from './Terminal.svelte';
 import { registerV1Verbs } from './verbs';
-import { listRegisteredApps, getActiveApp } from '../apps/registry.svelte';
-import { launchApp } from '../apps/lifecycle';
-import { registeredShards } from '../shards/activate.svelte';
-import { inspectActiveLayout, focusView, closeTab, popoutView, dockFloat, dockIntoActiveLayout, locateSlot as locateSlotInActiveLayout } from '../layout/inspection';
+import { makeShellApiHeadless } from './shellApi';
+import { focusView } from '../layout/inspection';
 import { floatManager } from '../overlays/float';
-import { listStandaloneViews } from '../shards/activate.svelte';
 import { getUser, isAdmin } from '../auth/index';
-/** Walk a layout tree and collect all tab entries (slotId + viewId + label). */
-function collectTabEntries(node) {
-    if (node.type === 'tabs') {
-        return node.tabs.filter((t) => t.viewId !== null);
-    }
-    if (node.type === 'split') {
-        return node.children.flatMap(collectTabEntries);
-    }
-    // slot node: wrap as a synthetic tab entry if it has a viewId
-    if (node.viewId !== null) {
-        return [{ slotId: node.slotId, viewId: node.viewId, label: node.viewId }];
-    }
-    return [];
-}
-function makeShellApi(_ctx) {
-    return {
-        // → apps/registry.svelte: listRegisteredApps() returns AppManifest[]
-        listApps() {
-            return listRegisteredApps().map((m) => ({ id: m.id, label: m.label }));
-        },
-        // → apps/registry.svelte: getActiveApp() returns AppManifest | null
-        getActiveApp() {
-            const m = getActiveApp();
-            return m ? { id: m.id, label: m.label } : null;
-        },
-        // → apps/lifecycle: launchApp() is async; fire-and-forget to keep ShellApi sync.
-        // Verb handlers display feedback independently via scrollback.
-        launchApp(id) {
-            void launchApp(id);
-        },
-        // → shards/activate.svelte: registeredShards reactive map
-        listShards() {
-            return Array.from(registeredShards.values()).map((s) => ({
-                id: s.manifest.id,
-                label: s.manifest.label,
-                version: s.manifest.version,
-            }));
-        },
-        // → layout/inspection: inspectActiveLayout() + tree walk
-        listViewsInCurrentLayout() {
-            try {
-                const { root } = inspectActiveLayout();
-                return collectTabEntries(root.docked).map((t) => {
-                    var _a;
-                    return ({
-                        slotId: t.slotId,
-                        viewId: (_a = t.viewId) !== null && _a !== void 0 ? _a : '',
-                        label: t.label,
-                    });
-                });
-            }
-            catch (_a) {
-                return [];
-            }
-        },
-        // → layout/inspection: focusView(viewId). Falls back to dockIntoActiveLayout
-        // for standalone views that aren't mounted yet — this is the single
-        // "summon" entry point wired behind the `open` verb.
-        openViewInCurrentLayout(viewId) {
-            try {
-                if (focusView(viewId))
-                    return { ok: true };
-                const standalone = listStandaloneViews().find((v) => v.viewId === viewId);
-                if (standalone) {
-                    const slotId = `standalone:${viewId}:${Date.now()}`;
-                    const ok = dockIntoActiveLayout({ slotId, viewId, label: standalone.label });
-                    return ok ? { ok: true } : { ok: false, error: `could not dock "${viewId}" — no available slot` };
-                }
-                return { ok: false, error: `view "${viewId}" not found in current layout` };
-            }
-            catch (err) {
-                return { ok: false, error: err instanceof Error ? err.message : String(err) };
-            }
-        },
-        // → shards/activate.svelte: listStandaloneViews() walks activeShards
-        listStandaloneViews() {
-            return listStandaloneViews();
-        },
-        // → layout/inspection: popoutView(slotId) returns floatId | null
-        popoutSlot(slotId) {
-            try {
-                const floatId = popoutView(slotId);
-                return floatId ? { ok: true, floatId } : { ok: false, error: `slot "${slotId}" not found in docked tree` };
-            }
-            catch (err) {
-                return { ok: false, error: err instanceof Error ? err.message : String(err) };
-            }
-        },
-        // → layout/inspection: dockFloat(floatId) returns boolean
-        dockFloat(floatId) {
-            try {
-                const ok = dockFloat(floatId);
-                return ok ? { ok: true } : { ok: false, error: `float "${floatId}" not found or has no dockable content` };
-            }
-            catch (err) {
-                return { ok: false, error: err instanceof Error ? err.message : String(err) };
-            }
-        },
-        // → layout/inspection: locateSlot(slotId) returns TreeRootRef | null
-        locateSlot(slotId) {
-            try {
-                return locateSlotInActiveLayout(slotId);
-            }
-            catch (_a) {
-                return null;
-            }
-        },
-        // → overlays/float: floatManager.list() returns FloatEntry[]
-        listFloats() {
-            return floatManager.list().map((f) => {
-                var _a, _b, _c, _d, _e;
-                const tabs = f.content.type === 'tabs' ? f.content : null;
-                const active = tabs ? (_b = tabs.tabs[(_a = tabs.activeTab) !== null && _a !== void 0 ? _a : 0]) !== null && _b !== void 0 ? _b : tabs.tabs[0] : null;
-                return {
-                    floatId: f.id,
-                    viewId: (_c = active === null || active === void 0 ? void 0 : active.viewId) !== null && _c !== void 0 ? _c : null,
-                    label: (_e = (_d = f.title) !== null && _d !== void 0 ? _d : active === null || active === void 0 ? void 0 : active.label) !== null && _e !== void 0 ? _e : f.id,
-                };
-            });
-        },
-        // → layout/inspection: closeTab(slotId) is async (guarded close).
-        // Fire-and-forget; the tab disappears asynchronously. ShellApi stays sync.
-        closeSlot(slotId) {
-            void closeTab(slotId);
-            return { ok: true };
-        },
-        // TODO Phase 10: wire to zone manager when state:manage permission is available.
-        // The shell manifest declares permissions: [] so ctx.zones is undefined.
-        // A future permission grant + ctx.zones.list() would power these.
-        listZones(_shardId) { return []; },
-        readZone(_shardId, _zoneName) { return null; },
-        // → auth/index: getUser() + isAdmin()
-        whoAmI() {
-            var _a;
-            const user = getUser();
-            return {
-                userId: (_a = user === null || user === void 0 ? void 0 : user.id) !== null && _a !== void 0 ? _a : 'guest',
-                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 []; },
-    };
-}
-/**
- * Test-only ShellApi constructor. Bypasses the admin gate and uses a
- * stub ShardContext. Only methods that do not consult `ctx` are
- * guaranteed to work — `locateSlot`, `listFloats`, `listApps`, etc.
- */
-export function makeShellApiForTest() {
-    return makeShellApi({});
-}
+export { makeShellApiHeadless, makeShellApiForTest } from './shellApi';
 export const shellShard = {
     manifest,
     activate(ctx) {
         registerV1Verbs(ctx);
-        const shell = makeShellApi(ctx);
+        const shell = makeShellApiHeadless();
         // The AZERTY `²` key (top-left on FR keyboards, below Escape) opens the
         // terminal view — focusing it if already mounted, floating it otherwise.
         // Migrated from Shell.svelte's inline keydown handler as proof-of-concept

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

@@ -15,18 +15,25 @@ 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({
         mode: () => mode,
+        role: () => (modeId === 'bash' ? 'admin' : 'user'),
         resolver,
         scrollback,
         session,
         shell,
         fs,
         cwd: () => '/',
+        busy: () => () => { },
     });
     return { dispatch, sent, pushed };
 }