sh3-core 0.14.3 → 0.15.0

package/dist/shards/activate.svelte.js

@@ -17,7 +17,8 @@
  *   stays in `registeredShards` — it's still known, just not running.
  */
 import { shell } from '../shellRuntime.svelte';
-import { registerView, unregisterView, registerVerb as fwRegisterVerb, unregisterVerb as fwUnregisterVerb } from './registry';
+import { registerView, unregisterView, registerVerb as fwRegisterVerb, unregisterVerb as fwUnregisterVerb, listVerbsWithShard } from './registry';
+import { runVerbProgrammatic } from '../runtime/runVerb';
 import { createDocumentHandle, getTenantId, getDocumentBackend } from '../documents';
 import { fetchEnvState, putEnvState } from '../env/client';
 import { isAdmin as checkIsAdmin } from '../auth/index';
@@ -28,7 +29,7 @@ import { createBrowseCapability } from '../documents/browse';
 import { createShardKeysApi } from '../keys/client';
 import { PERMISSION_KEYS_MINT } from '../keys/types';
 import { subscribe } from '../keys/revocation-bus.svelte';
-import { register as contributionsRegister, list as contributionsList, listPoints as contributionsListPoints, onChange as contributionsOnChange, } from '../contributions';
+import { register as contributionsRegister, list as contributionsList, listPoints as contributionsListPoints, onChange as contributionsOnChange, onAnyChange as contributionsOnAnyChange, } from '../contributions';
 import { registerAction } from '../actions/registry';
 import { makeSelectionApi, clearSelectionForShard } from '../actions/selection.svelte';
 import { openContextMenu as shellOpenContextMenu, openPalette as shellOpenPalette } from '../actions/listeners';
@@ -122,6 +123,11 @@ export async function activateShard(id, opts) {
             entry.cleanupFns.push(async () => off());
             return off;
         },
+        onAnyChange(cb) {
+            const off = contributionsOnAnyChange(cb);
+            entry.cleanupFns.push(async () => off());
+            return off;
+        },
     };
     const ctx = {
         state: (schema) => shell.state(id, schema),
@@ -131,7 +137,7 @@ export async function activateShard(id, opts) {
         },
         registerVerb: (verb) => {
             const prefixed = id === 'shell' ? verb.name : `${id}:${verb.name}`;
-            fwRegisterVerb(prefixed, Object.assign(Object.assign({}, verb), { name: prefixed }));
+            fwRegisterVerb(prefixed, Object.assign(Object.assign({}, verb), { name: prefixed }), id);
             entry.verbNames.add(prefixed);
         },
         documents: (options) => {
@@ -195,6 +201,17 @@ export async function activateShard(id, opts) {
             openContextMenu(opts) { shellOpenContextMenu(opts); },
             openPalette(opts) { shellOpenPalette(opts); },
         },
+        listVerbs() {
+            return listVerbsWithShard().map(({ verb, shardId }) => ({
+                shardId,
+                name: verb.name,
+                summary: verb.summary,
+                schema: verb.schema,
+            }));
+        },
+        runVerb(shardId, name, args, opts) {
+            return runVerbProgrammatic(shardId, name, args, opts);
+        },
     };
     entry.ctx = ctx;
     // Wire onKeyRevoked hook: subscribe to the revocation bus for this shard.

package/dist/shards/registry.d.ts

@@ -5,9 +5,19 @@ export declare function registerView(viewId: string, factory: ViewFactory): void
 export declare function getView(viewId: string): ViewFactory | undefined;
 export declare function unregisterView(viewId: string): void;
 import type { Verb } from '../verbs/types';
-export declare function registerVerb(name: string, verb: Verb): void;
+export declare function registerVerb(name: string, verb: Verb, shardId: string): void;
 export declare function getVerb(name: string): Verb | undefined;
 export declare function unregisterVerb(name: string): void;
 export declare function listVerbs(): Verb[];
+/**
+ * Like `listVerbs`, but also exposes the `shardId` each verb belongs to.
+ * Used by `ctx.listVerbs()` so callers don't have to parse the
+ * shardId-prefixed verb name. Order is undefined — callers that want
+ * sorted output sort themselves.
+ */
+export declare function listVerbsWithShard(): Array<{
+    verb: Verb;
+    shardId: string;
+}>;
 /** Test-only reset: clear the view and verb registries. */
 export declare function __resetViewRegistryForTest(): void;

package/dist/shards/registry.js

@@ -38,20 +38,32 @@ export function unregisterView(viewId) {
     views.delete(viewId);
 }
 const verbs = new Map();
-export function registerVerb(name, verb) {
+export function registerVerb(name, verb, shardId) {
     if (verbs.has(name)) {
         throw new Error(`Verb "${name}" is already registered`);
     }
-    verbs.set(name, verb);
+    verbs.set(name, { verb, shardId });
 }
 export function getVerb(name) {
-    return verbs.get(name);
+    var _a;
+    return (_a = verbs.get(name)) === null || _a === void 0 ? void 0 : _a.verb;
 }
 export function unregisterVerb(name) {
     verbs.delete(name);
 }
 export function listVerbs() {
-    return Array.from(verbs.values()).sort((a, b) => a.name.localeCompare(b.name));
+    return Array.from(verbs.values())
+        .map((entry) => entry.verb)
+        .sort((a, b) => a.name.localeCompare(b.name));
+}
+/**
+ * Like `listVerbs`, but also exposes the `shardId` each verb belongs to.
+ * Used by `ctx.listVerbs()` so callers don't have to parse the
+ * shardId-prefixed verb name. Order is undefined — callers that want
+ * sorted output sort themselves.
+ */
+export function listVerbsWithShard() {
+    return Array.from(verbs.values()).map((entry) => (Object.assign({}, entry)));
 }
 /** Test-only reset: clear the view and verb registries. */
 export function __resetViewRegistryForTest() {

package/dist/shards/registry.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach } from 'vitest';
-import { registerVerb, getVerb, unregisterVerb, listVerbs, } from './registry';
+import { registerVerb, getVerb, unregisterVerb, listVerbs, listVerbsWithShard, } from './registry';
 function makeStubVerb(name) {
     return { name, summary: `stub ${name}`, run: async () => { } };
 }
@@ -10,53 +10,61 @@ describe('verb registry', () => {
             unregisterVerb(name);
         registered.length = 0;
     });
-    function trackVerb(name, verb) {
-        registerVerb(name, verb);
+    function trackVerb(name, verb, shardId) {
+        registerVerb(name, verb, shardId);
         registered.push(name);
     }
     it('registers and retrieves a verb by name', () => {
         const verb = makeStubVerb('foo');
-        trackVerb('foo', verb);
+        trackVerb('foo', verb, 'shell');
         expect(getVerb('foo')).toBe(verb);
     });
     it('returns undefined for unknown verb', () => {
         expect(getVerb('nope')).toBeUndefined();
     });
     it('throws on duplicate verb name', () => {
-        trackVerb('dup', makeStubVerb('dup'));
-        expect(() => trackVerb('dup', makeStubVerb('dup'))).toThrowError('Verb "dup" is already registered');
+        trackVerb('dup', makeStubVerb('dup'), 'shell');
+        expect(() => trackVerb('dup', makeStubVerb('dup'), 'shell')).toThrowError('Verb "dup" is already registered');
     });
     it('unregisters a verb', () => {
-        trackVerb('gone', makeStubVerb('gone'));
+        trackVerb('gone', makeStubVerb('gone'), 'shell');
         unregisterVerb('gone');
         registered.pop();
         expect(getVerb('gone')).toBeUndefined();
     });
-    it('lists verbs sorted by name', () => {
-        trackVerb('zeta', makeStubVerb('zeta'));
-        trackVerb('alpha', makeStubVerb('alpha'));
-        trackVerb('mid', makeStubVerb('mid'));
+    it('lists verbs sorted by name (legacy shape)', () => {
+        trackVerb('zeta', makeStubVerb('zeta'), 'shell');
+        trackVerb('alpha', makeStubVerb('alpha'), 'shell');
+        trackVerb('mid', makeStubVerb('mid'), 'shell');
         const names = listVerbs().map((v) => v.name);
         expect(names).toEqual(['alpha', 'mid', 'zeta']);
     });
+    it('listVerbsWithShard returns shardId per entry', () => {
+        trackVerb('apps', makeStubVerb('apps'), 'shell');
+        trackVerb('sh3-store:install', makeStubVerb('sh3-store:install'), 'sh3-store');
+        const result = listVerbsWithShard();
+        const apps = result.find((e) => e.verb.name === 'apps');
+        const install = result.find((e) => e.verb.name === 'sh3-store:install');
+        expect(apps === null || apps === void 0 ? void 0 : apps.shardId).toBe('shell');
+        expect(install === null || install === void 0 ? void 0 : install.shardId).toBe('sh3-store');
+    });
     it('stores prefixed name inside verb object (mirrors activate auto-prefix)', () => {
-        // activate.svelte.ts does: { ...verb, name: prefixed }
         const original = makeStubVerb('install');
         const prefixed = Object.assign(Object.assign({}, original), { name: 'registry:install' });
-        trackVerb('registry:install', prefixed);
+        trackVerb('registry:install', prefixed, 'registry');
         const found = getVerb('registry:install');
         expect(found === null || found === void 0 ? void 0 : found.name).toBe('registry:install');
         expect(found === null || found === void 0 ? void 0 : found.summary).toBe('stub install');
     });
     it('bulk unregister simulates deactivate cleanup', () => {
-        // activate.svelte.ts tracks verbNames and unregisters on deactivate
         const names = ['registry:install', 'registry:search', 'registry:info'];
         for (const name of names)
-            trackVerb(name, makeStubVerb(name));
+            trackVerb(name, makeStubVerb(name), 'registry');
         expect(listVerbs()).toHaveLength(3);
         for (const name of names)
             unregisterVerb(name);
-        registered.length = 0; // already cleaned
+        registered.length = 0;
         expect(listVerbs()).toHaveLength(0);
+        expect(listVerbsWithShard()).toHaveLength(0);
     });
 });

package/dist/shards/types.d.ts

@@ -3,7 +3,8 @@ import type { ZoneSchema, ZoneManager } from '../state/types';
 import type { DocumentHandle, DocumentHandleOptions } from '../documents/types';
 import type { BrowseCapability } from '../documents/browse';
 import type { EnvState } from '../env/types';
-import type { Verb } from '../verbs/types';
+import type { Verb, VerbSchema } from '../verbs/types';
+import type { ScrollbackEntry } from '../shell-shard/scrollback.svelte';
 import type { ShardContextKeys } from '../keys/types';
 import type { ContributionsApi } from '../contributions/types';
 import type { ActionsApi } from '../actions/types';
@@ -251,6 +252,42 @@ export interface ShardContext {
      * entries). Actions are auto-unregistered when the shard deactivates.
      */
     actions: ActionsApi;
+    /**
+     * Read-only snapshot of every verb registered across every active shard.
+     * Returned entries include the contributing `shardId`, the prefixed
+     * `name`, the verb's `summary`, and (when present) its `schema`.
+     * Order is undefined.
+     *
+     * No permission gate — verb names + summaries are already visible via
+     * the `help` verb. Diagnostic and AI-class shards (sh3-ai, sh3-diagnostic)
+     * use this to enumerate the host's action surface.
+     */
+    listVerbs(): Array<{
+        shardId: string;
+        name: string;
+        summary: string;
+        schema?: VerbSchema;
+    }>;
+    /**
+     * Programmatically dispatch a verb by `(shardId, name)`. Resolves with
+     * `{ result, scrollback }` where `scrollback` is the array of entries
+     * the verb pushed during invocation. Rejects on:
+     *   - unknown shardId,
+     *   - unknown verb,
+     *   - target verb not opted in via `programmatic: true`,
+     *   - any error thrown by the verb's `run`.
+     *
+     * Pass `opts.structured` to populate `ctx.structuredArgs` for verbs
+     * that declare `schema.input`. Pass `opts.signal` for cooperative
+     * cancellation (verbs must opt in to honor it).
+     */
+    runVerb(shardId: string, name: string, args: string[], opts?: {
+        signal?: AbortSignal;
+        structured?: unknown;
+    }): Promise<{
+        result: unknown;
+        scrollback: ScrollbackEntry[];
+    }>;
 }
 /**
  * A shard module. Shards are the fundamental unit of contribution in SH3.

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

@@ -6,8 +6,8 @@ const globalVerb = { name: 'clear', summary: '', globalVerb: true, async run() {
 describe('VerbRegistry.resolve — globalOnly option', () => {
     beforeEach(() => {
         __resetViewRegistryForTest();
-        registerVerb('apps', sh3Verb);
-        registerVerb('clear', globalVerb);
+        registerVerb('apps', sh3Verb, 'shell');
+        registerVerb('clear', globalVerb, 'shell');
     });
     it('without globalOnly resolves any registered verb', () => {
         const r = new VerbRegistry();

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