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

package/lib/types/adapter/upstream/index.js

@@ -0,0 +1,15 @@
+/**
+ * Upstream Driver Plane.
+ *
+ * This directory is the future/only allowed home for direct `@deepseek-ai/*`
+ * imports. The current migration keeps legacy drivers in `src/dsh-adapter/` so
+ * no behavior changes in this iteration; new drivers must land here.
+ */
+export { buildHostCapabilityLifecycles, refreshHostCapabilityLifecycles, detectHostDescriptorCapability, hostDescriptorDriver, } from './host-descriptor-driver.js';
+export { detectWorkspaceCapability, workspaceDriver, } from './workspace-driver.js';
+export { detectScenesCapability, scenesDriver, } from './scenes-driver.js';
+export { detectSettingsCapability, settingsDriver, } from './settings-driver.js';
+export { detectPresentationCapability, presentationDriver, } from './presentation-driver.js';
+export { detectDecisionsCapability, decisionsDriver, } from './decisions-driver.js';
+export { detectStatusCapability, detectShortcutsCapability, detectRenderersCapability, detectThemesCapability, detectToastCapability, detectCommandTreesCapability, statusDriver, shortcutsDriver, renderersDriver, themesDriver, toastDriver, commandTreesDriver, } from './extensions-driver.js';
+export { detectChannelCapability, verifyChannelLive, channelDriver, } from './channel-driver.js';

package/lib/types/adapter/upstream/presentation-driver.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Upstream driver for the TUI presentation capability.
+ *
+ * Presentation is fundamentally interactive: ask/approve/confirm require a
+ * human answer and cannot be safely auto-reversed without producing user-
+ * visible UI. This driver therefore stays honest:
+ * - detect() reports the service/method topology as `degraded` until a real
+ *   reversible presentation probe exists;
+ * - verifyLive() returns a degraded lifecycle and never fabricates `live`.
+ * The only thin port surface mounted today is the host dialog queue; ask and
+ * approve are intentionally staged and fail closed.
+ */
+import type { Detection } from './detection.js';
+import type { UpstreamDriver } from './driver.js';
+export declare function detectPresentationCapability(ctx: unknown): Detection;
+export declare const presentationDriver: UpstreamDriver;
+//# sourceMappingURL=presentation-driver.d.ts.map

package/lib/types/adapter/upstream/presentation-driver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"presentation-driver.d.ts","sourceRoot":"","sources":["../../../../src/adapter/upstream/presentation-driver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAcH,OAAO,KAAK,EAAE,SAAS,EAAqB,MAAM,gBAAgB,CAAA;AAClE,OAAO,KAAK,EAAE,cAAc,EAAuB,MAAM,aAAa,CAAA;AAqBtE,wBAAgB,4BAA4B,CAAC,GAAG,EAAE,OAAO,GAAG,SAAS,CAmBpE;AA0ED,eAAO,MAAM,kBAAkB,EAAE,cAWhC,CAAA"}

package/lib/types/adapter/upstream/presentation-driver.js

@@ -0,0 +1,129 @@
+/**
+ * Upstream driver for the TUI presentation capability.
+ *
+ * Presentation is fundamentally interactive: ask/approve/confirm require a
+ * human answer and cannot be safely auto-reversed without producing user-
+ * visible UI. This driver therefore stays honest:
+ * - detect() reports the service/method topology as `degraded` until a real
+ *   reversible presentation probe exists;
+ * - verifyLive() returns a degraded lifecycle and never fabricates `live`.
+ * The only thin port surface mounted today is the host dialog queue; ask and
+ * approve are intentionally staged and fail closed.
+ */
+import { lifecycleFromDetection } from '../kernel/lifecycle.js';
+import { getHostDialogStore } from '../../dsh-adapter/dialogs.js';
+import { getQuestionStore } from '../../dsh-adapter/questions.js';
+import { getApprovalStore } from '../../dsh-adapter/approvals.js';
+const CAPABILITY = 'host.presentation';
+function serviceEvidence(id) {
+    return { kind: 'service', id };
+}
+function methodEvidence(service, method) {
+    return { kind: 'method', id: `${service}:${method}` };
+}
+function probeEvidence(id, detail) {
+    return { kind: 'probe', id, detail };
+}
+export function detectPresentationCapability(ctx) {
+    const service = ctx?.get?.('tuiDialogs');
+    if (service === undefined) {
+        return { state: 'unsupported', reason: 'tuiDialogs service is not mounted' };
+    }
+    const evidence = [serviceEvidence('tuiDialogs')];
+    for (const method of ['select', 'confirm', 'input']) {
+        if (typeof service[method] === 'function') {
+            evidence.push(methodEvidence('tuiDialogs', method));
+        }
+    }
+    return {
+        state: 'degraded',
+        missing: ['reversible-presentation-probe'],
+        evidence: [
+            ...evidence,
+            probeEvidence('presentation.interactive', 'ask/approve/confirm require human interaction; no safe auto-reversible live probe in P3'),
+        ],
+    };
+}
+async function verifyPresentationLive(ctx) {
+    const detection = detectPresentationCapability(ctx);
+    if (detection.state === 'unsupported') {
+        return [lifecycleFromDetection(CAPABILITY, detection)];
+    }
+    return [lifecycleFromDetection(CAPABILITY, {
+            state: 'degraded',
+            missing: ['reversible-presentation-probe'],
+            evidence: detection.evidence ?? [],
+        })];
+}
+function createPresentationPort(ctx) {
+    const service = ctx?.get?.('tuiDialogs');
+    const store = service === undefined ? undefined : (() => {
+        try {
+            return getHostDialogStore(service);
+        }
+        catch {
+            return undefined;
+        }
+    })();
+    return Object.freeze({
+        async ask(request) {
+            const questionStore = getQuestionStore(ctx);
+            if (questionStore === undefined) {
+                throw new Error('dsh-tui: host.presentation.ask is unavailable because no QuestionStore is mounted in this composition');
+            }
+            const answer = await questionStore.ask({
+                questions: request.questions.map(item => ({
+                    id: item.id,
+                    question: item.question,
+                    ...(item.options === undefined ? {} : {
+                        options: item.options.map(label => ({ label })),
+                    }),
+                    ...(item.multiple === true ? { multiSelect: true } : {}),
+                })),
+            });
+            return { answers: answer.answers };
+        },
+        async approve(_request) {
+            // P3: approval is intentionally staged on the Host Port because a real
+            // ApprovalStore.park() needs the DSH ApprovalRequest's live agent/session
+            // context, which this internal Port does not carry. It is not silently
+            // pretending to be a working approval path.
+            const approvalStore = getApprovalStore(ctx);
+            if (approvalStore === undefined) {
+                throw new Error('dsh-tui: host.presentation.approve is unavailable because no ApprovalStore is mounted in this composition');
+            }
+            throw new Error('dsh-tui: host.presentation.approve is staged in P3; use the DSH approval/request waterfall which carries a live ApprovalRequest');
+        },
+        dialog(request) {
+            if (store === undefined)
+                return Promise.resolve(undefined);
+            const snapshot = {
+                kind: request.kind,
+                title: request.title,
+                ...(request.kind === 'select' ? { options: request.options } : {}),
+                ...(request.kind === 'confirm' ? {
+                    ...(request.message === undefined ? {} : { message: request.message }),
+                    confirmLabel: request.confirmLabel ?? 'OK',
+                    cancelLabel: request.cancelLabel ?? 'Cancel',
+                } : {}),
+                ...(request.kind === 'input' ? {
+                    ...(request.placeholder === undefined ? {} : { placeholder: request.placeholder }),
+                    initial: request.initial ?? '',
+                } : {}),
+            };
+            return store.ask(snapshot, request.signal, request.timeoutMs);
+        },
+    });
+}
+export const presentationDriver = {
+    id: 'dsh-tui-presentation',
+    upstreamFamily: 'dsh-tui',
+    capability: 'host.presentation',
+    mountEffectClass: 'mutate',
+    detect: detectPresentationCapability,
+    verifyLive: verifyPresentationLive,
+    async mount(context) {
+        const ports = { presentation: createPresentationPort(context) };
+        return { disposer: () => undefined, ports };
+    },
+};

package/lib/types/adapter/upstream/scenes-driver.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Upstream driver for the TUI scenes capability.
+ *
+ * Scenes are a register-class capability. The driver performs a real
+ * reversible probe through the host-only scenes facade: register a uniquely
+ * named temporary scene, list it, dispose it, then prove the same name can
+ * be registered again (no residue). It never opens the scene during the
+ * probe, so no visible UI mutation is caused.
+ *
+ * Publication is feature-level: register/list are live only after the
+ * reversible no-residue probe; open/close/active/subscribe are not safely
+ * auto-verifiable in P3 and stay degraded.
+ */
+import type { Detection } from './detection.js';
+import type { UpstreamDriver } from './driver.js';
+export declare function detectScenesCapability(ctx: unknown): Detection;
+export declare const scenesDriver: UpstreamDriver;
+//# sourceMappingURL=scenes-driver.d.ts.map

package/lib/types/adapter/upstream/scenes-driver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scenes-driver.d.ts","sourceRoot":"","sources":["../../../../src/adapter/upstream/scenes-driver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAOH,OAAO,KAAK,EAAE,SAAS,EAAqB,MAAM,gBAAgB,CAAA;AAClE,OAAO,KAAK,EAAE,cAAc,EAAuB,MAAM,aAAa,CAAA;AAwDtE,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,OAAO,GAAG,SAAS,CAmB9D;AA4ED,eAAO,MAAM,YAAY,EAAE,cAY1B,CAAA"}

package/lib/types/adapter/upstream/scenes-driver.js

@@ -0,0 +1,170 @@
+/**
+ * Upstream driver for the TUI scenes capability.
+ *
+ * Scenes are a register-class capability. The driver performs a real
+ * reversible probe through the host-only scenes facade: register a uniquely
+ * named temporary scene, list it, dispose it, then prove the same name can
+ * be registered again (no residue). It never opens the scene during the
+ * probe, so no visible UI mutation is caused.
+ *
+ * Publication is feature-level: register/list are live only after the
+ * reversible no-residue probe; open/close/active/subscribe are not safely
+ * auto-verifiable in P3 and stay degraded.
+ */
+import { randomUUID } from 'node:crypto';
+import { lifecycleFromDetection } from '../kernel/lifecycle.js';
+import { getHostSceneRuntime } from '../../dsh-adapter/scenes.js';
+const CAPABILITY = 'host.scenes';
+const SCENE_FEATURES = Object.freeze([
+    'host.scenes.register',
+    'host.scenes.list',
+    'host.scenes.open',
+    'host.scenes.close',
+    'host.scenes.active',
+    'host.scenes.subscribe',
+]);
+function serviceEvidence(id) {
+    return { kind: 'service', id };
+}
+function methodEvidence(service, method) {
+    return { kind: 'method', id: `${service}:${method}` };
+}
+function probeEvidence(id, detail) {
+    return { kind: 'probe', id, detail };
+}
+function errorText(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function sceneHost(ctx) {
+    const service = ctx?.get?.('tuiScenes');
+    if (service === undefined)
+        return undefined;
+    try {
+        return getHostSceneRuntime(service);
+    }
+    catch {
+        return undefined;
+    }
+}
+function degradedFeature(capability, evidence, missing) {
+    return lifecycleFromDetection(capability, {
+        state: 'degraded',
+        missing: [missing],
+        evidence,
+    });
+}
+function liveFeature(capability, evidence) {
+    return lifecycleFromDetection(capability, {
+        state: 'supported',
+        evidence,
+    });
+}
+export function detectScenesCapability(ctx) {
+    const service = ctx?.get?.('tuiScenes');
+    if (service === undefined) {
+        return { state: 'unsupported', reason: 'tuiScenes service is not mounted' };
+    }
+    const evidence = [serviceEvidence('tuiScenes')];
+    const host = sceneHost(ctx);
+    if (host === undefined) {
+        return { state: 'degraded', missing: ['tuiScenes host facade'], evidence };
+    }
+    const methods = ['register', 'list', 'open', 'close', 'subscribe'];
+    for (const method of methods) {
+        if (typeof host[method] === 'function') {
+            evidence.push(methodEvidence('tuiScenes', method));
+        }
+        else {
+            return { state: 'degraded', missing: [`tuiScenes.${method}()`], evidence };
+        }
+    }
+    return { state: 'supported', evidence };
+}
+async function verifyScenesLive(ctx) {
+    const host = sceneHost(ctx);
+    const baseEvidence = [serviceEvidence('tuiScenes')];
+    if (host === undefined) {
+        return SCENE_FEATURES.map(feature => degradedFeature(feature, baseEvidence, `${feature}.live-probe`));
+    }
+    const evidence = [serviceEvidence('tuiScenes')];
+    const missing = [];
+    const id = `dsh_tui_probe_${randomUUID().replace(/-/g, '').slice(0, 12)}`;
+    const descriptor = {
+        id,
+        title: 'dsh-tui reversible scene probe',
+        component: () => undefined,
+    };
+    let dispose;
+    let registerLive = false;
+    try {
+        dispose = host.register(descriptor);
+        const listed = host.list();
+        if (!Array.isArray(listed) || !listed.some(scene => scene.id === id)) {
+            missing.push('tuiScenes.register/list()');
+            throw new Error('temporary scene was not visible through list()');
+        }
+        evidence.push(probeEvidence(`tuiScenes.register+dispose(${id})`, 'temporary scene registered and listed'));
+        dispose();
+        dispose = undefined;
+        // No-residue proof: the same id must be registrable again.
+        const second = host.register(descriptor);
+        second();
+        evidence.push(probeEvidence(`tuiScenes.dispose(${id})`, 'temporary scene removed; same id re-register succeeded'));
+        registerLive = true;
+    }
+    catch (error) {
+        missing.push('tuiScenes.reversible-live-probe');
+        evidence.push(probeEvidence('tuiScenes.reversible-live-probe', errorText(error)));
+    }
+    finally {
+        try {
+            dispose?.();
+        }
+        catch {
+            // Best-effort cleanup.
+        }
+    }
+    const out = [];
+    out.push(registerLive
+        ? liveFeature('host.scenes.register', evidence)
+        : degradedFeature('host.scenes.register', evidence, 'tuiScenes.reversible-live-probe'));
+    if (registerLive) {
+        out.push(liveFeature('host.scenes.list', [
+            serviceEvidence('tuiScenes'),
+            methodEvidence('tuiScenes', 'list'),
+            probeEvidence('tuiScenes.list()', 'temporary scene visible through list()'),
+        ]));
+    }
+    else {
+        out.push(degradedFeature('host.scenes.list', [serviceEvidence('tuiScenes'), methodEvidence('tuiScenes', 'list')], 'tuiScenes.list() live-probe'));
+    }
+    for (const feature of ['host.scenes.open', 'host.scenes.close', 'host.scenes.active', 'host.scenes.subscribe']) {
+        out.push(degradedFeature(feature, [serviceEvidence('tuiScenes')], `${feature}.live-probe`));
+    }
+    return out;
+}
+function createScenesPort(host) {
+    return Object.freeze({
+        register: descriptor => host.register(descriptor),
+        list: () => host.list(),
+        open: id => host.open(id),
+        close: () => host.close(),
+        get active() {
+            return host.active;
+        },
+        subscribe: listener => host.subscribe(listener),
+    });
+}
+export const scenesDriver = {
+    id: 'dsh-tui-scenes',
+    upstreamFamily: 'dsh-tui',
+    capability: 'host.scenes',
+    mountEffectClass: 'register',
+    detect: detectScenesCapability,
+    verifyLive: verifyScenesLive,
+    async mount(context) {
+        const host = sceneHost(context);
+        const ports = host === undefined ? undefined : { scenes: createScenesPort(host) };
+        return { disposer: () => undefined, ...(ports === undefined ? {} : { ports }) };
+    },
+};

package/lib/types/adapter/upstream/settings-driver.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Upstream driver for the TUI settings-section capability.
+ *
+ * Settings sections are a register-class host extension. The driver performs
+ * a reversible probe through the host-only settings facade: register a
+ * uniquely named temporary section, list it, dispose it, then prove the same
+ * namespace can be registered again (no residue).
+ *
+ * Publication is feature-level: register/list/section are live after the
+ * reversible no-residue probe; subscribe stays degraded in P3 because the
+ * probe does not own a real subscriber lifecycle.
+ */
+import type { CapabilityLifecycle } from '../kernel/lifecycle.js';
+import type { Detection } from './detection.js';
+import type { UpstreamDriver } from './driver.js';
+import { type TuiSettingsSectionsHost } from '../../dsh-adapter/settings-sections.js';
+export declare function detectSettingsCapability(ctx: unknown): Detection;
+export declare function verifySettingsLiveForHost(host: TuiSettingsSectionsHost | undefined): Promise<CapabilityLifecycle[]>;
+export declare const settingsDriver: UpstreamDriver;
+//# sourceMappingURL=settings-driver.d.ts.map

package/lib/types/adapter/upstream/settings-driver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings-driver.d.ts","sourceRoot":"","sources":["../../../../src/adapter/upstream/settings-driver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAKH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAA;AAEjE,OAAO,KAAK,EAAE,SAAS,EAAqB,MAAM,gBAAgB,CAAA;AAClE,OAAO,KAAK,EAAE,cAAc,EAAuB,MAAM,aAAa,CAAA;AACtE,OAAO,EAA2B,KAAK,uBAAuB,EAAE,MAAM,wCAAwC,CAAA;AAqD9G,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,OAAO,GAAG,SAAS,CAqBhE;AAED,wBAAsB,yBAAyB,CAC7C,IAAI,EAAE,uBAAuB,GAAG,SAAS,GACxC,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAiEhC;AAeD,eAAO,MAAM,cAAc,EAAE,cAY5B,CAAA"}

package/lib/types/adapter/upstream/settings-driver.js

@@ -0,0 +1,173 @@
+/**
+ * Upstream driver for the TUI settings-section capability.
+ *
+ * Settings sections are a register-class host extension. The driver performs
+ * a reversible probe through the host-only settings facade: register a
+ * uniquely named temporary section, list it, dispose it, then prove the same
+ * namespace can be registered again (no residue).
+ *
+ * Publication is feature-level: register/list/section are live after the
+ * reversible no-residue probe; subscribe stays degraded in P3 because the
+ * probe does not own a real subscriber lifecycle.
+ */
+import { randomUUID } from 'node:crypto';
+import { lifecycleFromDetection } from '../kernel/lifecycle.js';
+import { getHostSettingsSections } from '../../dsh-adapter/settings-sections.js';
+const CAPABILITY = 'host.settings';
+const SETTINGS_FEATURES = Object.freeze([
+    'host.settings.register',
+    'host.settings.list',
+    'host.settings.section',
+    'host.settings.subscribe',
+]);
+function serviceEvidence(id) {
+    return { kind: 'service', id };
+}
+function methodEvidence(service, method) {
+    return { kind: 'method', id: `${service}:${method}` };
+}
+function probeEvidence(id, detail) {
+    return { kind: 'probe', id, detail };
+}
+function errorText(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function settingsHost(ctx) {
+    const service = ctx?.get?.('tuiSettingsSections');
+    if (service === undefined)
+        return undefined;
+    try {
+        return getHostSettingsSections(service);
+    }
+    catch {
+        return undefined;
+    }
+}
+function degradedFeature(capability, evidence, missing) {
+    return lifecycleFromDetection(capability, {
+        state: 'degraded',
+        missing: [missing],
+        evidence,
+    });
+}
+function liveFeature(capability, evidence) {
+    return lifecycleFromDetection(capability, {
+        state: 'supported',
+        evidence,
+    });
+}
+export function detectSettingsCapability(ctx) {
+    const service = ctx?.get?.('tuiSettingsSections');
+    if (service === undefined) {
+        return { state: 'unsupported', reason: 'tuiSettingsSections service is not mounted' };
+    }
+    const evidence = [serviceEvidence('tuiSettingsSections')];
+    const host = settingsHost(ctx);
+    if (host === undefined) {
+        return { state: 'degraded', missing: ['tuiSettingsSections host facade'], evidence };
+    }
+    for (const method of ['register', 'list', 'subscribe']) {
+        if (typeof host[method] === 'function') {
+            evidence.push(methodEvidence('tuiSettingsSections', method));
+        }
+        else {
+            return { state: 'degraded', missing: [`tuiSettingsSections.${method}()`], evidence };
+        }
+    }
+    return {
+        state: 'supported',
+        evidence: [...evidence, probeEvidence('tuiSettingsSections.host()', 'host settings facade is present')],
+    };
+}
+export async function verifySettingsLiveForHost(host) {
+    const baseEvidence = [serviceEvidence('tuiSettingsSections')];
+    if (host === undefined) {
+        return SETTINGS_FEATURES.map(feature => degradedFeature(feature, baseEvidence, `${feature}.live-probe`));
+    }
+    const evidence = [serviceEvidence('tuiSettingsSections')];
+    const missing = [];
+    const ns = `dsh_tui_probe_${randomUUID().replace(/-/g, '').slice(0, 12)}`;
+    const section = {
+        ns,
+        title: 'dsh-tui reversible settings probe',
+        fields: [],
+    };
+    let dispose;
+    let registerLive = false;
+    try {
+        dispose = host.register(section);
+        const listed = host.list();
+        if (!Array.isArray(listed) || !listed.some(entry => entry.ns === ns)) {
+            missing.push('tuiSettingsSections.register/list()');
+            throw new Error('temporary settings section was not visible through list()');
+        }
+        evidence.push(probeEvidence(`tuiSettingsSections.register+list(${ns})`, 'temporary settings section registered and listed'));
+        const resolved = host.section(ns);
+        if (resolved === undefined || resolved.ns !== ns) {
+            missing.push('tuiSettingsSections.section()');
+            throw new Error('temporary settings section was not resolvable through section()');
+        }
+        evidence.push(probeEvidence(`tuiSettingsSections.section(${ns})`, 'temporary settings section resolvable by namespace'));
+        dispose();
+        dispose = undefined;
+        const second = host.register(section);
+        second();
+        evidence.push(probeEvidence(`tuiSettingsSections.dispose(${ns})`, 'temporary settings section removed; same ns re-register succeeded'));
+        registerLive = true;
+    }
+    catch (error) {
+        missing.push('tuiSettingsSections.reversible-live-probe');
+        evidence.push(probeEvidence('tuiSettingsSections.reversible-live-probe', errorText(error)));
+    }
+    finally {
+        try {
+            dispose?.();
+        }
+        catch {
+            // Best-effort cleanup.
+        }
+    }
+    const out = [];
+    out.push(registerLive
+        ? liveFeature('host.settings.register', evidence)
+        : degradedFeature('host.settings.register', evidence, 'tuiSettingsSections.reversible-live-probe'));
+    out.push(registerLive
+        ? liveFeature('host.settings.list', [
+            serviceEvidence('tuiSettingsSections'),
+            methodEvidence('tuiSettingsSections', 'list'),
+            probeEvidence('tuiSettingsSections.list()', 'temporary settings section visible through list()'),
+        ])
+        : degradedFeature('host.settings.list', [serviceEvidence('tuiSettingsSections'), methodEvidence('tuiSettingsSections', 'list')], 'tuiSettingsSections.list() live-probe'));
+    out.push(registerLive
+        ? liveFeature('host.settings.section', [
+            serviceEvidence('tuiSettingsSections'),
+            probeEvidence('tuiSettingsSections.section()', 'temporary settings section resolvable by namespace'),
+        ])
+        : degradedFeature('host.settings.section', [serviceEvidence('tuiSettingsSections')], 'tuiSettingsSections.section() live-probe'));
+    out.push(degradedFeature('host.settings.subscribe', [serviceEvidence('tuiSettingsSections'), methodEvidence('tuiSettingsSections', 'subscribe')], 'host.settings.subscribe.live-probe'));
+    return out;
+}
+async function verifySettingsLive(ctx) {
+    return verifySettingsLiveForHost(settingsHost(ctx));
+}
+function createSettingsPort(host) {
+    return Object.freeze({
+        register: section => host.register(section),
+        list: () => host.list(),
+        section: ns => host.section(ns),
+        subscribe: listener => host.subscribe(listener),
+    });
+}
+export const settingsDriver = {
+    id: 'dsh-tui-settings',
+    upstreamFamily: 'dsh-tui',
+    capability: 'host.settings',
+    mountEffectClass: 'register',
+    detect: detectSettingsCapability,
+    verifyLive: verifySettingsLive,
+    async mount(context) {
+        const host = settingsHost(context);
+        const ports = host === undefined ? undefined : { settings: createSettingsPort(host) };
+        return { disposer: () => undefined, ...(ports === undefined ? {} : { ports }) };
+    },
+};

package/lib/types/adapter/upstream/workspace-driver.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Upstream driver for the TUI workspace capability.
+ *
+ * This driver detects the `tuiWorkspaces` service and its host-only facade,
+ * performs real read-only enumeration/resolution probes in `verifyLive`, and
+ * mounts a thin Host Workspace Port over the same legacy host facade. It
+ * deliberately does not import Standard/Spec and does not define protocol
+ * semantics.
+ *
+ * Publication is feature-level: only the methods actually verified by a
+ * read-only/reversible probe are promoted to live. Mutating methods
+ * (rename/runCommand) and command-shell execution remain degraded in P3
+ * because they cannot be safely auto-reversed on a real host.
+ */
+import type { Detection } from './detection.js';
+import type { UpstreamDriver } from './driver.js';
+export declare function detectWorkspaceCapability(ctx: unknown): Detection;
+export declare const workspaceDriver: UpstreamDriver;
+//# sourceMappingURL=workspace-driver.d.ts.map

package/lib/types/adapter/upstream/workspace-driver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-driver.d.ts","sourceRoot":"","sources":["../../../../src/adapter/upstream/workspace-driver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAMH,OAAO,KAAK,EAAE,SAAS,EAAqB,MAAM,gBAAgB,CAAA;AAClE,OAAO,KAAK,EAAE,cAAc,EAAuB,MAAM,aAAa,CAAA;AA0DtE,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,OAAO,GAAG,SAAS,CAqBjE;AA8FD,eAAO,MAAM,eAAe,EAAE,cAY7B,CAAA"}