@deepseek-harness-tui/dsh-tui 0.10.0 → 0.10.2

package/lib/types/adapter/kernel/runtime.js

@@ -0,0 +1,325 @@
+/**
+ * Adapter runtime / shadow-mode switch and effect-class enforcement.
+ *
+ * This is the Kernel's incremental-migration control surface. It does not load
+ * drivers or perform business translation; it selects and records shadow
+ * policy per capability, and provides the unified assertion every
+ * effect-producing Port/slice entry must call.
+ */
+import { isReplayIsolationActive } from './replay-isolation.js';
+export const DEFAULT_ADAPTER_MODE = 'legacy';
+/**
+ * Effect classification per adapter capability.
+ *
+ * Every capability that can produce an effect must be registered here so the
+ * runtime can enforce shadow policy uniformly instead of relying on ad-hoc
+ * call-site checks.
+ */
+export const ADAPTER_CAPABILITY_EFFECT_CLASSES = Object.freeze({
+    'host.descriptor': 'read-only',
+    'host.diagnostics': 'read-only',
+    'host.admission': 'mutate',
+    'host.grants.evaluate': 'read-only',
+    'host.grants.subscribe': 'subscribe',
+    'host.ledger.record': 'mutate',
+    'host.commands.register': 'register',
+    'host.commands.invoke': 'mutate',
+    'host.commands.liveProbe': 'register',
+    'host.storage.open': 'mutate',
+    'host.storage.read': 'read-only',
+    'host.storage.write': 'mutate',
+    'host.storage.probe': 'read-only',
+    'host.storage.liveProbe': 'mutate',
+    'host.messages.subscribe': 'subscribe',
+    'host.messages.probe': 'read-only',
+    'host.messages.liveProbe': 'subscribe',
+    'host.decision.subscribe': 'subscribe',
+    'host.decision.probe': 'read-only',
+    'host.presentation.ask': 'mutate',
+    'host.presentation.approve': 'mutate',
+    'host.presentation.dialog': 'mutate',
+    'host.scenes.register': 'register',
+    'host.scenes.list': 'read-only',
+    'host.scenes.open': 'mutate',
+    'host.scenes.close': 'mutate',
+    'host.scenes.active': 'read-only',
+    'host.scenes.subscribe': 'subscribe',
+    'host.settings.register': 'register',
+    'host.settings.list': 'read-only',
+    'host.settings.section': 'read-only',
+    'host.settings.subscribe': 'subscribe',
+    'host.status.set': 'mutate',
+    'host.status.register-view': 'register',
+    'host.status.snapshot': 'read-only',
+    'host.status.subscribe': 'subscribe',
+    'host.renderers.register': 'register',
+    'host.renderers.render': 'read-only',
+    'host.shortcuts.register': 'register',
+    'host.shortcuts.list': 'read-only',
+    'host.shortcuts.dispatch': 'mutate',
+    'host.themes.register': 'register',
+    'host.themes.snapshot': 'read-only',
+    'host.themes.resolver': 'read-only',
+    'host.themes.subscribe': 'subscribe',
+    'host.dialogs.select': 'mutate',
+    'host.dialogs.confirm': 'mutate',
+    'host.dialogs.input': 'mutate',
+    'host.toast.show': 'mutate',
+    'host.command-trees.register': 'register',
+    'host.command-trees.children': 'read-only',
+    'host.command-trees.descriptions': 'read-only',
+    'host.workspaces.register': 'register',
+    'host.workspaces.list': 'read-only',
+    'host.workspaces.resolve': 'read-only',
+    'host.workspaces.describe': 'read-only',
+    'host.workspaces.commandShell': 'mutate',
+    'host.workspaces.rename': 'mutate',
+    'host.workspaces.commands': 'read-only',
+    'host.workspaces.runCommand': 'mutate',
+    'host.channel.projection.ui': 'read-only',
+    'host.channel.projection.snapshot': 'read-only',
+    'host.channel.projection.subscribe': 'subscribe',
+    'host.channel.state.snapshot': 'read-only',
+    'host.channel.transcript.rows': 'read-only',
+    'host.channel.transcript.trace-events': 'read-only',
+    'host.channel.actions.loadOlder': 'mutate',
+    'host.channel.actions.submit': 'mutate',
+    'host.channel.actions.steer': 'mutate',
+    'host.channel.actions.cancel': 'mutate',
+    'host.channel.actions.interruptAndDeliver': 'mutate',
+    'host.channel.actions.clear': 'mutate',
+    'host.channel.actions.notify': 'mutate',
+    'host.channel.actions.new-session': 'mutate',
+    'host.channel.plugins.run-external-command': 'mutate',
+    'host.channel.plugins.open-scene': 'mutate',
+    'host.channel.plugins.close-scene': 'mutate',
+    'host.channel.plugins.settings-sections': 'read-only',
+    'host.channel.plugins.subscribe-settings-sections': 'subscribe',
+});
+/** Map a capability to its incremental migration slice. */
+export const ADAPTER_CAPABILITY_SLICES = Object.freeze({
+    'host.descriptor': 'descriptor',
+    'host.diagnostics': 'descriptor',
+    'host.admission': 'admission',
+    'host.grants.evaluate': 'admission',
+    'host.grants.subscribe': 'admission',
+    'host.ledger.record': 'ledger',
+    'host.commands.register': 'commands',
+    'host.commands.invoke': 'commands',
+    'host.commands.liveProbe': 'commands',
+    'host.storage.open': 'storage',
+    'host.storage.read': 'storage',
+    'host.storage.write': 'storage',
+    'host.storage.probe': 'storage',
+    'host.storage.liveProbe': 'storage',
+    'host.messages.subscribe': 'messages',
+    'host.messages.probe': 'messages',
+    'host.messages.liveProbe': 'messages',
+    'host.decision.subscribe': 'decisions',
+    'host.decision.probe': 'decisions',
+    'host.presentation.ask': 'presentation',
+    'host.presentation.approve': 'presentation',
+    'host.presentation.dialog': 'presentation',
+    'host.scenes.register': 'scenes',
+    'host.scenes.list': 'scenes',
+    'host.scenes.open': 'scenes',
+    'host.scenes.close': 'scenes',
+    'host.scenes.active': 'scenes',
+    'host.scenes.subscribe': 'scenes',
+    'host.settings.register': 'settings',
+    'host.settings.list': 'settings',
+    'host.settings.section': 'settings',
+    'host.settings.subscribe': 'settings',
+    'host.status.set': 'status',
+    'host.status.snapshot': 'status',
+    'host.status.subscribe': 'status',
+    'host.renderers.register': 'renderers',
+    'host.renderers.render': 'renderers',
+    'host.shortcuts.register': 'shortcuts',
+    'host.shortcuts.list': 'shortcuts',
+    'host.shortcuts.dispatch': 'shortcuts',
+    'host.themes.register': 'themes',
+    'host.themes.snapshot': 'themes',
+    'host.themes.resolver': 'themes',
+    'host.themes.subscribe': 'themes',
+    'host.dialogs.select': 'presentation',
+    'host.dialogs.confirm': 'presentation',
+    'host.dialogs.input': 'presentation',
+    'host.toast.show': 'toast',
+    'host.command-trees.register': 'command-trees',
+    'host.command-trees.children': 'command-trees',
+    'host.command-trees.descriptions': 'command-trees',
+    'host.workspaces.register': 'workspaces',
+    'host.workspaces.list': 'workspaces',
+    'host.workspaces.resolve': 'workspaces',
+    'host.workspaces.describe': 'workspaces',
+    'host.workspaces.commandShell': 'workspaces',
+    'host.workspaces.rename': 'workspaces',
+    'host.workspaces.commands': 'workspaces',
+    'host.workspaces.runCommand': 'workspaces',
+    'host.channel.projection.snapshot': 'channel',
+    'host.channel.projection.subscribe': 'channel',
+    'host.channel.state.snapshot': 'channel',
+    'host.channel.transcript.rows': 'channel',
+    'host.channel.transcript.trace-events': 'channel',
+    'host.channel.actions.loadOlder': 'channel',
+    'host.channel.actions.submit': 'channel',
+    'host.channel.actions.new-session': 'channel',
+    'host.channel.actions.steer': 'channel',
+    'host.channel.actions.cancel': 'channel',
+    'host.channel.actions.interruptAndDeliver': 'channel',
+    'host.channel.actions.clear': 'channel',
+    'host.channel.actions.notify': 'channel',
+    'host.channel.plugins.run-external-command': 'channel',
+    'host.channel.plugins.open-scene': 'channel',
+    'host.channel.plugins.close-scene': 'channel',
+    'host.channel.plugins.settings-sections': 'channel',
+    'host.channel.plugins.subscribe-settings-sections': 'channel',
+});
+export function sliceForCapability(capability) {
+    return ADAPTER_CAPABILITY_SLICES[capability];
+}
+/**
+ * If an explicit slice allowlist is provided, only capabilities from those
+ * slices are governed by the selected AdapterMode. An empty/undefined slice
+ * list means the whole adapter surface is governed (the conservative default).
+ */
+function isSelectedSlice(capability, slices) {
+    if (slices === undefined || slices.length === 0)
+        return true;
+    const slice = sliceForCapability(capability);
+    return slice !== undefined && slices.includes(slice);
+}
+export function effectClassFor(capability) {
+    return ADAPTER_CAPABILITY_EFFECT_CLASSES[capability];
+}
+export function parseAdapterMode(value) {
+    const normalized = value?.trim().toLowerCase();
+    switch (normalized) {
+        case undefined:
+            return DEFAULT_ADAPTER_MODE;
+        case 'legacy':
+        case 'passive-shadow':
+        case 'replay-shadow':
+        case 'new':
+            return normalized;
+        default:
+            throw new Error(`dsh-tui: unknown DSH_TUI_ADAPTER_MODE ${JSON.stringify(value)}; valid modes: legacy, passive-shadow, replay-shadow, new`);
+    }
+}
+export const ADAPTER_SLICE_ALIASES = Object.freeze({
+    'dialog': 'presentation',
+    'dialogs': 'presentation',
+    'decision': 'decisions',
+    'decision-events': 'decisions',
+    'decisionevents': 'decisions',
+    'command-tree': 'command-trees',
+    'commandtrees': 'command-trees',
+    'workspace': 'workspaces',
+    'setting': 'settings',
+    'scene': 'scenes',
+    'shortcut': 'shortcuts',
+    'renderer': 'renderers',
+    'theme': 'themes',
+});
+const KNOWN_ADAPTER_SLICES = new Set(Object.values(ADAPTER_CAPABILITY_SLICES));
+function canonicalAdapterSlice(value) {
+    const trimmed = value.trim().toLowerCase();
+    return ADAPTER_SLICE_ALIASES[trimmed] ?? trimmed;
+}
+/**
+ * Normalize an explicit adapter-slice allowlist.
+ *
+ * Slice ids are case-insensitive and surrounding whitespace is ignored.
+ * Known aliases are mapped to their canonical slice id. Unknown ids are
+ * rejected loudly (fail-closed) instead of being silently ignored: a typo in
+ * `DSH_TUI_ADAPTER_SLICES` must never accidentally broaden or narrow the
+ * governed adapter surface without the operator noticing.
+ */
+export function normalizeAdapterSliceList(slices) {
+    const normalized = [];
+    for (const raw of slices) {
+        const name = canonicalAdapterSlice(raw);
+        if (name === '')
+            continue;
+        if (!KNOWN_ADAPTER_SLICES.has(name)) {
+            throw new Error(`dsh-tui: unknown adapter slice "${raw}"; valid slices: ${[...KNOWN_ADAPTER_SLICES].sort().join(', ')}`);
+        }
+        if (!normalized.includes(name))
+            normalized.push(name);
+    }
+    return Object.freeze(normalized);
+}
+export function parseAdapterRuntime(env = process.env) {
+    return Object.freeze({
+        mode: parseAdapterMode(env.DSH_TUI_ADAPTER_MODE),
+        slices: normalizeAdapterSliceList((env.DSH_TUI_ADAPTER_SLICES ?? '').split(',')),
+    });
+}
+/**
+ * Immutable fallback snapshot factory for objects that are not bound to a
+ * Cordis composition (standalone stores, in-package local registries, unbound
+ * grant stores). Each object captures the process environment at construction
+ * time; once captured, that object never re-reads mutable process state.
+ * Production composition-bound services must use `adapterRuntimeFor(ctx)`
+ * instead so each composition root gets its own stable snapshot.
+ */
+export function defaultAdapterRuntime() {
+    return parseAdapterRuntime();
+}
+/**
+ * Effect classification determines which shadow modes are allowed:
+ * - read-only may run as passive shadow and replay shadow;
+ * - subscribe/register require replay or direct switch;
+ * - mutate only runs in legacy/new (it must never pretend to be a shadow).
+ */
+export function isPassiveShadowAllowed(effectClass) {
+    return effectClass === 'read-only';
+}
+export function shadowPolicyAllowed(effectClass, mode) {
+    if (mode === 'legacy' || mode === 'new')
+        return true;
+    if (mode === 'replay-shadow') {
+        // On a real production host replay-shadow is fail-closed: without an
+        // explicit isolated replay section, subscribe/register-capable entries
+        // are refused just like passive-shadow. They are only allowed while the
+        // replay harness has entered an isolated mock/replay context.
+        if (!isReplayIsolationActive())
+            return effectClass === 'read-only';
+        return effectClass !== 'mutate';
+    }
+    return mode === 'passive-shadow' && isPassiveShadowAllowed(effectClass);
+}
+export function assertShadowPolicy(effectClass, mode) {
+    if (!shadowPolicyAllowed(effectClass, mode)) {
+        throw new Error(`dsh-tui: shadow policy denies ${effectClass} in ${mode} mode`);
+    }
+}
+/**
+ * Hard guard-position invariant for adapter capability methods:
+ * every mediated/effectful entry MUST call this guard (or the
+ * `assertAdapterCapability` convenience) as its FIRST side-effect-free
+ * preflight step, BEFORE creating subscriptions, registrations, file watches,
+ * writes, mounts or any other observable side effect. This is also enforced
+ * by `verify:adapter-shadow` for service methods and returned handles.
+ */
+export function assertCapabilityShadowPolicy(capability, mode, slices) {
+    // The slice allowlist is an incremental-migration switch for legacy/new
+    // only. Shadow modes are global safety modes: a capability outside the
+    // listed slice must still be denied if it would produce a real effect.
+    if (!isSelectedSlice(capability, slices) && (mode === 'legacy' || mode === 'new'))
+        return;
+    const effectClass = effectClassFor(capability);
+    if (effectClass === undefined) {
+        throw new Error(`dsh-tui: capability has no registered effect class: ${capability}`);
+    }
+    assertShadowPolicy(effectClass, mode);
+}
+/** Convenience for legacy adapter service methods: parse the process runtime
+ * once per call and assert the capability's shadow policy. This keeps
+ * migration-era service entry points on the same unified effect matrix. */
+let defaultRuntimeSnapshot;
+export function assertAdapterCapability(capability) {
+    defaultRuntimeSnapshot ??= parseAdapterRuntime();
+    assertCapabilityShadowPolicy(capability, defaultRuntimeSnapshot.mode, defaultRuntimeSnapshot.slices);
+}

package/lib/types/adapter/kernel/slices/channel.d.ts

@@ -0,0 +1,3 @@
+import type { KernelSlice } from './types.js';
+export declare const channelSlice: KernelSlice;
+//# sourceMappingURL=channel.d.ts.map

package/lib/types/adapter/kernel/slices/channel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel.d.ts","sourceRoot":"","sources":["../../../../../src/adapter/kernel/slices/channel.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAE7C,eAAO,MAAM,YAAY,EAAE,WAKzB,CAAA"}

package/lib/types/adapter/kernel/slices/channel.js

@@ -0,0 +1,8 @@
+import { channelDriver } from '../../upstream/channel-driver.js';
+import { CHANNEL_FEATURES } from '../../channel/features.js';
+export const channelSlice = Object.freeze({
+    id: 'channel',
+    capability: 'host.channel',
+    driver: channelDriver,
+    standardDeclarations: Object.freeze([...CHANNEL_FEATURES]),
+});

package/lib/types/adapter/kernel/slices/decisions.d.ts

@@ -0,0 +1,3 @@
+import type { KernelSlice } from './types.js';
+export declare const decisionsSlice: KernelSlice;
+//# sourceMappingURL=decisions.d.ts.map

package/lib/types/adapter/kernel/slices/decisions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decisions.d.ts","sourceRoot":"","sources":["../../../../../src/adapter/kernel/slices/decisions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAE7C,eAAO,MAAM,cAAc,EAAE,WAQ3B,CAAA"}

package/lib/types/adapter/kernel/slices/decisions.js

@@ -0,0 +1,10 @@
+import { decisionsDriver } from '../../upstream/decisions-driver.js';
+export const decisionsSlice = Object.freeze({
+    id: 'decisions',
+    capability: 'host.decisions',
+    driver: decisionsDriver,
+    standardDeclarations: Object.freeze([
+        'host.decision.subscribe',
+        'host.decision.probe',
+    ]),
+});

package/lib/types/adapter/kernel/slices/extensions.d.ts

@@ -0,0 +1,8 @@
+import type { KernelSlice } from './types.js';
+export declare const statusSlice: KernelSlice;
+export declare const shortcutsSlice: KernelSlice;
+export declare const renderersSlice: KernelSlice;
+export declare const themesSlice: KernelSlice;
+export declare const toastSlice: KernelSlice;
+export declare const commandTreesSlice: KernelSlice;
+//# sourceMappingURL=extensions.d.ts.map

package/lib/types/adapter/kernel/slices/extensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extensions.d.ts","sourceRoot":"","sources":["../../../../../src/adapter/kernel/slices/extensions.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAwC7C,eAAO,MAAM,WAAW,aAA4E,CAAA;AACpG,eAAO,MAAM,cAAc,aAAwF,CAAA;AACnH,eAAO,MAAM,cAAc,aAAwF,CAAA;AACnH,eAAO,MAAM,WAAW,aAA4E,CAAA;AACpG,eAAO,MAAM,UAAU,aAAwE,CAAA;AAC/F,eAAO,MAAM,iBAAiB,aAAsG,CAAA"}

package/lib/types/adapter/kernel/slices/extensions.js

@@ -0,0 +1,43 @@
+import { statusDriver, shortcutsDriver, renderersDriver, themesDriver, toastDriver, commandTreesDriver, } from '../../upstream/extensions-driver.js';
+const statusDeclarations = Object.freeze([
+    'host.status.set',
+    'host.status.snapshot',
+    'host.status.subscribe',
+]);
+const shortcutsDeclarations = Object.freeze([
+    'host.shortcuts.register',
+    'host.shortcuts.list',
+    'host.shortcuts.dispatch',
+]);
+const renderersDeclarations = Object.freeze([
+    'host.renderers.register',
+    'host.renderers.render',
+]);
+const themesDeclarations = Object.freeze([
+    'host.themes.register',
+    'host.themes.snapshot',
+    'host.themes.resolver',
+    'host.themes.subscribe',
+]);
+const toastDeclarations = Object.freeze([
+    'host.toast.show',
+]);
+const commandTreesDeclarations = Object.freeze([
+    'host.command-trees.register',
+    'host.command-trees.children',
+    'host.command-trees.descriptions',
+]);
+function extensionSlice(id, capability, driver, standardDeclarations) {
+    return Object.freeze({
+        id,
+        capability,
+        driver,
+        standardDeclarations,
+    });
+}
+export const statusSlice = extensionSlice('status', 'host.status', statusDriver, statusDeclarations);
+export const shortcutsSlice = extensionSlice('shortcuts', 'host.shortcuts', shortcutsDriver, shortcutsDeclarations);
+export const renderersSlice = extensionSlice('renderers', 'host.renderers', renderersDriver, renderersDeclarations);
+export const themesSlice = extensionSlice('themes', 'host.themes', themesDriver, themesDeclarations);
+export const toastSlice = extensionSlice('toast', 'host.toast', toastDriver, toastDeclarations);
+export const commandTreesSlice = extensionSlice('command-trees', 'host.command-trees', commandTreesDriver, commandTreesDeclarations);

package/lib/types/adapter/kernel/slices/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Kernel slice registry.
+ *
+ * Each slice composes one upstream driver with the Standard/effect
+ * capability declarations it governs. The Kernel runtime can consume this
+ * list for composition and diagnostics; it does not turn slices into
+ * business logic.
+ */
+export type { KernelSlice } from './types.js';
+export { presentationSlice } from './presentation.js';
+export { workspaceSlice } from './workspace.js';
+export { scenesSlice } from './scenes.js';
+export { settingsSlice } from './settings.js';
+export { channelSlice } from './channel.js';
+export { statusSlice, shortcutsSlice, renderersSlice, themesSlice, toastSlice, commandTreesSlice, } from './extensions.js';
+export { decisionsSlice } from './decisions.js';
+import type { KernelSlice } from './types.js';
+export declare const ADAPTER_KERNEL_SLICES: readonly KernelSlice[];
+//# sourceMappingURL=index.d.ts.map

package/lib/types/adapter/kernel/slices/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/adapter/kernel/slices/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,YAAY,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAC7C,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AACzC,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAC3C,OAAO,EACL,WAAW,EACX,cAAc,EACd,cAAc,EACd,WAAW,EACX,UAAU,EACV,iBAAiB,GAClB,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAE/C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAgB7C,eAAO,MAAM,qBAAqB,EAAE,SAAS,WAAW,EAatD,CAAA"}

package/lib/types/adapter/kernel/slices/index.js

@@ -0,0 +1,36 @@
+/**
+ * Kernel slice registry.
+ *
+ * Each slice composes one upstream driver with the Standard/effect
+ * capability declarations it governs. The Kernel runtime can consume this
+ * list for composition and diagnostics; it does not turn slices into
+ * business logic.
+ */
+export { presentationSlice } from './presentation.js';
+export { workspaceSlice } from './workspace.js';
+export { scenesSlice } from './scenes.js';
+export { settingsSlice } from './settings.js';
+export { channelSlice } from './channel.js';
+export { statusSlice, shortcutsSlice, renderersSlice, themesSlice, toastSlice, commandTreesSlice, } from './extensions.js';
+export { decisionsSlice } from './decisions.js';
+import { presentationSlice } from './presentation.js';
+import { workspaceSlice } from './workspace.js';
+import { scenesSlice } from './scenes.js';
+import { settingsSlice } from './settings.js';
+import { channelSlice } from './channel.js';
+import { statusSlice, shortcutsSlice, renderersSlice, themesSlice, toastSlice, commandTreesSlice, } from './extensions.js';
+import { decisionsSlice } from './decisions.js';
+export const ADAPTER_KERNEL_SLICES = Object.freeze([
+    presentationSlice,
+    workspaceSlice,
+    scenesSlice,
+    settingsSlice,
+    channelSlice,
+    statusSlice,
+    shortcutsSlice,
+    renderersSlice,
+    themesSlice,
+    toastSlice,
+    commandTreesSlice,
+    decisionsSlice,
+]);

package/lib/types/adapter/kernel/slices/presentation.d.ts

@@ -0,0 +1,3 @@
+import type { KernelSlice } from './types.js';
+export declare const presentationSlice: KernelSlice;
+//# sourceMappingURL=presentation.d.ts.map

package/lib/types/adapter/kernel/slices/presentation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"presentation.d.ts","sourceRoot":"","sources":["../../../../../src/adapter/kernel/slices/presentation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAE7C,eAAO,MAAM,iBAAiB,EAAE,WAY9B,CAAA"}

package/lib/types/adapter/kernel/slices/presentation.js

@@ -0,0 +1,14 @@
+import { presentationDriver } from '../../upstream/presentation-driver.js';
+export const presentationSlice = Object.freeze({
+    id: 'presentation',
+    capability: 'host.presentation',
+    driver: presentationDriver,
+    standardDeclarations: Object.freeze([
+        'host.presentation.ask',
+        'host.presentation.approve',
+        'host.presentation.dialog',
+        'host.dialogs.select',
+        'host.dialogs.confirm',
+        'host.dialogs.input',
+    ]),
+});

package/lib/types/adapter/kernel/slices/scenes.d.ts

@@ -0,0 +1,3 @@
+import type { KernelSlice } from './types.js';
+export declare const scenesSlice: KernelSlice;
+//# sourceMappingURL=scenes.d.ts.map

package/lib/types/adapter/kernel/slices/scenes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scenes.d.ts","sourceRoot":"","sources":["../../../../../src/adapter/kernel/slices/scenes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAE7C,eAAO,MAAM,WAAW,EAAE,WAYxB,CAAA"}

package/lib/types/adapter/kernel/slices/scenes.js

@@ -0,0 +1,14 @@
+import { scenesDriver } from '../../upstream/scenes-driver.js';
+export const scenesSlice = Object.freeze({
+    id: 'scenes',
+    capability: 'host.scenes',
+    driver: scenesDriver,
+    standardDeclarations: Object.freeze([
+        'host.scenes.register',
+        'host.scenes.list',
+        'host.scenes.open',
+        'host.scenes.close',
+        'host.scenes.active',
+        'host.scenes.subscribe',
+    ]),
+});

package/lib/types/adapter/kernel/slices/settings.d.ts

@@ -0,0 +1,3 @@
+import type { KernelSlice } from './types.js';
+export declare const settingsSlice: KernelSlice;
+//# sourceMappingURL=settings.d.ts.map

package/lib/types/adapter/kernel/slices/settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings.d.ts","sourceRoot":"","sources":["../../../../../src/adapter/kernel/slices/settings.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAE7C,eAAO,MAAM,aAAa,EAAE,WAU1B,CAAA"}

package/lib/types/adapter/kernel/slices/settings.js

@@ -0,0 +1,12 @@
+import { settingsDriver } from '../../upstream/settings-driver.js';
+export const settingsSlice = Object.freeze({
+    id: 'settings',
+    capability: 'host.settings',
+    driver: settingsDriver,
+    standardDeclarations: Object.freeze([
+        'host.settings.register',
+        'host.settings.list',
+        'host.settings.section',
+        'host.settings.subscribe',
+    ]),
+});

package/lib/types/adapter/kernel/slices/types.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Kernel slice: one vertical capability slice.
+ *
+ * A slice owns:
+ * - an upstream driver (detection/live-verification/mount),
+ * - the Host Port(s) the driver can mount,
+ * - the Standard/effect capabilities it declares and governs.
+ *
+ * The Kernel uses this only for composition/diagnostics; it never performs
+ * business translation itself.
+ */
+import type { UpstreamDriver } from '../../upstream/driver.js';
+export interface KernelSlice {
+    readonly id: string;
+    readonly capability: string;
+    readonly driver: UpstreamDriver;
+    /** Effect-class capabilities governed by this slice (Standard declaration). */
+    readonly standardDeclarations: readonly string[];
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/types/adapter/kernel/slices/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/adapter/kernel/slices/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAA;AAE9D,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAA;IAC/B,+EAA+E;IAC/E,QAAQ,CAAC,oBAAoB,EAAE,SAAS,MAAM,EAAE,CAAA;CACjD"}

package/lib/types/adapter/kernel/slices/types.js

@@ -0,0 +1,12 @@
+/**
+ * Kernel slice: one vertical capability slice.
+ *
+ * A slice owns:
+ * - an upstream driver (detection/live-verification/mount),
+ * - the Host Port(s) the driver can mount,
+ * - the Standard/effect capabilities it declares and governs.
+ *
+ * The Kernel uses this only for composition/diagnostics; it never performs
+ * business translation itself.
+ */
+export {};

package/lib/types/adapter/kernel/slices/workspace.d.ts

@@ -0,0 +1,3 @@
+import type { KernelSlice } from './types.js';
+export declare const workspaceSlice: KernelSlice;
+//# sourceMappingURL=workspace.d.ts.map

package/lib/types/adapter/kernel/slices/workspace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace.d.ts","sourceRoot":"","sources":["../../../../../src/adapter/kernel/slices/workspace.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAE7C,eAAO,MAAM,cAAc,EAAE,WAa3B,CAAA"}

package/lib/types/adapter/kernel/slices/workspace.js

@@ -0,0 +1,15 @@
+import { workspaceDriver } from '../../upstream/workspace-driver.js';
+export const workspaceSlice = Object.freeze({
+    id: 'workspace',
+    capability: 'host.workspaces',
+    driver: workspaceDriver,
+    standardDeclarations: Object.freeze([
+        'host.workspaces.list',
+        'host.workspaces.resolve',
+        'host.workspaces.describe',
+        'host.workspaces.commandShell',
+        'host.workspaces.rename',
+        'host.workspaces.commands',
+        'host.workspaces.runCommand',
+    ]),
+});