@askdkc/dsh-cli 0.11.3

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('dsh-cli/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 === 'dsh-cli'
+                && 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/adapter/standard/grants.d.ts

@@ -0,0 +1,30 @@
+/** Live, scoped plugin grant evaluation. */
+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;
+    activationId?: string;
+}
+export interface GrantStore {
+    /** Evaluate one concrete operation scope. Missing/unsupported scopes deny. */
+    allows(principal: GrantPrincipal | string, permission: string, scope: string): boolean;
+    defaultOf(permission: string): 'allow' | 'deny';
+    knownPermissions(): readonly string[];
+    /** Subscribe to file changes. Used to actively release grant-owned effects. */
+    onChange?(listener: () => void): () => void;
+    readonly corrupt: boolean;
+}
+/** Parse a fixed snapshot, primarily for deterministic tests. */
+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, 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/adapter/standard/grants.js

@@ -0,0 +1,219 @@
+/** Live, scoped plugin grant evaluation. */
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+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')
+        return { permission: value, legacy: true };
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const record = value;
+    if (Object.keys(record).some(key => !['name', 'scope', 'activationId'].includes(key)))
+        return undefined;
+    if (typeof record.name !== 'string' || typeof record.scope !== 'string')
+        return undefined;
+    if (record.activationId !== undefined && typeof record.activationId !== 'string')
+        return undefined;
+    return {
+        permission: record.name,
+        scope: record.scope,
+        ...(record.activationId === undefined ? {} : { activationId: record.activationId }),
+        legacy: false,
+    };
+}
+function parseTable(text) {
+    const grants = new Map();
+    const denies = new Map();
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return { grants, denies, corrupt: true };
+    }
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        return { grants, denies, corrupt: true };
+    }
+    const root = parsed;
+    if (Object.keys(root).some(key => key !== 'grants' && key !== 'denies')) {
+        return { grants, denies, corrupt: true };
+    }
+    const readSection = (key, target) => {
+        const section = root[key];
+        if (section === undefined)
+            return true;
+        if (section === null || typeof section !== 'object' || Array.isArray(section))
+            return false;
+        for (const [componentId, values] of Object.entries(section)) {
+            if (componentId === '' || !Array.isArray(values))
+                return false;
+            const rules = values.map(parseRule);
+            if (rules.some(rule => rule === undefined))
+                return false;
+            target.set(componentId, rules);
+        }
+        return true;
+    };
+    if (!readSection('grants', grants) || !readSection('denies', denies)) {
+        return { grants: new Map(), denies: new Map(), corrupt: true };
+    }
+    return { grants, denies, corrupt: false };
+}
+function resolveRegistry(registry) {
+    return registry ?? loadSpecData()?.permissions;
+}
+function principalParts(principal) {
+    return typeof principal === 'string' ? { componentId: principal } : principal;
+}
+function ruleMatches(rule, principal, permission, scope, mode = 'grant') {
+    if (rule.permission !== permission)
+        return false;
+    if (rule.activationId !== undefined && rule.activationId !== principal.activationId)
+        return false;
+    const actual = normalizePermissionScope(permission, scope, principal.componentId);
+    if (actual === undefined)
+        return false;
+    // A legacy string row carries no resource/session/command scope. Treating a
+    // legacy GRANT as a wildcard would silently enlarge a grant during the v0.15
+    // migration, so it never authorizes. A legacy DENY is safe to apply
+    // conservatively to every enforceable scope: it can reduce availability but
+    // cannot widen access or make revocation ineffective.
+    if (rule.legacy)
+        return mode === 'deny';
+    const declared = normalizePermissionScope(permission, rule.scope ?? '', principal.componentId);
+    return declared !== undefined && permissionScopeCovers(permission, declared, actual);
+}
+/** An unbound/diagnostic principal cannot safely inherit a default or an
+ * unscoped rule when an activation-specific rule could apply. Returning deny
+ * here is conservative: callers must admit a real activation before using a
+ * grant whose lifetime is activation-scoped. */
+function hasUnknownActivationRule(rules, principal, permission, scope) {
+    if (principal.activationId !== undefined)
+        return false;
+    const actual = normalizePermissionScope(permission, scope, principal.componentId);
+    if (actual === undefined)
+        return false;
+    return rules.some(rule => {
+        if (rule.legacy || rule.permission !== permission || rule.activationId === undefined)
+            return false;
+        const declared = normalizePermissionScope(permission, rule.scope ?? '', principal.componentId);
+        return declared !== undefined && permissionScopeCovers(permission, declared, actual);
+    });
+}
+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
+    // proxy (or an accidentally retained reference) cannot replace `allows`
+    // and turn an authorization check into an unconditional allow.
+    return Object.freeze({
+        get corrupt() {
+            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;
+            const principal = principalParts(principalValue);
+            if (normalizePermissionScope(permission, scope, principal.componentId) === undefined)
+                return false;
+            const denies = current.denies.get(principal.componentId) ?? [];
+            const grants = current.grants.get(principal.componentId) ?? [];
+            if (hasUnknownActivationRule(denies, principal, permission, scope)
+                || hasUnknownActivationRule(grants, principal, permission, scope))
+                return false;
+            if (denies.some(rule => ruleMatches(rule, principal, permission, scope, 'deny')))
+                return false;
+            if (grants.some(rule => ruleMatches(rule, principal, permission, scope, 'grant')))
+                return true;
+            return known.get(permission) === 'allow';
+        },
+        defaultOf: permission => known.get(permission) ?? 'deny',
+        knownPermissions: () => [...known.keys()],
+        onChange,
+    });
+}
+/** Parse a fixed snapshot, primarily for deterministic tests. */
+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, 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, runtime = defaultAdapterRuntime()) {
+    const file = join(dir, EXTENSION_GRANTS_FILE);
+    const readCurrent = () => {
+        let text;
+        let missing = false;
+        try {
+            text = readFileSync(file, 'utf8');
+        }
+        catch (error) {
+            missing = error.code === 'ENOENT';
+            text = missing ? '' : '{unreadable';
+        }
+        return {
+            // An existing zero-byte file is corruption, not the same state as an
+            // absent grants file. Only ENOENT receives the registry defaults.
+            table: missing
+                ? { grants: new Map(), denies: new Map(), corrupt: false }
+                : parseTable(text),
+            signature: text,
+        };
+    };
+    const listeners = new Set();
+    let watching = false;
+    let watchTimer;
+    let signature = readCurrent().signature;
+    const changed = () => {
+        const next = readCurrent().signature;
+        if (next === signature)
+            return;
+        signature = next;
+        for (const listener of [...listeners]) {
+            try {
+                listener();
+            }
+            catch {
+                // A lifecycle observer is advisory; one faulty cleanup callback must
+                // not prevent the remaining subscriptions from seeing revocation.
+            }
+        }
+    };
+    const onChange = (listener) => {
+        listeners.add(listener);
+        if (!watching) {
+            watching = true;
+            // A small unref'ed poll is deterministic across filesystems and
+            // timestamp granularities. The synchronous read on every operation
+            // remains the authorization source of truth; this loop only releases
+            // grant-owned subscriptions promptly after a revocation.
+            watchTimer = setInterval(changed, 50);
+            watchTimer.unref?.();
+        }
+        return () => {
+            listeners.delete(listener);
+            if (watching && listeners.size === 0) {
+                watching = false;
+                if (watchTimer !== undefined)
+                    clearInterval(watchTimer);
+                watchTimer = undefined;
+            }
+        };
+    };
+    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

@@ -0,0 +1,11 @@
+/** Five-state admission decision using dsh-std projection and ProtocolCatalog. */
+import type { ContractIndex } from './validate.js';
+import type { HostDescriptor, NegotiationDecision, PluginManifest } from './types.js';
+export interface GrantedPermission {
+    name: string;
+    scope: string;
+    /** Explicit effective answer. Omitted means a legacy positive grant row. */
+    granted?: boolean;
+}
+export declare function negotiate(index: ContractIndex, manifest: PluginManifest, host: HostDescriptor, grants?: readonly GrantedPermission[]): NegotiationDecision;
+//# sourceMappingURL=negotiate.d.ts.map