@deepseek-harness-tui/dsh-tui 0.8.0 → 0.8.2

package/lib/types/plugin-spec/registry.js

@@ -0,0 +1,252 @@
+/** Load and verify the pinned dsh-TUI admission profile. */
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createAdmissionCatalog } from './tui-extension.js';
+export const DSH_STD_REVISION = '614dfa1ac168db79fcf4577cf0ebb34e2e3b944b';
+export const ECOSYSTEM_SPEC_REVISION = 'e1b902b0f95f4280a8e68d414ec7a4d25d6ce106';
+const REGISTRY_FILE = join('registry', 'registry-0.15.json');
+const EXPECTED_PROFILE_VERSION = 'tui-admission/0.15';
+const EXPECTED_STD_REPOSITORY = 'https://github.com/Yan-Zero/dsh-std';
+const EXPECTED_STD_SUBMODULE = 'vendor/dsh-std';
+const EXPECTED_STD_MANIFEST_VERSION = '0.15';
+const EXPECTED_PERMISSION_REGISTRY_VERSION = '0.1';
+// The permission registry is policy, not merely input data. Keep the
+// admission defaults and scopes pinned to the reviewed dsh-ecosystem-spec
+// revision so a locally modified copy cannot silently widen a capability.
+const EXPECTED_PERMISSIONS = Object.freeze([
+    { name: 'storage.local.read', default: 'deny', revocable: true, scope: 'plugin namespace' },
+    { name: 'storage.local.write', default: 'deny', revocable: true, scope: 'plugin namespace' },
+    { name: 'commands.invoke', default: 'allow', revocable: true, scope: 'declared command id' },
+    { name: 'messages.observe.read', default: 'deny', revocable: true, scope: 'message observation scope' },
+    { name: 'session.input.intercept', default: 'deny', revocable: true, scope: 'decision event subscription' },
+    { name: 'session.rewind.intercept', default: 'deny', revocable: true, scope: 'decision event subscription' },
+    { name: 'session.switch.intercept', default: 'deny', revocable: true, scope: 'decision event subscription' },
+    { name: 'session.compact.intercept', default: 'deny', revocable: true, scope: 'decision event subscription' },
+]);
+export function locateSpecDir(start = dirname(fileURLToPath(import.meta.url))) {
+    let dir = start;
+    for (let index = 0; index < 8; index++) {
+        if (existsSync(join(dir, 'dsh-ecosystem-spec', REGISTRY_FILE)))
+            return join(dir, 'dsh-ecosystem-spec');
+        const parent = dirname(dir);
+        if (parent === dir)
+            return undefined;
+        dir = parent;
+    }
+    return undefined;
+}
+function loadJson(dir, relative) {
+    return JSON.parse(readFileSync(join(dir, relative), 'utf8'));
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function soundEntry(value, privateDefinition) {
+    if (!isRecord(value) || typeof value.name !== 'string' || value.name === ''
+        || (value.kind !== 'capability' && value.kind !== 'event'))
+        return false;
+    if (!isRecord(value.coordinates)
+        || typeof value.coordinates.apiVersion !== 'string' || value.coordinates.apiVersion === ''
+        || typeof value.coordinates.kind !== 'string' || value.coordinates.kind === '')
+        return false;
+    if (!Array.isArray(value.permissions) || !value.permissions.every(permission => typeof permission === 'string'))
+        return false;
+    if (privateDefinition) {
+        return value.authority === 'dsh-tui'
+            && typeof value.profile === 'string'
+            && value.profile.length > 0
+            && typeof value.profileHash === 'string'
+            && /^sha256:[0-9a-f]{64}$/u.test(value.profileHash);
+    }
+    return typeof value.package === 'string' && /^@dsh-std\/[a-z0-9][a-z0-9-]*$/u.test(value.package);
+}
+function structurallySound(data) {
+    if (!isRecord(data.registry)
+        || data.registry.profileVersion !== EXPECTED_PROFILE_VERSION
+        || !isRecord(data.registry.std)
+        || data.registry.std.repository !== EXPECTED_STD_REPOSITORY
+        || data.registry.std.submodule !== EXPECTED_STD_SUBMODULE
+        || data.registry.std.manifestVersion !== EXPECTED_STD_MANIFEST_VERSION
+        || !Array.isArray(data.registry.imports)
+        || !Array.isArray(data.registry.definitions)
+        || !Array.isArray(data.registry.facetApiVersions)
+        || data.registry.facetApiVersions.length === 0
+        || !data.registry.facetApiVersions.every(version => typeof version === 'string'
+            && /^v[0-9]+(?:alpha[0-9]+|beta[0-9]+)?$/u.test(version)))
+        return false;
+    if (new Set(data.registry.facetApiVersions).size !== data.registry.facetApiVersions.length)
+        return false;
+    if (!data.registry.imports.every(entry => soundEntry(entry, false)))
+        return false;
+    if (!data.registry.definitions.every(entry => soundEntry(entry, true)))
+        return false;
+    const entries = [...data.registry.imports, ...data.registry.definitions];
+    const names = new Set();
+    const coordinates = new Set();
+    for (const entry of entries) {
+        if (names.has(entry.name))
+            return false;
+        names.add(entry.name);
+        const key = `${entry.coordinates.apiVersion}#${entry.coordinates.kind}`;
+        if (coordinates.has(key))
+            return false;
+        coordinates.add(key);
+        if ('authority' in entry && !entry.coordinates.apiVersion.startsWith('tui.dsh/'))
+            return false;
+    }
+    if (!isRecord(data.permissions)
+        || data.permissions.registryVersion !== EXPECTED_PERMISSION_REGISTRY_VERSION
+        || !Array.isArray(data.permissions.permissions)
+        || data.permissions.permissions.length !== EXPECTED_PERMISSIONS.length)
+        return false;
+    const expectedPermissions = new Map(EXPECTED_PERMISSIONS.map(permission => [permission.name, permission]));
+    const permissionNames = new Set();
+    for (const permission of data.permissions.permissions) {
+        if (!isRecord(permission) || typeof permission.name !== 'string'
+            || (permission.default !== 'allow' && permission.default !== 'deny')
+            || typeof permission.revocable !== 'boolean'
+            || typeof permission.scope !== 'string'
+            || permission.scope.trim() === '')
+            return false;
+        if (permissionNames.has(permission.name))
+            return false;
+        permissionNames.add(permission.name);
+        const expected = expectedPermissions.get(permission.name);
+        if (expected === undefined
+            || permission.default !== expected.default
+            || permission.revocable !== expected.revocable
+            || permission.scope !== expected.scope)
+            return false;
+        if ('rationale' in permission && permission.rationale !== undefined && typeof permission.rationale !== 'string')
+            return false;
+    }
+    if (permissionNames.size !== expectedPermissions.size)
+        return false;
+    const knownPermissions = new Set(expectedPermissions.keys());
+    if (!entries.every(entry => entry.permissions.every(permission => knownPermissions.has(permission))))
+        return false;
+    return Object.values(data.schemas).every(isRecord);
+}
+export function loadSpecData(dir = locateSpecDir()) {
+    if (dir === undefined)
+        return undefined;
+    try {
+        const data = {
+            dir,
+            registry: loadJson(dir, REGISTRY_FILE),
+            permissions: loadJson(dir, join('registry', 'permissions-0.1.json')),
+            schemas: {
+                host: loadJson(dir, join('schemas', 'host-descriptor.schema.json')),
+                ledger: loadJson(dir, join('schemas', 'effect-ledger-record.schema.json')),
+                claim: loadJson(dir, join('schemas', 'conformance-claim.schema.json')),
+            },
+        };
+        return structurallySound(data) ? data : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function registryEntries(registry) {
+    return Array.isArray(registry.imports) && Array.isArray(registry.definitions)
+        ? [...registry.imports, ...registry.definitions]
+        : [];
+}
+export function digestFile(dir, relative) {
+    return `sha256:${createHash('sha256').update(readFileSync(join(dir, relative))).digest('hex')}`;
+}
+/** Verify definition availability and private profile digest pins. */
+export function verifyRegistry(data) {
+    const failures = [];
+    const registry = data?.registry;
+    if (!isRecord(registry)
+        || !Array.isArray(registry.imports)
+        || !Array.isArray(registry.definitions)) {
+        return ['registry imports/definitions are malformed'];
+    }
+    const names = new Set();
+    const coordinates = new Set();
+    const { protocols } = createAdmissionCatalog();
+    for (const raw of [...registry.imports, ...registry.definitions]) {
+        const privateDefinition = registry.definitions.includes(raw);
+        if (!soundEntry(raw, privateDefinition)) {
+            failures.push('registry entry is malformed');
+            continue;
+        }
+        const entry = raw;
+        const key = `${entry.coordinates.apiVersion}#${entry.coordinates.kind}`;
+        if (names.has(entry.name))
+            failures.push(`${entry.name}: duplicate registry name`);
+        names.add(entry.name);
+        if (coordinates.has(key))
+            failures.push(`${key}: duplicate registry coordinate`);
+        coordinates.add(key);
+        if ('authority' in entry && !entry.coordinates.apiVersion.startsWith('tui.dsh/')) {
+            failures.push(`${key}: dsh-tui definition must use the private protocol group`);
+        }
+        if (!protocols.understands(entry.coordinates))
+            failures.push(`${key}: ProtocolCatalog definition unavailable`);
+        if ('profile' in entry) {
+            let actual;
+            try {
+                actual = digestFile(data.dir, entry.profile);
+            }
+            catch {
+                failures.push(`${entry.name}: private profile unreadable (${entry.profile})`);
+                continue;
+            }
+            if (actual !== entry.profileHash)
+                failures.push(`${entry.name}: profileHash drifted (registry ${entry.profileHash}, actual ${actual})`);
+        }
+    }
+    return failures;
+}
+/** Verify the TUI-owned definitions; public definitions live in dsh-std. */
+export function verifyContractProfiles(data) {
+    const requiredKeys = [
+        'name', 'version', 'kind', 'coordinates', 'caller', 'permissions',
+        'errors', 'concurrency', 'timeout', 'cleanup', 'privacyClass', 'securityBoundary',
+    ];
+    const failures = [];
+    if (!isRecord(data?.registry)
+        || !Array.isArray(data.registry.definitions)) {
+        return ['registry definitions are malformed'];
+    }
+    for (const entry of data.registry.definitions) {
+        if (!soundEntry(entry, true)) {
+            failures.push('registry definition is malformed');
+            continue;
+        }
+        let profile;
+        try {
+            const loaded = loadJson(data.dir, entry.profile);
+            if (!isRecord(loaded)) {
+                failures.push(`${entry.name}: private profile is not an object (${entry.profile})`);
+                continue;
+            }
+            profile = loaded;
+        }
+        catch {
+            failures.push(`${entry.name}: private profile unreadable (${entry.profile})`);
+            continue;
+        }
+        for (const key of requiredKeys) {
+            if (!(key in profile))
+                failures.push(`${entry.name}: contract profile missing "${key}"`);
+        }
+        const coordinates = profile.coordinates;
+        if (coordinates?.apiVersion !== entry.coordinates.apiVersion || coordinates.kind !== entry.coordinates.kind) {
+            failures.push(`${entry.name}: profile/registry coordinates mismatch`);
+        }
+        const actualPermissions = [...(profile.permissions ?? [])].sort();
+        if (JSON.stringify(actualPermissions) !== JSON.stringify([...entry.permissions].sort())) {
+            failures.push(`${entry.name}: profile/registry permissions mismatch`);
+        }
+        if (!('operations' in profile) || profile.securityBoundary !== false) {
+            failures.push(`${entry.name}: capability boundary is incomplete`);
+        }
+    }
+    return failures;
+}

package/lib/types/plugin-spec/schema-check.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 零依赖 JSON Schema 校验器——上游 `conformance/tests/run.js` 的 check()
+ * 的保真 TS 移植。刻意只实现 vendored schemas 用到的子集：本地 $ref、
+ * oneOf（恰好一个匹配）、const/enum、object（required/additionalProperties:
+ * false/patternProperties）、array（min/maxItems/items/uniqueItems）、
+ * string（min/maxLength/pattern/format uri|date-time）、integer（minimum）、
+ * boolean。遇到子集之外的构件不静默放行——schema 更新引入新构件时这里
+ * 必须显式扩展（fixtures 矩阵会当场抓住）。
+ */
+type JsonSchema = Record<string, unknown>;
+/**
+ * Validate `value` against `schema`; throws an Error with the failing path
+ * (`$.a.b[0]: reason`) on the first violation.
+ */
+export declare function check(value: unknown, schema: JsonSchema, rootSchema?: JsonSchema, where?: string): void;
+export {};
+//# sourceMappingURL=schema-check.d.ts.map

package/lib/types/plugin-spec/schema-check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-check.d.ts","sourceRoot":"","sources":["../../../src/plugin-spec/schema-check.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAqCzC;;;GAGG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,GAAE,UAAmB,EAAE,KAAK,SAAM,GAAG,IAAI,CA0G5G"}

package/lib/types/plugin-spec/schema-check.js

@@ -0,0 +1,165 @@
+/**
+ * 零依赖 JSON Schema 校验器——上游 `conformance/tests/run.js` 的 check()
+ * 的保真 TS 移植。刻意只实现 vendored schemas 用到的子集：本地 $ref、
+ * oneOf（恰好一个匹配）、const/enum、object（required/additionalProperties:
+ * false/patternProperties）、array（min/maxItems/items/uniqueItems）、
+ * string（min/maxLength/pattern/format uri|date-time）、integer（minimum）、
+ * boolean。遇到子集之外的构件不静默放行——schema 更新引入新构件时这里
+ * 必须显式扩展（fixtures 矩阵会当场抓住）。
+ */
+/** Canonical JSON encoding for `uniqueItems`.  JSON object member order is not
+ * semantically significant, while `JSON.stringify` preserves insertion order
+ * and therefore lets equivalent objects evade duplicate detection. */
+function canonicalJson(value) {
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(',')}]`;
+    switch (typeof value) {
+        case 'object': {
+            const record = value;
+            return `{${Object.keys(record).sort().map(key => `${JSON.stringify(key)}:${canonicalJson(record[key])}`).join(',')}}`;
+        }
+        case 'string': return JSON.stringify(value);
+        case 'number': return JSON.stringify(value) ?? 'null';
+        case 'boolean': return value ? 'true' : 'false';
+        case 'undefined': return 'undefined';
+        default: return `${typeof value}:${String(value)}`;
+    }
+}
+function resolveRef(rootSchema, ref) {
+    if (!ref.startsWith('#/')) {
+        throw new Error(`external ref is not supported by the zero-dependency checker: ${ref}`);
+    }
+    return ref
+        .slice(2)
+        .split('/')
+        .reduce((value, key) => {
+        const child = value[key.replace(/~1/g, '/').replace(/~0/g, '~')];
+        if (child === null || typeof child !== 'object') {
+            throw new Error(`unresolvable $ref segment "${key}" in ${ref}`);
+        }
+        return child;
+    }, rootSchema);
+}
+/**
+ * Validate `value` against `schema`; throws an Error with the failing path
+ * (`$.a.b[0]: reason`) on the first violation.
+ */
+export function check(value, schema, rootSchema = schema, where = '$') {
+    if (typeof schema.$ref === 'string') {
+        return check(value, resolveRef(rootSchema, schema.$ref), rootSchema, where);
+    }
+    // oneOf: exactly one variant must match (JSON Schema semantics). Variants
+    // are currently mutually exclusive by design; exact-one keeps future
+    // overlap from being silently accepted.
+    if (Array.isArray(schema.oneOf)) {
+        let matched = 0;
+        const errors = [];
+        for (const variant of schema.oneOf) {
+            try {
+                check(value, variant, rootSchema, where);
+                matched += 1;
+            }
+            catch (error) {
+                errors.push(error instanceof Error ? error.message : String(error));
+            }
+        }
+        if (matched !== 1) {
+            throw new Error(`${where}: expected exactly one oneOf match, got ${matched}: ${errors.join(' | ')}`);
+        }
+        return;
+    }
+    if (schema.const !== undefined && value !== schema.const) {
+        throw new Error(`${where}: expected ${JSON.stringify(schema.const)}`);
+    }
+    if (Array.isArray(schema.enum) && !schema.enum.includes(value)) {
+        throw new Error(`${where}: value is not in enum`);
+    }
+    if (schema.type === 'object') {
+        if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+            throw new Error(`${where}: expected object`);
+        }
+        const record = value;
+        for (const key of schema.required ?? []) {
+            if (!(key in record))
+                throw new Error(`${where}.${key}: required`);
+        }
+        // draft-2020-12: additionalProperties consults properties AND
+        // patternProperties — a key matching a declared pattern is not
+        // "additional".
+        if (schema.additionalProperties === false) {
+            const patterns = Object.keys(schema.patternProperties ?? {});
+            for (const key of Object.keys(record)) {
+                const declared = schema.properties?.[key] !== undefined;
+                const patterned = patterns.some(pattern => new RegExp(pattern).test(key));
+                if (!declared && !patterned)
+                    throw new Error(`${where}.${key}: additional property`);
+            }
+        }
+        for (const [key, child] of Object.entries(schema.properties ?? {})) {
+            if (key in record)
+                check(record[key], child, rootSchema, `${where}.${key}`);
+        }
+        if (schema.patternProperties !== undefined) {
+            for (const [pattern, child] of Object.entries(schema.patternProperties)) {
+                for (const name of Object.keys(record)) {
+                    if (new RegExp(pattern).test(name))
+                        check(record[name], child, rootSchema, `${where}.${name}`);
+                }
+            }
+        }
+        return;
+    }
+    if (schema.type === 'array') {
+        if (!Array.isArray(value))
+            throw new Error(`${where}: expected array`);
+        if (schema.minItems !== undefined && value.length < schema.minItems) {
+            throw new Error(`${where}: too few items`);
+        }
+        if (schema.maxItems !== undefined && value.length > schema.maxItems) {
+            throw new Error(`${where}: too many items`);
+        }
+        for (let i = 0; i < value.length; i++) {
+            check(value[i], schema.items, rootSchema, `${where}[${i}]`);
+        }
+        if (schema.uniqueItems === true) {
+            const encoded = value.map(canonicalJson);
+            if (new Set(encoded).size !== encoded.length)
+                throw new Error(`${where}: duplicate items`);
+        }
+        return;
+    }
+    if (schema.type === 'string') {
+        if (typeof value !== 'string')
+            throw new Error(`${where}: expected string`);
+        if (schema.minLength !== undefined && value.length < schema.minLength) {
+            throw new Error(`${where}: too short`);
+        }
+        if (schema.maxLength !== undefined && value.length > schema.maxLength) {
+            throw new Error(`${where}: too long`);
+        }
+        if (schema.pattern !== undefined && !new RegExp(schema.pattern).test(value)) {
+            throw new Error(`${where}: pattern mismatch`);
+        }
+        if (schema.format === 'uri' && !/^[A-Za-z][A-Za-z0-9+.-]*:\/\//.test(value)) {
+            throw new Error(`${where}: invalid URI`);
+        }
+        if (schema.format === 'date-time' && Number.isNaN(Date.parse(value))) {
+            throw new Error(`${where}: invalid date-time`);
+        }
+        return;
+    }
+    if (schema.type === 'integer') {
+        if (!Number.isInteger(value))
+            throw new Error(`${where}: expected integer`);
+        if (schema.minimum !== undefined && value < schema.minimum) {
+            throw new Error(`${where}: below minimum`);
+        }
+        return;
+    }
+    if (schema.type === 'boolean') {
+        if (typeof value !== 'boolean')
+            throw new Error(`${where}: expected boolean`);
+    }
+}

package/lib/types/plugin-spec/tui-extension.d.ts

@@ -0,0 +1,16 @@
+/** dsh-TUI private protocol registration on the shared dsh-std catalog. */
+import { ProtocolCatalog, type ProtocolDefinition } from '@dsh-std/core';
+import { ManifestDefinitionCatalog } from '@dsh-std/manifest';
+import type { ContractCoordinate } from './types.js';
+export declare const TUI_EXTENSION_API_VERSION = "tui.dsh/v1alpha1";
+export declare const DECISION_EVENTS_COORDINATE: Readonly<ContractCoordinate>;
+export declare const TUI_DECISION_EVENT_NAMES: readonly ["tui/input", "tui/rewind-prompt", "tui/rewind-done", "tui/session-switch", "tui/session-switched", "tui/compact"];
+export declare const TUI_EXTENSION_PERMISSION_NAMES: readonly ["session.input.intercept", "session.rewind.intercept", "session.switch.intercept", "session.compact.intercept"];
+export declare const decisionEventsDefinition: ProtocolDefinition;
+export interface AdmissionCatalog {
+    protocols: ProtocolCatalog;
+    manifests: ManifestDefinitionCatalog;
+}
+/** Register public and private definitions into one evaluator-owned catalog. */
+export declare function createAdmissionCatalog(): AdmissionCatalog;
+//# sourceMappingURL=tui-extension.d.ts.map

package/lib/types/plugin-spec/tui-extension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tui-extension.d.ts","sourceRoot":"","sources":["../../../src/plugin-spec/tui-extension.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAE3E,OAAO,EAAE,eAAe,EAAE,KAAK,kBAAkB,EAAsB,MAAM,eAAe,CAAA;AAC5F,OAAO,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAA;AAM7D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAEpD,eAAO,MAAM,yBAAyB,qBAAqB,CAAA;AAE3D,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,kBAAkB,CAGlE,CAAA;AAEF,eAAO,MAAM,wBAAwB,6HAO1B,CAAA;AAEX,eAAO,MAAM,8BAA8B,2HAKhC,CAAA;AAiBX,eAAO,MAAM,wBAAwB,EAAE,kBAsBrC,CAAA;AAEF,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,eAAe,CAAA;IAC1B,SAAS,EAAE,yBAAyB,CAAA;CACrC;AAED,gFAAgF;AAChF,wBAAgB,sBAAsB,IAAI,gBAAgB,CAUzD"}

package/lib/types/plugin-spec/tui-extension.js

@@ -0,0 +1,79 @@
+/** dsh-TUI private protocol registration on the shared dsh-std catalog. */
+import { ProtocolCatalog } from '@dsh-std/core';
+import { ManifestDefinitionCatalog } from '@dsh-std/manifest';
+import { register as registerCommand } from '@dsh-std/command';
+import { register as registerMessages } from '@dsh-std/messages';
+import { register as registerPresentation } from '@dsh-std/presentation';
+import { register as registerStorage } from '@dsh-std/storage';
+import { tuiChannelDefinition } from '#dsh-ecosystem-spec/tui-channel';
+export const TUI_EXTENSION_API_VERSION = 'tui.dsh/v1alpha1';
+export const DECISION_EVENTS_COORDINATE = Object.freeze({
+    apiVersion: TUI_EXTENSION_API_VERSION,
+    kind: 'DecisionEvents',
+});
+export const TUI_DECISION_EVENT_NAMES = Object.freeze([
+    'tui/input',
+    'tui/rewind-prompt',
+    'tui/rewind-done',
+    'tui/session-switch',
+    'tui/session-switched',
+    'tui/compact',
+]);
+export const TUI_EXTENSION_PERMISSION_NAMES = Object.freeze([
+    'session.input.intercept',
+    'session.rewind.intercept',
+    'session.switch.intercept',
+    'session.compact.intercept',
+]);
+function featureSupport(value) {
+    if (value === undefined)
+        return Object.freeze({ features: Object.freeze([]) });
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new TypeError('DecisionEvents support spec must be an object');
+    }
+    const record = value;
+    const unknown = Object.keys(record).filter(key => key !== 'features' && !key.startsWith('x-'));
+    if (unknown.length > 0)
+        throw new TypeError(`DecisionEvents support spec contains unknown field ${JSON.stringify(unknown[0])}`);
+    if (record.features !== undefined && (!Array.isArray(record.features)
+        || record.features.some(feature => typeof feature !== 'string' || feature.trim() === ''))) {
+        throw new TypeError('DecisionEvents support spec.features must be an array of non-empty strings');
+    }
+    return Object.freeze({ features: Object.freeze([...(record.features ?? [])].sort()) });
+}
+export const decisionEventsDefinition = Object.freeze({
+    ...DECISION_EVENTS_COORDINATE,
+    validateRequirement(value) {
+        if (value !== undefined)
+            throw new TypeError('DecisionEvents requirement does not accept spec in manifest v0.15');
+        return undefined;
+    },
+    validateSupport: featureSupport,
+    negotiate(input) {
+        const providers = [...new Set(input.supports.map(row => row.participant))].sort();
+        const issues = input.requirements.flatMap(row => providers.length === 0
+            ? [{
+                    code: row.requirement.optional === true ? 'optional-support-missing' : 'required-support-missing',
+                    severity: row.requirement.optional === true ? 'warning' : 'error',
+                    participant: row.participant,
+                    message: 'DecisionEvents has no provider in this negotiation scope',
+                }]
+            : []);
+        return {
+            agreement: Object.freeze({ providers: Object.freeze(providers) }),
+            issues: Object.freeze(issues),
+        };
+    },
+});
+/** Register public and private definitions into one evaluator-owned catalog. */
+export function createAdmissionCatalog() {
+    const protocols = new ProtocolCatalog({ name: 'dsh-tui-admission', version: '0.15' });
+    const manifests = new ManifestDefinitionCatalog();
+    registerCommand(protocols, manifests);
+    registerStorage(protocols);
+    registerMessages(protocols);
+    registerPresentation(protocols);
+    protocols.register(decisionEventsDefinition);
+    protocols.register(tuiChannelDefinition);
+    return { protocols, manifests };
+}

package/lib/types/plugin-spec/types.d.ts

@@ -0,0 +1,114 @@
+/** Types shared by the dsh-std admission adapter and the TUI runtime. */
+import type { PluginManifest as StandardPluginManifest } from '@dsh-std/manifest';
+export interface ContractCoordinate {
+    apiVersion: string;
+    kind: string;
+}
+export interface ContractRef extends ContractCoordinate {
+    optional?: boolean;
+    fallback?: string;
+}
+export interface ManifestPermission {
+    name: string;
+    scope: string;
+    reason?: string;
+}
+export type SubscriptionRef = ContractCoordinate & {
+    scope?: string;
+} | string;
+/** Community v0.15 is parsed and frozen by @dsh-std/manifest. */
+export type PluginManifest = StandardPluginManifest;
+export type HostContractDefinition = {
+    source: 'dsh-std';
+    package: `@dsh-std/${string}`;
+} | {
+    source: 'tui-profile';
+    profileHash: `sha256:${string}`;
+};
+export interface HostContract extends ContractCoordinate {
+    spec?: unknown;
+    definition: HostContractDefinition;
+    permissions: string[];
+}
+export interface HostDescriptor {
+    $schema: 'urn:dsh-tui:host-descriptor:0.15';
+    hostId: string;
+    hostVersion: string;
+    facetApiVersions: string[];
+    contracts: HostContract[];
+    runtime: {
+        location: 'local' | 'remote' | 'container';
+        generationId: string;
+        headless: boolean;
+        remoteAttach?: boolean;
+    };
+    trustLevel: 'trusted-in-process';
+    platform: {
+        os: string;
+        arch: string;
+        node?: string;
+    };
+}
+export type NegotiationDecision = {
+    decision: 'compatible';
+} | {
+    decision: 'compatible_degraded';
+    missingOptional: string[];
+} | {
+    decision: 'waiting_authorization';
+    reasonCode: string;
+    deniedPermissions: string[];
+} | {
+    decision: 'rejected';
+    reasonCode: string;
+    missingRequired?: string[];
+    facetApiVersion?: string;
+    hostFacetApiVersions?: string[];
+    issues?: readonly unknown[];
+} | {
+    decision: 'unknown';
+    reasonCode: string;
+    unknownContracts: string[];
+};
+export declare const NEGOTIATION_ERROR_CODES: readonly ["REQUIRED_PROTOCOL_UNAVAILABLE", "PROTOCOL_NEGOTIATION_FAILED", "FACET_API_VERSION_UNAVAILABLE", "PERMISSION_NOT_GRANTED", "UNKNOWN_PROTOCOL_VERSION", "DUPLICATE_CONTRIBUTION_ID", "INVALID_MANIFEST"];
+export type NegotiationErrorCode = (typeof NEGOTIATION_ERROR_CODES)[number];
+export interface PermissionEntry {
+    name: string;
+    default: 'allow' | 'deny';
+    revocable: boolean;
+    scope: string;
+    rationale?: string;
+}
+export interface PermissionRegistry {
+    registryVersion: string;
+    permissions: PermissionEntry[];
+}
+interface RegistryEntryBase {
+    name: string;
+    coordinates: ContractCoordinate;
+    kind: 'capability' | 'event';
+    permissions: string[];
+    eventEnvelope?: string;
+}
+export interface ImportedRegistryEntry extends RegistryEntryBase {
+    package: `@dsh-std/${string}`;
+}
+export interface PrivateRegistryEntry extends RegistryEntryBase {
+    authority: 'dsh-tui';
+    profile: string;
+    profileHash: `sha256:${string}`;
+}
+export type RegistryEntry = ImportedRegistryEntry | PrivateRegistryEntry;
+export interface ContractRegistry {
+    profileVersion: string;
+    std: {
+        repository: string;
+        submodule: string;
+        manifestVersion: string;
+    };
+    imports: ImportedRegistryEntry[];
+    definitions: PrivateRegistryEntry[];
+    facetApiVersions: string[];
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

package/lib/types/plugin-spec/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/plugin-spec/types.ts"],"names":[],"mappings":"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"}

package/lib/types/plugin-spec/types.js

@@ -0,0 +1,10 @@
+/** Types shared by the dsh-std admission adapter and the TUI runtime. */
+export const NEGOTIATION_ERROR_CODES = [
+    'REQUIRED_PROTOCOL_UNAVAILABLE',
+    'PROTOCOL_NEGOTIATION_FAILED',
+    'FACET_API_VERSION_UNAVAILABLE',
+    'PERMISSION_NOT_GRANTED',
+    'UNKNOWN_PROTOCOL_VERSION',
+    'DUPLICATE_CONTRIBUTION_ID',
+    'INVALID_MANIFEST',
+];