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

package/lib/types/adapter/standard/descriptor.js

@@ -0,0 +1,356 @@
+/** Build the current dsh-TUI Host Descriptor from live Kernel lifecycle evidence. */
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { hasProbeEvidence, hasVerificationEvidence } from '../kernel/lifecycle.js';
+import { digestFile, loadSpecData, verifyContractProfiles } from './registry.js';
+import { HOST_SUPPORTED_CONTRACTS } from '../spec/protocol-constants.js';
+import { createContractIndex, validateHost } from './validate.js';
+import { check } from './schema-check.js';
+export { HOST_SUPPORTED_CONTRACTS };
+/** The facet version is part of the host identity, not a protocol definition.
+ * Keep a conservative fallback so a descriptor remains schema-valid when the
+ * optional vendored registry is unavailable; the contract list is still
+ * empty in that degraded state. */
+export const HOST_FACET_API_VERSIONS = Object.freeze(['v1alpha1']);
+function freezeDeep(value, seen = new WeakSet()) {
+    if (value === null || typeof value !== 'object' || seen.has(value))
+        return value;
+    seen.add(value);
+    for (const child of Object.values(value))
+        freezeDeep(child, seen);
+    return Object.freeze(value);
+}
+export function readOwnPackageVersion() {
+    const candidates = [];
+    try {
+        candidates.push(fileURLToPath(import.meta.resolve('@deepseek-harness-tui/dsh-tui/package.json')));
+    }
+    catch {
+        // Fall through to the source/package walk-up path.
+    }
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for (let index = 0; index < 8; index++) {
+        candidates.push(join(dir, 'package.json'));
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    for (const candidate of candidates) {
+        try {
+            const manifest = JSON.parse(readFileSync(candidate, 'utf8'));
+            if (manifest.name === '@deepseek-harness-tui/dsh-tui'
+                && typeof manifest.version === 'string'
+                && manifest.version !== '')
+                return manifest.version;
+        }
+        catch {
+            // Keep looking.
+        }
+    }
+    return '0.0.0';
+}
+function coordinateFromCapability(capability) {
+    const index = capability.indexOf('#');
+    if (index <= 0 || index === capability.length - 1)
+        return undefined;
+    return {
+        apiVersion: capability.slice(0, index),
+        kind: capability.slice(index + 1),
+    };
+}
+function coordinateOf(lifecycle) {
+    return lifecycle.coordinate ?? coordinateFromCapability(lifecycle.capability);
+}
+function supportSpec(coordinate, lifecycle, legacyFeatures) {
+    if (coordinate.apiVersion === 'tui.dsh/v1alpha1' && coordinate.kind === 'DecisionEvents') {
+        // Never fall back to the full event vocabulary. New mode only advertises
+        // liveFeatures verified by the driver probe; legacy mode only advertises
+        // features passed from the read-only legacy topology probe.
+        const features = legacyFeatures ?? [...(lifecycle?.liveFeatures ?? [])];
+        return { features: [...new Set(features)].sort() };
+    }
+    return undefined;
+}
+/**
+ * Whether a lifecycle's probe evidence is sufficient to publish the whole
+ * capability contract.
+ *
+ * The protocol definitions for Command / LocalStorage / MessageObserver do not
+ * support feature-granular support specs, so a probe must prove the real
+ * operational capability (not merely a catalog/list or mounted-runtime
+ * diagnostic). DecisionEvents is feature-granular and is handled separately.
+ */
+function hasPublishableCapabilityProbe(lifecycle, coordinate) {
+    const detection = lifecycle.detection;
+    if (detection.state !== 'supported' && detection.state !== 'degraded')
+        return false;
+    const evidence = detection.evidence ?? [];
+    if (coordinate.kind === 'Command') {
+        return evidence.some(item => item.kind === 'probe' && /(?:execute|invoke)/u.test(item.id));
+    }
+    if (coordinate.kind === 'LocalStorage' || coordinate.kind === 'MessageObserver') {
+        return evidence.some(item => item.kind === 'probe' && !item.id.includes('probeDiagnostic'));
+    }
+    return true;
+}
+/**
+ * DecisionEvents publication additionally requires the actual mediated
+ * subscription method to exist. A real channel/probe with a missing
+ * `subscribeDecision()` is still a degraded/non-publishable capability.
+ */
+function hasDecisionSubscriptionMethod(lifecycle) {
+    const detection = lifecycle.detection;
+    if (detection.state !== 'supported' && detection.state !== 'degraded')
+        return false;
+    return (detection.evidence ?? []).some(item => item.kind === 'method' && item.id.includes('subscribeDecision'));
+}
+function hasDecisionCriticalMissing(lifecycle) {
+    const detection = lifecycle.detection;
+    if (detection.state !== 'degraded')
+        return false;
+    return detection.missing.some(item => item.includes('subscribeDecision'));
+}
+function hasPublishableDecisionFeatureEvidence(lifecycle) {
+    return hasProbeEvidence(lifecycle)
+        && !hasDecisionCriticalMissing(lifecycle)
+        && hasDecisionSubscriptionMethod(lifecycle)
+        && (lifecycle.liveFeatures?.length ?? 0) > 0;
+}
+/**
+ * Select the publishable contract set from live lifecycle evidence.
+ *
+ * `degraded` remains a diagnostic fact here: it is never promoted to a whole
+ * supported contract. If a protocol supports feature granularity, the caller
+ * must split the degraded capability into feature-level live lifecycles (or
+ * pass `liveFeatures` on a live lifecycle) before this builder can publish it.
+ */
+function publishableLifecycles(lifecycles, warnings, dropped) {
+    const published = [];
+    for (const lifecycle of lifecycles) {
+        const coordinate = coordinateOf(lifecycle);
+        if (coordinate === undefined) {
+            dropped.push(lifecycle.capability);
+            warnings.push(`${lifecycle.capability}: lifecycle has no contract coordinate; cannot publish`);
+            continue;
+        }
+        const key = `${coordinate.apiVersion}#${coordinate.kind}`;
+        if (lifecycle.state === 'live') {
+            if (!hasVerificationEvidence(lifecycle) || !hasPublishableCapabilityProbe(lifecycle, coordinate)) {
+                dropped.push(key);
+                warnings.push(`${key}: live lifecycle lacks a publishable real capability probe; not published`);
+                continue;
+            }
+            if (coordinate.apiVersion === 'tui.dsh/v1alpha1' && coordinate.kind === 'DecisionEvents') {
+                if (lifecycle.liveFeatures === undefined || lifecycle.liveFeatures.length === 0) {
+                    dropped.push(key);
+                    warnings.push(`${key}: live DecisionEvents has no verified feature-level evidence; not published`);
+                    continue;
+                }
+                if (!hasPublishableDecisionFeatureEvidence(lifecycle)) {
+                    dropped.push(key);
+                    warnings.push(`${key}: live DecisionEvents lacks a real probe and/or the mediated subscribeDecision method; not published`);
+                    continue;
+                }
+            }
+            published.push({ lifecycle, coordinate });
+        }
+        else if (lifecycle.state === 'degraded') {
+            if (lifecycle.liveFeatures !== undefined && lifecycle.liveFeatures.length > 0
+                && coordinate.apiVersion === 'tui.dsh/v1alpha1'
+                && coordinate.kind === 'DecisionEvents'
+                && hasPublishableDecisionFeatureEvidence(lifecycle)) {
+                // Feature-granular publication: only the decomposed live features are
+                // advertised, never the whole degraded capability. Probe evidence is
+                // mandatory even for feature splits — no probe, no publication — and
+                // the mediated subscribeDecision method must also exist.
+                published.push({ lifecycle, coordinate });
+                warnings.push(`${key}: degraded capability split into live feature-level evidence (${lifecycle.liveFeatures.join(', ')})`);
+            }
+            else if (lifecycle.liveFeatures !== undefined && lifecycle.liveFeatures.length > 0
+                && coordinate.apiVersion === 'tui.dsh/v1alpha1'
+                && coordinate.kind === 'DecisionEvents') {
+                dropped.push(key);
+                warnings.push(`${key}: degraded DecisionEvents has feature evidence without a real probe/mediated subscribeDecision method; not published`);
+            }
+            else {
+                dropped.push(key);
+                warnings.push(`${key}: degraded capability was not split into publishable live features; not published`);
+            }
+        }
+        else {
+            dropped.push(key);
+            warnings.push(`${key}: capability is ${lifecycle.state}, not live; not published`);
+        }
+    }
+    return published;
+}
+/**
+ * Build Host Descriptor only from live lifecycle evidence. This is the
+ * canonical production entry point; it never accepts a bare supported array as
+ * final fact.
+ */
+export function buildHostDescriptorFromLifecycles(lifecycles, options = { generationId: 'unknown' }) {
+    return buildHostDescriptor({ ...options, lifecycles });
+}
+/**
+ * Build the explicit legacy-mode Host Descriptor.
+ *
+ * P6 keeps this as a first-class mode, not a compatibility shim: it preserves
+ * the old default (`legacy` adapter mode) publication semantics. Command /
+ * LocalStorage / MessageObserver are declared when their legacy service rows
+ * are mounted, without running the new Kernel or any reversible live probe.
+ * It is deliberately distinct from the live-only
+ * `buildHostDescriptorFromLifecycles` path and returns warnings identifying it
+ * as a legacy declaration.
+ */
+export function buildLegacyHostDescriptor(options) {
+    return buildHostDescriptor({
+        hostId: options.hostId,
+        hostVersion: options.hostVersion,
+        generationId: options.generationId,
+        headless: options.headless,
+        specDir: options.specDir,
+        legacy: true,
+        legacySupported: options.supported,
+        legacyDecisionFeatures: options.decisionFeatures,
+    });
+}
+export function buildHostDescriptor(options) {
+    const warnings = [];
+    const dropped = [];
+    const contracts = [];
+    const data = loadSpecData(options.specDir);
+    // `loadSpecData` rejects malformed/empty facet declarations. Preserve the
+    // pinned values exactly when data is valid; use the schema-valid fallback
+    // only for the completely unavailable/degraded path.
+    const facetApiVersions = data === undefined
+        ? [...HOST_FACET_API_VERSIONS]
+        : [...data.registry.facetApiVersions];
+    const profileFailures = data === undefined ? [] : verifyContractProfiles(data);
+    const legacyMode = options.legacy === true && options.legacySupported !== undefined;
+    // Live lifecycle evidence is the only caller-facing publication source.
+    // The old no-lifecycles fallback (advertising HOST_SUPPORTED_CONTRACTS) has
+    // been removed: without live lifecycle evidence this host must not claim any
+    // negotiated support. Callers that only want static diagnostics get an empty
+    // contract surface plus an explicit non-live/host-unavailable warning.
+    if (options.lifecycles === undefined && !legacyMode) {
+        warnings.push('no live lifecycle evidence supplied; host descriptor advertises no contracts (host unavailable / non-live)');
+    }
+    if (legacyMode) {
+        warnings.push('legacy compatibility descriptor: contracts declared from the mounted legacy service topology without live probe evidence');
+    }
+    // Admission is a live/feature-split evidence path only. Degraded/staged
+    // capabilities are never admitted solely because a service row is mounted.
+    //
+    // The explicit exception is the legacy compatibility path used by the
+    // default `legacy` adapter mode. It is a separate, non-live declaration of
+    // the old mounted-service topology (kept alive for zero-behavior-change
+    // migration), not a fake live claim and never mixed into new-mode live
+    // descriptors.
+    const selected = legacyMode
+        ? options.legacySupported.map(coordinate => ({ coordinate, lifecycle: undefined }))
+        : options.lifecycles === undefined
+            ? []
+            : publishableLifecycles(options.lifecycles, warnings, dropped);
+    if (data === undefined) {
+        warnings.push('admission profile unavailable (dsh-ecosystem-spec/); advertising an empty protocol surface');
+    }
+    else {
+        const index = createContractIndex(data.registry, data.permissions);
+        for (const item of selected) {
+            const coordinate = item.coordinate;
+            const key = `${coordinate.apiVersion}#${coordinate.kind}`;
+            const entry = index.lookupContract(coordinate);
+            const definition = index.protocols.resolve(coordinate);
+            if (entry === undefined || definition === undefined) {
+                dropped.push(key);
+                warnings.push(`${key}: live implementation has no pinned ProtocolCatalog definition`);
+                continue;
+            }
+            if ('profile' in entry) {
+                if (profileFailures.length > 0) {
+                    dropped.push(key);
+                    warnings.push(`${key}: TUI contract profile self-check failed (${profileFailures.join(' | ')})`);
+                    continue;
+                }
+                let actual;
+                try {
+                    actual = digestFile(data.dir, entry.profile);
+                }
+                catch {
+                    dropped.push(key);
+                    warnings.push(`${key}: TUI profile is unreadable (${entry.profile})`);
+                    continue;
+                }
+                if (actual !== entry.profileHash) {
+                    dropped.push(key);
+                    warnings.push(`${key}: TUI profile hash drifted (expected ${entry.profileHash}, actual ${actual})`);
+                    continue;
+                }
+            }
+            const lifecycle = item.lifecycle;
+            // Legacy declarations use the same definition/registry resolution but
+            // do not invent a live support spec.
+            const spec = legacyMode
+                ? supportSpec(coordinate, undefined, options.legacyDecisionFeatures)
+                : supportSpec(coordinate, lifecycle);
+            try {
+                definition.validateSupport(spec);
+            }
+            catch (error) {
+                dropped.push(key);
+                warnings.push(`${key}: support spec rejected by its definition (${error instanceof Error ? error.message : String(error)})`);
+                continue;
+            }
+            contracts.push({
+                ...coordinate,
+                ...(spec === undefined ? {} : { spec }),
+                definition: 'package' in entry
+                    ? { source: 'dsh-std', package: entry.package }
+                    : { source: 'tui-profile', profileHash: entry.profileHash },
+                permissions: [...entry.permissions],
+            });
+        }
+    }
+    const descriptor = {
+        $schema: 'urn:dsh-tui:host-descriptor:0.15',
+        hostId: options.hostId ?? 'dsh-tui',
+        hostVersion: options.hostVersion ?? readOwnPackageVersion(),
+        facetApiVersions: [...facetApiVersions],
+        contracts,
+        runtime: {
+            location: 'local',
+            generationId: options.generationId,
+            headless: options.headless ?? false,
+        },
+        trustLevel: 'trusted-in-process',
+        platform: { os: process.platform, arch: process.arch, node: process.version },
+    };
+    if (data !== undefined) {
+        try {
+            validateHost(createContractIndex(data.registry, data.permissions), descriptor);
+        }
+        catch (error) {
+            warnings.push(`constructed descriptor failed semantic validation: ${error instanceof Error ? error.message : String(error)}`);
+            descriptor.contracts.length = 0;
+        }
+        try {
+            check(descriptor, data.schemas.host, data.schemas.host);
+        }
+        catch (error) {
+            warnings.push(`constructed descriptor failed schema validation: ${error instanceof Error ? error.message : String(error)}`);
+            descriptor.contracts.length = 0;
+        }
+    }
+    // The descriptor is handed to untrusted admission/diagnostic callers.  A
+    // cached mutable object would let one caller delete contracts or forge the
+    // runtime generation for every later negotiation, so freeze the complete
+    // graph and return immutable diagnostic arrays as well.
+    return Object.freeze({
+        descriptor: freezeDeep(descriptor),
+        dropped: Object.freeze(dropped),
+        warnings: Object.freeze(warnings),
+    });
+}

package/lib/types/{dsh-adapter → adapter/standard}/grants.d.ts

@@ -1,5 +1,6 @@
 /** Live, scoped plugin grant evaluation. */
-import type { PermissionRegistry } from '../plugin-spec/types.js';
+import type { PermissionRegistry } from './types.js';
+import { type AdapterRuntimeOptions } from '../kernel/runtime.js';
 export declare const EXTENSION_GRANTS_FILE = "extension-grants.json";
 export interface GrantPrincipal {
     componentId: string;
@@ -15,11 +16,15 @@ export interface GrantStore {
     readonly corrupt: boolean;
 }
 /** Parse a fixed snapshot, primarily for deterministic tests. */
-export declare function parseGrantStore(text: string, registry?: PermissionRegistry): GrantStore;
+export declare function parseGrantStore(text: string, registry?: PermissionRegistry, runtime?: AdapterRuntimeOptions): GrantStore;
 /**
  * Read grants on every decision. File changes therefore affect the next
  * operation without a restart. onChange uses a non-persistent watcher so
  * grant-owned subscriptions can be released even when no event is flowing.
+ *
+ * When called from a Cordis composition, pass the same immutable
+ * `adapterRuntimeFor(ctx)` snapshot so grant evaluation uses the same shadow
+ * policy as every other service in that composition root.
  */
-export declare function readGrantStore(dir?: string, registry?: PermissionRegistry): GrantStore;
+export declare function readGrantStore(dir?: string, registry?: PermissionRegistry, runtime?: AdapterRuntimeOptions): GrantStore;
 //# sourceMappingURL=grants.d.ts.map

package/lib/types/adapter/standard/grants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grants.d.ts","sourceRoot":"","sources":["../../../../src/adapter/standard/grants.ts"],"names":[],"mappings":"AAAA,4CAA4C;AAI5C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAGpD,OAAO,EAGL,KAAK,qBAAqB,EAC3B,MAAM,sBAAsB,CAAA;AAG7B,eAAO,MAAM,qBAAqB,0BAA0B,CAAA;AAE5D,MAAM,WAAW,cAAc;IAC7B,WAAW,EAAE,MAAM,CAAA;IACnB,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,UAAU;IACzB,8EAA8E;IAC9E,MAAM,CAAC,SAAS,EAAE,cAAc,GAAG,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAA;IACtF,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,CAAA;IAC/C,gBAAgB,IAAI,SAAS,MAAM,EAAE,CAAA;IACrC,+EAA+E;IAC/E,QAAQ,CAAC,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAA;IAC3C,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;CAC1B;AAoJD,iEAAiE;AACjE,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,QAAQ,CAAC,EAAE,kBAAkB,EAC7B,OAAO,GAAE,qBAA+C,GACvD,UAAU,CAKZ;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAC5B,GAAG,GAAE,MAAiB,EACtB,QAAQ,CAAC,EAAE,kBAAkB,EAC7B,OAAO,GAAE,qBAA+C,GACvD,UAAU,CA0DZ"}

package/lib/types/{dsh-adapter → adapter/standard}/grants.js

@@ -1,9 +1,10 @@
 /** Live, scoped plugin grant evaluation. */
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { normalizePermissionScope, permissionScopeCovers } from '../plugin-spec/permission-scope.js';
-import { loadSpecData } from '../plugin-spec/registry.js';
-import { DATA_DIR } from '../utils/paths.js';
+import { normalizePermissionScope, permissionScopeCovers } from './permission-scope.js';
+import { loadSpecData } from './registry.js';
+import { assertCapabilityShadowPolicy, defaultAdapterRuntime, } from '../kernel/runtime.js';
+import { DATA_DIR } from '../../utils/paths.js';
 export const EXTENSION_GRANTS_FILE = 'extension-grants.json';
 function parseRule(value) {
     if (typeof value === 'string')
@@ -103,7 +104,7 @@ function hasUnknownActivationRule(rules, principal, permission, scope) {
         return declared !== undefined && permissionScopeCovers(permission, declared, actual);
     });
 }
-function storeFrom(table, registry, onChange) {
+function storeFrom(table, registry, onChange, runtime = defaultAdapterRuntime()) {
     const known = new Map((registry?.permissions ?? []).map(entry => [entry.name, entry.default]));
     // The store is a capability, not a mutable configuration object.  Keep the
     // live table in the closure and freeze the facade so a traceable Cordis
@@ -114,6 +115,7 @@ function storeFrom(table, registry, onChange) {
             return table().corrupt;
         },
         allows(principalValue, permission, scope) {
+            assertCapabilityShadowPolicy('host.grants.evaluate', runtime.mode, runtime.slices);
             const current = table();
             if (current.corrupt || known.get(permission) === undefined)
                 return false;
@@ -137,18 +139,22 @@ function storeFrom(table, registry, onChange) {
     });
 }
 /** Parse a fixed snapshot, primarily for deterministic tests. */
-export function parseGrantStore(text, registry) {
+export function parseGrantStore(text, registry, runtime = defaultAdapterRuntime()) {
     const parsed = text === ''
         ? { grants: new Map(), denies: new Map(), corrupt: false }
         : parseTable(text);
-    return storeFrom(() => parsed, resolveRegistry(registry), () => () => undefined);
+    return storeFrom(() => parsed, resolveRegistry(registry), () => () => undefined, runtime);
 }
 /**
  * Read grants on every decision. File changes therefore affect the next
  * operation without a restart. onChange uses a non-persistent watcher so
  * grant-owned subscriptions can be released even when no event is flowing.
+ *
+ * When called from a Cordis composition, pass the same immutable
+ * `adapterRuntimeFor(ctx)` snapshot so grant evaluation uses the same shadow
+ * policy as every other service in that composition root.
  */
-export function readGrantStore(dir = DATA_DIR, registry) {
+export function readGrantStore(dir = DATA_DIR, registry, runtime = defaultAdapterRuntime()) {
     const file = join(dir, EXTENSION_GRANTS_FILE);
     const readCurrent = () => {
         let text;
@@ -209,5 +215,5 @@ export function readGrantStore(dir = DATA_DIR, registry) {
             }
         };
     };
-    return storeFrom(() => readCurrent().table, resolveRegistry(registry), onChange);
+    return storeFrom(() => readCurrent().table, resolveRegistry(registry), onChange, runtime);
 }

package/lib/types/adapter/standard/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Canonical dsh-std / dsh-ecosystem-spec plane for the TUI adapter.
+ *
+ * This is the single import point for protocol catalogs, Host Descriptor
+ * construction, admission/negotiation, permission scopes, grant evaluation
+ * and the pinned dsh-ecosystem-spec profile loader.
+ *
+ * Invariants:
+ * - No `@deepseek-ai/*` imports are allowed in this directory.
+ * - Protocol semantics stay owned by dsh-std / dsh-ecosystem-spec; Host Ports
+ *   must not invent a second protocol language.
+ * - P6 removed the legacy `src/plugin-spec/*` and
+ *   `src/dsh-adapter/{grants,host-descriptor}.ts` shims; production code
+ *   imports this canonical surface directly.
+ */
+export * from './types.js';
+export * from './protocols.js';
+export * from './schema-check.js';
+export * from './permission-scope.js';
+export * from './tui-extension.js';
+export * from './registry.js';
+export * from './admission.js';
+export * from './grants.js';
+export * from './descriptor.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/types/adapter/standard/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/adapter/standard/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,cAAc,YAAY,CAAA;AAC1B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,mBAAmB,CAAA;AACjC,cAAc,uBAAuB,CAAA;AACrC,cAAc,oBAAoB,CAAA;AAClC,cAAc,eAAe,CAAA;AAC7B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,aAAa,CAAA;AAC3B,cAAc,iBAAiB,CAAA"}

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

@@ -0,0 +1,24 @@
+/**
+ * Canonical dsh-std / dsh-ecosystem-spec plane for the TUI adapter.
+ *
+ * This is the single import point for protocol catalogs, Host Descriptor
+ * construction, admission/negotiation, permission scopes, grant evaluation
+ * and the pinned dsh-ecosystem-spec profile loader.
+ *
+ * Invariants:
+ * - No `@deepseek-ai/*` imports are allowed in this directory.
+ * - Protocol semantics stay owned by dsh-std / dsh-ecosystem-spec; Host Ports
+ *   must not invent a second protocol language.
+ * - P6 removed the legacy `src/plugin-spec/*` and
+ *   `src/dsh-adapter/{grants,host-descriptor}.ts` shims; production code
+ *   imports this canonical surface directly.
+ */
+export * from './types.js';
+export * from './protocols.js';
+export * from './schema-check.js';
+export * from './permission-scope.js';
+export * from './tui-extension.js';
+export * from './registry.js';
+export * from './admission.js';
+export * from './grants.js';
+export * from './descriptor.js';

package/lib/types/adapter/standard/negotiate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"negotiate.d.ts","sourceRoot":"","sources":["../../../../src/adapter/standard/negotiate.ts"],"names":[],"mappings":"AAAA,kFAAkF;AAIlF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAElD,OAAO,KAAK,EAAE,cAAc,EAAsB,mBAAmB,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAIzG,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,4EAA4E;IAC5E,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,SAAS,CACvB,KAAK,EAAE,aAAa,EACpB,QAAQ,EAAE,cAAc,EACxB,IAAI,EAAE,cAAc,EACpB,MAAM,GAAE,SAAS,iBAAiB,EAAO,GACxC,mBAAmB,CA6FrB"}

package/lib/types/{plugin-spec → adapter/standard}/permission-scope.d.ts

@@ -1,11 +1,8 @@
 /** Permission scope normalization shared by admission and runtime checks. */
+import { INTERCEPT_PERMISSIONS, INTERCEPT_EVENT_SCOPE_BY_PERMISSION, TUI_EVENT_SCOPE_NAMES } from '../spec/protocol-constants.js';
+export { INTERCEPT_PERMISSIONS, INTERCEPT_EVENT_SCOPE_BY_PERMISSION, TUI_EVENT_SCOPE_NAMES };
+/** Storage permission names are derived from the same vendored registry. */
 export declare const STORAGE_PERMISSIONS: Set<string>;
-export declare const INTERCEPT_PERMISSIONS: Set<string>;
-/** The decision point controlled by each intercept permission.  Keeping this
- * mapping in the scope adapter (rather than accepting every `tui/*` name for
- * every permission) prevents a manifest or grant from silently crossing an
- * event boundary. */
-export declare const INTERCEPT_EVENT_SCOPE_BY_PERMISSION: Readonly<Record<string, string>>;
 /** A session scope is carried through the message envelope and may also be
  * used by an intercept grant. Keep the canonical bound here so admission,
  * grant evaluation, and runtime delivery cannot disagree about whether a
@@ -26,7 +23,5 @@ export declare function scopeCovers(declared: NormalizedPermissionScope, actual:
  * denies, so a narrow `session:<id>` deny wins over a broad event grant.
  */
 export declare function permissionScopeCovers(permission: string, declared: NormalizedPermissionScope, actual: NormalizedPermissionScope): boolean;
-/** Decision permission scopes may be expressed as one named event point. */
-export declare const TUI_EVENT_SCOPE_NAMES: Set<string>;
 export declare function rawScopeCovers(permission: string, declared: string, actual: string, componentId: string): boolean;
 //# sourceMappingURL=permission-scope.d.ts.map

package/lib/types/adapter/standard/permission-scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permission-scope.d.ts","sourceRoot":"","sources":["../../../../src/adapter/standard/permission-scope.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAE7E,OAAO,EAEL,qBAAqB,EACrB,mCAAmC,EACnC,qBAAqB,EACtB,MAAM,+BAA+B,CAAA;AAEtC,OAAO,EAAE,qBAAqB,EAAE,mCAAmC,EAAE,qBAAqB,EAAE,CAAA;AAE5F,4EAA4E;AAC5E,eAAO,MAAM,mBAAmB,aAE/B,CAAA;AAGD;;;0BAG0B;AAC1B,eAAO,MAAM,uBAAuB,MAAM,CAAA;AAI1C,MAAM,MAAM,SAAS,GAAG,WAAW,GAAG,SAAS,GAAG,SAAS,GAAG,OAAO,CAAA;AAErE,MAAM,WAAW,yBAAyB;IACxC,IAAI,EAAE,SAAS,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;CACd;AAED,4EAA4E;AAC5E,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,GAClB,yBAAyB,GAAG,SAAS,CA2BvC;AAED,wBAAgB,WAAW,CAAC,QAAQ,EAAE,yBAAyB,EAAE,MAAM,EAAE,yBAAyB,GAAG,OAAO,CAI3G;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,yBAAyB,EACnC,MAAM,EAAE,yBAAyB,GAChC,OAAO,CAKT;AAED,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAMjH"}

package/lib/types/{plugin-spec → adapter/standard}/permission-scope.js

@@ -1,21 +1,8 @@
 /** Permission scope normalization shared by admission and runtime checks. */
-export const STORAGE_PERMISSIONS = new Set(['storage.local.read', 'storage.local.write']);
-export const INTERCEPT_PERMISSIONS = new Set([
-    'session.input.intercept',
-    'session.rewind.intercept',
-    'session.switch.intercept',
-    'session.compact.intercept',
-]);
-/** The decision point controlled by each intercept permission.  Keeping this
- * mapping in the scope adapter (rather than accepting every `tui/*` name for
- * every permission) prevents a manifest or grant from silently crossing an
- * event boundary. */
-export const INTERCEPT_EVENT_SCOPE_BY_PERMISSION = Object.freeze({
-    'session.input.intercept': 'tui/input',
-    'session.rewind.intercept': 'tui/rewind-prompt',
-    'session.switch.intercept': 'tui/session-switch',
-    'session.compact.intercept': 'tui/compact',
-});
+import { EXPECTED_PERMISSIONS, INTERCEPT_PERMISSIONS, INTERCEPT_EVENT_SCOPE_BY_PERMISSION, TUI_EVENT_SCOPE_NAMES, } from '../spec/protocol-constants.js';
+export { INTERCEPT_PERMISSIONS, INTERCEPT_EVENT_SCOPE_BY_PERMISSION, TUI_EVENT_SCOPE_NAMES };
+/** Storage permission names are derived from the same vendored registry. */
+export const STORAGE_PERMISSIONS = new Set(EXPECTED_PERMISSIONS.filter(permission => permission.name.startsWith('storage.local.')).map(permission => permission.name));
 /** A session scope is carried through the message envelope and may also be
  * used by an intercept grant. Keep the canonical bound here so admission,
  * grant evaluation, and runtime delivery cannot disagree about whether a
@@ -72,15 +59,6 @@ export function permissionScopeCovers(permission, declared, actual) {
         && declared.kind === 'event'
         && actual.kind === 'session';
 }
-/** Decision permission scopes may be expressed as one named event point. */
-export const TUI_EVENT_SCOPE_NAMES = new Set([
-    'tui/input',
-    'tui/rewind-prompt',
-    'tui/rewind-done',
-    'tui/session-switch',
-    'tui/session-switched',
-    'tui/compact',
-]);
 export function rawScopeCovers(permission, declared, actual, componentId) {
     const normalizedDeclared = normalizePermissionScope(permission, declared, componentId);
     const normalizedActual = normalizePermissionScope(permission, actual, componentId);

package/lib/types/adapter/standard/protocols.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Canonical re-export surface for dsh-std public protocol packages.
+ *
+ * This is the only place in the new adapter where dsh-std runtime/type APIs
+ * are re-exported for the legacy adapter layer. Consumer modules that still
+ * live in `src/dsh-adapter/` during incremental migration should import from
+ * here instead of importing `@dsh-std/*` directly.
+ */
+export { parseManifest, projectManifest } from '@dsh-std/manifest';
+export { validateMessageEvent } from '@dsh-std/messages';
+export { validateDeleteInput, validateDeleteOutput, validateGetInput, validateGetOutput, validateSetInput, validateSetOutput, } from '@dsh-std/storage';
+//# sourceMappingURL=protocols.d.ts.map

package/lib/types/adapter/standard/protocols.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocols.d.ts","sourceRoot":"","sources":["../../../../src/adapter/standard/protocols.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAClE,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAA;AACxD,OAAO,EACL,mBAAmB,EACnB,oBAAoB,EACpB,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,kBAAkB,CAAA"}

package/lib/types/adapter/standard/protocols.js

@@ -0,0 +1,11 @@
+/**
+ * Canonical re-export surface for dsh-std public protocol packages.
+ *
+ * This is the only place in the new adapter where dsh-std runtime/type APIs
+ * are re-exported for the legacy adapter layer. Consumer modules that still
+ * live in `src/dsh-adapter/` during incremental migration should import from
+ * here instead of importing `@dsh-std/*` directly.
+ */
+export { parseManifest, projectManifest } from '@dsh-std/manifest';
+export { validateMessageEvent } from '@dsh-std/messages';
+export { validateDeleteInput, validateDeleteOutput, validateGetInput, validateGetOutput, validateSetInput, validateSetOutput, } from '@dsh-std/storage';

package/lib/types/adapter/standard/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../src/adapter/standard/registry.ts"],"names":[],"mappings":"AAAA,4DAA4D;AAQ5D,OAAO,KAAK,EAAE,gBAAgB,EAAmB,kBAAkB,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAEtG,eAAO,MAAM,gBAAgB,6CAA6C,CAAA;AAC1E,eAAO,MAAM,uBAAuB,6CAA6C,CAAA;AAEjF,MAAM,WAAW,QAAQ;IACvB,GAAG,EAAE,MAAM,CAAA;IACX,QAAQ,EAAE,gBAAgB,CAAA;IAC1B,WAAW,EAAE,kBAAkB,CAAA;IAC/B,OAAO,EAAE;QACP,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;QAC7B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;QAC/B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAC/B,CAAA;CACF;AASD,wBAAgB,aAAa,CAAC,KAAK,GAAE,MAAgD,GAAG,MAAM,GAAG,SAAS,CASzG;AAiFD,wBAAgB,YAAY,CAAC,GAAG,GAAE,MAAM,GAAG,SAA2B,GAAG,QAAQ,GAAG,SAAS,CAiB5F;AAED,wBAAgB,eAAe,CAAC,QAAQ,EAAE,gBAAgB,GAAG,aAAa,EAAE,CAI3E;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,UAAU,MAAM,EAAE,CAE5E;AAED,sEAAsE;AACtE,wBAAgB,cAAc,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,EAAE,CAuCvD;AAED,4EAA4E;AAC5E,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,EAAE,CA2C/D"}