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

package/lib/types/dsh-adapter/plugin-host.js

@@ -32,7 +32,7 @@
  *   per-contract at descriptor build time; boot must not die on drifted
  *   vendored data).
  */
-import { Service } from '@deepseek-ai/cordis';
+import { Context, Service } from '@deepseek-ai/cordis';
 import { randomUUID } from 'node:crypto';
 import { parseManifest, projectManifest } from '@dsh-std/manifest';
 import { loadSpecData, verifyContractProfiles, verifyRegistry } from '../plugin-spec/registry.js';
@@ -46,18 +46,23 @@ import { TuiMessageObserverRuntime } from './message-observer.js';
 import { stampCommandOwner, unstampCommandOwner } from './command-attribution.js';
 import { hasCommandErrorCode, mapCommandError } from './command-errors.js';
 import { installDecisionGuard, decisionHandlerMetadataOf, registerDecisionHandler, withDecisionRegistration, } from './decision-guard.js';
-import { bindComponentIdentity, declaresCommand, requiresDecisionEvents, requireComponentIdentity, } from './component-identity.js';
+import { bindComponentIdentity, declaresCommand, requiresDecisionEvents, requiresContract, requireComponentIdentity, } from './component-identity.js';
+import { activationContext, activationFiber, assertCallerContext, bindCallerEffect, compositionRoot, concreteService } from './host-access.js';
 /** `ctx.tuiPluginHost` — plugin-interop anchor (generation, grants, descriptor). */
 export class TuiPluginHostRuntime extends Service {
     /** Runtime generation id (C-050): fresh per activation of this row. */
-    generationId = randomUUID();
+    get generationId() { return hostStateFor(this).generationId; }
     /** Live scoped grant store; every operation observes the current file. */
-    grants;
-    descriptorBuild;
-    descriptorCommandsMounted;
+    get grants() { return hostStateFor(this).grants; }
     constructor(ctx) {
         super(ctx, 'tuiPluginHost');
-        this.grants = readGrantStore();
+        hostStates.set(this, {
+            hostContext: compositionRoot(ctx),
+            generationId: randomUUID(),
+            grants: Object.freeze(readGrantStore()),
+            descriptorBuild: undefined,
+            descriptorTopology: undefined,
+        });
         // The host row may be mounted without the extensions row or a channel;
         // decision registration must remain mediated in that degraded topology.
         installDecisionGuard(ctx, this.grants);
@@ -79,30 +84,63 @@ export class TuiPluginHostRuntime extends Service {
         return this.build();
     }
     build() {
-        // C-010 honesty: advertise Command only when the commands service is
-        // actually mounted — a bare/embedded context without dsh-commands must
-        // not negotiate `compatible` for a capability plugins will never get.
-        // Probed on every descriptor request: the service can mount or unmount
-        // after the first lazy build.
-        const commandsMounted = this.ctx.get('commands') !== undefined;
-        if (this.descriptorBuild === undefined || this.descriptorCommandsMounted !== commandsMounted) {
-            const supported = HOST_SUPPORTED_CONTRACTS.filter(contract => contract.kind !== 'Command' || commandsMounted);
-            this.descriptorBuild = buildHostDescriptor({ generationId: this.generationId, supported });
-            this.descriptorCommandsMounted = commandsMounted;
+        const state = hostStateFor(this);
+        const host = state.hostContext;
+        // C-010 honesty: advertise a runtime capability only while its service is
+        // actually mounted. Probed on every descriptor request because sibling
+        // rows can mount after this service, and embedders can unload them later.
+        const commandsMounted = host.get('commands') !== undefined;
+        const storageMounted = host.get('tuiPluginStorage') !== undefined;
+        const observerMounted = host.get('tuiMessageObserver') !== undefined;
+        const topology = `${Number(commandsMounted)}:${Number(storageMounted)}:${Number(observerMounted)}`;
+        if (state.descriptorBuild === undefined || state.descriptorTopology !== topology) {
+            const supported = HOST_SUPPORTED_CONTRACTS.filter(contract => {
+                if (contract.kind === 'Command')
+                    return commandsMounted;
+                if (contract.kind === 'LocalStorage')
+                    return storageMounted;
+                if (contract.kind === 'MessageObserver')
+                    return observerMounted;
+                return true;
+            });
+            state.descriptorBuild = buildHostDescriptor({ generationId: state.generationId, supported });
+            state.descriptorTopology = topology;
             if (!commandsMounted) {
-                this.ctx.logger.warn('dsh-tui: host descriptor: commands.dsh/v1alpha1#Command excluded — the commands service is not mounted on this context');
+                host.logger.warn('dsh-tui: host descriptor: commands.dsh/v1alpha1#Command excluded — the commands service is not mounted on this context');
             }
-            for (const warning of this.descriptorBuild.warnings) {
-                this.ctx.logger.warn(`dsh-tui: host descriptor: ${warning}`);
+            if (!storageMounted) {
+                host.logger.warn('dsh-tui: host descriptor: storage.dsh/v1alpha1#LocalStorage excluded — the tuiPluginStorage service is not mounted on this context');
+            }
+            if (!observerMounted) {
+                host.logger.warn('dsh-tui: host descriptor: messages.dsh/v1alpha1#MessageObserver excluded — the tuiMessageObserver service is not mounted on this context');
+            }
+            for (const warning of state.descriptorBuild.warnings) {
+                host.logger.warn(`dsh-tui: host descriptor: ${warning}`);
             }
         }
-        return this.descriptorBuild;
+        return state.descriptorBuild;
     }
     /**
      * Parse, project, validate, negotiate, and bind one activation's Component
      * identity before any mediated runtime capability can be used.
      */
     admit(pluginCtx, source, options = {}) {
+        // Admission binds an untrusted manifest to a privileged activation.  A
+        // plugin-facing service proxy must not be able to choose another
+        // component's id and inherit its grants, so the loader uses the
+        // host-only accessor below instead of this public compatibility method.
+        void pluginCtx;
+        void source;
+        void options;
+        throw new Error('dsh-tui: admission is host-owned; the loader must use its admission capability');
+    }
+    /** @internal Host loader entry; the unexported token prevents proxy calls. */
+    admitInternal(pluginCtx, source, options = {}, token) {
+        if (token !== HOST_ADMISSION_TOKEN) {
+            throw new Error('dsh-tui: admission capability is host-owned');
+        }
+        const host = hostContextFor(this);
+        const caller = assertActivationContext(host, pluginCtx);
         const manifest = parseManifest(source, { source: options.source });
         // The host owns the activation instance identity. Embedders may provide a
         // pre-issued id when policy has an activation-scoped grant; otherwise a
@@ -111,6 +149,10 @@ export class TuiPluginHostRuntime extends Service {
         const data = loadSpecData();
         if (data === undefined)
             throw new Error('dsh-tui: admission profile is unavailable');
+        const specViolations = [...verifyRegistry(data), ...verifyContractProfiles(data)];
+        if (specViolations.length > 0) {
+            throw new Error(`dsh-tui: admission profile self-check failed: ${specViolations.join(' | ')}`);
+        }
         const index = createContractIndex(data.registry, data.permissions);
         validatePlugin(index, manifest);
         const projection = projectManifest(manifest);
@@ -118,13 +160,13 @@ export class TuiPluginHostRuntime extends Service {
             .map(request => ({
             name: request.name,
             scope: request.scope,
-            granted: this.grants.allows({ componentId: manifest.id, activationId }, request.name, request.scope),
+            granted: hostStateFor(this).grants.allows({ componentId: manifest.id, activationId }, request.name, request.scope),
         }));
         const decision = negotiate(index, manifest, this.hostDescriptor(), grants);
         if (decision.decision !== 'compatible' && decision.decision !== 'compatible_degraded') {
             throw new Error(`dsh-tui: Component ${manifest.id} admission ${decision.decision}: ${'reasonCode' in decision ? decision.reasonCode : 'incompatible'}`);
         }
-        return bindComponentIdentity(pluginCtx, manifest, projection, activationId);
+        return bindComponentIdentity(caller, manifest, projection, activationId);
     }
     /**
      * Host-mediated DecisionEvents activation surface.  A plugin cannot use a
@@ -134,13 +176,16 @@ export class TuiPluginHostRuntime extends Service {
      * the activation so deactivation cannot leave an effect behind.
      */
     subscribeDecision(pluginCtx, event, listener, options = {}) {
-        const identity = requireComponentIdentity(pluginCtx);
+        const host = hostContextFor(this);
+        const caller = assertActivationContext(host, pluginCtx);
+        assertCallerContext(this.ctx, caller, 'DecisionEvents.subscribe', this);
+        const identity = requireComponentIdentity(caller);
         if (!requiresDecisionEvents(identity)) {
             throw new Error(`dsh-tui: Component "${identity.componentId}" must require tui.dsh/v1alpha1#DecisionEvents before subscribing`);
         }
         const previousMetadata = decisionHandlerMetadataOf(listener);
-        const release = withDecisionRegistration(pluginCtx, () => registerDecisionHandler(pluginCtx, identity, event, listener, options, () => {
-            this.ctx.get('tuiEffectLedger')?.record({ operation: 'release', resource: { kind: 'decision-handler', id: `${identity.componentId}:${event}` }, result: 'applied' }, pluginCtx);
+        const release = withDecisionRegistration(caller, () => registerDecisionHandler(caller, identity, event, listener, options, () => {
+            host.get('tuiEffectLedger')?.record({ operation: 'release', resource: { kind: 'decision-handler', id: `${identity.componentId}:${event}` }, result: 'applied' }, caller);
         }));
         // A missing live grant is represented by a no-op disposer rather than an
         // exception. Do not write a successful bind record for that path; the
@@ -151,26 +196,32 @@ export class TuiPluginHostRuntime extends Service {
             && metadata.activationId === identity.activationId
             && metadata.event === event;
         if (!registered) {
-            this.ctx.get('tuiEffectLedger')?.record({
+            host.get('tuiEffectLedger')?.record({
                 operation: 'bind',
                 resource: { kind: 'permission', id: `${event}` },
                 result: 'failed',
                 errorCode: 'PERMISSION_NOT_GRANTED',
-            }, pluginCtx);
+            }, caller);
             return () => false;
         }
-        this.ctx.get('tuiEffectLedger')?.record({ operation: 'bind', resource: { kind: 'decision-handler', id: `${identity.componentId}:${event}` }, result: 'applied' }, pluginCtx);
+        host.get('tuiEffectLedger')?.record({ operation: 'bind', resource: { kind: 'decision-handler', id: `${identity.componentId}:${event}` }, result: 'applied' }, caller);
         return release;
     }
     registerCommand(pluginCtx, contributionOrDefinition, explicitDefinition) {
+        const host = hostContextFor(this);
+        const caller = assertActivationContext(host, pluginCtx);
+        assertCallerContext(this.ctx, caller, 'commands.register', this);
         // Resolve through the registrant context so dsh-commands attaches the
         // registration to that agent's scoped layer rather than the host-global
         // layer. Its traceable service proxy carries this context into register().
-        const commands = pluginCtx.get('commands');
+        const commands = caller.get('commands');
         if (commands === undefined) {
             throw new Error('dsh-tui: registerCommand unavailable — the commands service is not mounted on this context');
         }
-        const identity = requireComponentIdentity(pluginCtx);
+        const identity = requireComponentIdentity(caller);
+        if (!requiresContract(identity, 'commands.dsh/v1alpha1', 'Command')) {
+            throw new Error(`dsh-tui: Component "${identity.componentId}" must require commands.dsh/v1alpha1#Command before registering commands`);
+        }
         const definition = typeof contributionOrDefinition === 'string' ? explicitDefinition : contributionOrDefinition;
         if (definition === undefined)
             throw new TypeError('dsh-tui: registerCommand requires a command definition');
@@ -201,33 +252,28 @@ export class TuiPluginHostRuntime extends Service {
         }
         catch (error) {
             const mapped = mapCommandError(error);
-            this.ctx.get('tuiEffectLedger')?.record({
+            host.get('tuiEffectLedger')?.record({
                 operation: 'create',
                 resource: { kind: 'command', id: contributionId },
                 result: 'failed',
                 errorCode: hasCommandErrorCode(mapped, 'DUPLICATE_CONTRIBUTION_ID') ? 'DUPLICATE_CONTRIBUTION_ID' : 'COMMAND_FAILED',
-            }, pluginCtx);
+            }, caller);
             throw mapped;
         }
-        stampCommandOwner(this.ctx, attributedDefinition, identity, contributionId);
-        this.ctx.get('tuiEffectLedger')?.record({ operation: 'create', resource: { kind: 'command', id: contributionId }, result: 'applied' }, pluginCtx);
+        stampCommandOwner(host, attributedDefinition, identity, contributionId);
+        host.get('tuiEffectLedger')?.record({ operation: 'create', resource: { kind: 'command', id: contributionId }, result: 'applied' }, caller);
         let released = false;
         const release = () => {
             if (released)
                 return;
             released = true;
-            unstampCommandOwner(this.ctx, attributedDefinition, identity.activationId);
-            this.ctx.get('tuiEffectLedger')?.record({ operation: 'release', resource: { kind: 'command', id: contributionId }, result: 'applied' }, pluginCtx);
+            unstampCommandOwner(host, attributedDefinition, identity.activationId);
+            host.get('tuiEffectLedger')?.record({ operation: 'release', resource: { kind: 'command', id: contributionId }, result: 'applied' }, caller);
         };
         // commands.register() already belongs to pluginCtx and therefore removes
         // the definition on fiber teardown. Keep the attribution in that same
         // lifecycle even when the caller never invokes our returned wrapper.
-        try {
-            pluginCtx.effect(() => release);
-        }
-        catch {
-            // Degraded contexts retain the wrapper-only cleanup path below.
-        }
+        bindCallerEffect(caller, release);
         let disposed = false;
         return () => {
             if (disposed)
@@ -249,10 +295,59 @@ export class TuiPluginHostRuntime extends Service {
     selfCheck() {
         const data = loadSpecData();
         if (data === undefined)
-            return ['vendored spec data unavailable (ecosystem-spec/)'];
+            return ['vendored spec data unavailable (dsh-ecosystem-spec/)'];
         return [...verifyRegistry(data), ...verifyContractProfiles(data)];
     }
 }
+const HOST_ADMISSION_TOKEN = Symbol('dsh-tui.host-admission');
+const hostStates = new WeakMap();
+function hostStateFor(runtime) {
+    const state = hostStates.get(concreteService(runtime));
+    if (state === undefined)
+        throw new Error('tuiPluginHost host state is unavailable');
+    return state;
+}
+function hostContextFor(runtime) {
+    return hostStateFor(runtime).hostContext;
+}
+export function getHostAdmission(runtime) {
+    if (runtime === undefined)
+        return undefined;
+    try {
+        const concrete = concreteService(runtime);
+        return {
+            admit: (pluginCtx, source, options = {}) => concrete.admitInternal(pluginCtx, source, options, HOST_ADMISSION_TOKEN),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+/** A mediated capability must be bound to a live non-root activation in the
+ * same Cordis composition as the host row. In particular, accepting
+ * `ctx.root` would leave identity, commands, or handlers alive after the
+ * plugin fiber unloads. */
+function assertActivationContext(hostCtx, pluginCtx) {
+    try {
+        const root = compositionRoot(hostCtx);
+        const caller = Context.is(pluginCtx) ? activationContext(pluginCtx) : undefined;
+        const rootFiber = activationFiber(root);
+        const callerFiber = caller === undefined ? undefined : activationFiber(caller);
+        if (caller === undefined
+            || compositionRoot(caller) !== root
+            || caller === root
+            || callerFiber === undefined
+            || callerFiber === rootFiber) {
+            throw new Error('dsh-tui: mediated capability requires a non-root activation context from the host composition');
+        }
+        return caller;
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.startsWith('dsh-tui:'))
+            throw error;
+        throw new Error('dsh-tui: mediated capability requires a live activation context');
+    }
+}
 export const name = 'dsh-tui-plugin-host';
 export function apply(ctx) {
     // The plugin-host service first — the contract surfaces mounted below

package/lib/types/dsh-adapter/plugin-storage.d.ts

@@ -85,11 +85,6 @@ export declare function storageFileName(plugin: string): string;
  * (normal path) or a private read otherwise (bare mounts in tests).
  */
 export declare class TuiPluginStorageRuntime extends Service {
-    private readonly grantsOption;
-    private readonly fallbackGrants;
-    private readonly ledgerOption;
-    private readonly namespaces;
-    private readonly dir;
     constructor(ctx: Context, options?: {
         dir?: string;
         grants?: GrantStore;

package/lib/types/dsh-adapter/plugin-storage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin-storage.d.ts","sourceRoot":"","sources":["../../../src/dsh-adapter/plugin-storage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAKH,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAWtD,OAAO,EAAkB,KAAK,UAAU,EAAE,MAAM,aAAa,CAAA;AAC7D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAA;AAEhE,8CAA8C;AAC9C,eAAO,MAAM,gBAAgB,MAAM,CAAA;AACnC,6DAA6D;AAC7D,eAAO,MAAM,iBAAiB,QAAa,CAAA;AAC3C,mCAAmC;AACnC,eAAO,MAAM,sBAAsB,MAAM,CAAA;AAEzC,MAAM,MAAM,sBAAsB,GAC9B,wBAAwB,GACxB,aAAa,GACb,eAAe,GACf,gBAAgB,GAChB,qBAAqB,CAAA;AAEzB,iEAAiE;AACjE,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,QAAQ,CAAC,IAAI,EAAE,sBAAsB,CAAA;gBACzB,IAAI,EAAE,sBAAsB,EAAE,OAAO,EAAE,MAAM;CAK1D;AAED,iFAAiF;AACjF,MAAM,WAAW,gBAAgB;IAC/B,GAAG,CAAC,KAAK,EAAE;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC;QAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAAA;KAAE,CAAC,CAAA;IAC/D,GAAG,CAAC,KAAK,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC;QAAE,MAAM,EAAE,IAAI,CAAA;KAAE,CAAC,CAAA;IACtE,MAAM,CAAC,KAAK,EAAE;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC,CAAA;CAC9D;AAED,OAAO,QAAQ,qBAAqB,CAAC;IACnC,UAAU,OAAO;QACf,gBAAgB,EAAE,uBAAuB,CAAA;KAC1C;CACF;AAED,8CAA8C;AAC9C,eAAO,MAAM,kBAAkB,mBAAmB,CAAA;AAElD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAGtD;AAgID;;;;GAIG;AACH,qBAAa,uBAAwB,SAAQ,OAAO;IAClD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAwB;IACrD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAY;IAC3C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAoC;IACjE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAoC;IAC/D,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAQ;gBAEhB,GAAG,EAAE,OAAO,EAAE,OAAO,GAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,UAAU,CAAC;QAAC,MAAM,CAAC,EAAE,sBAAsB,CAAA;KAAO;IAQ9G;;;gDAG4C;IAC5C,OAAO,CAAC,MAAM;IAId,2EAA2E;IAC3E,OAAO,CAAC,MAAM;IAId;;;;;OAKG;IACH,IAAI,CAAC,SAAS,EAAE,OAAO,GAAG,gBAAgB;CA2K3C"}
+{"version":3,"file":"plugin-storage.d.ts","sourceRoot":"","sources":["../../../src/dsh-adapter/plugin-storage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAKH,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAYtD,OAAO,EAAkB,KAAK,UAAU,EAAE,MAAM,aAAa,CAAA;AAC7D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAA;AAEhE,8CAA8C;AAC9C,eAAO,MAAM,gBAAgB,MAAM,CAAA;AACnC,6DAA6D;AAC7D,eAAO,MAAM,iBAAiB,QAAa,CAAA;AAC3C,mCAAmC;AACnC,eAAO,MAAM,sBAAsB,MAAM,CAAA;AAEzC,MAAM,MAAM,sBAAsB,GAC9B,wBAAwB,GACxB,aAAa,GACb,eAAe,GACf,gBAAgB,GAChB,qBAAqB,CAAA;AAEzB,iEAAiE;AACjE,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,QAAQ,CAAC,IAAI,EAAE,sBAAsB,CAAA;gBACzB,IAAI,EAAE,sBAAsB,EAAE,OAAO,EAAE,MAAM;CAK1D;AAmBD,iFAAiF;AACjF,MAAM,WAAW,gBAAgB;IAC/B,GAAG,CAAC,KAAK,EAAE;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC;QAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAAA;KAAE,CAAC,CAAA;IAC/D,GAAG,CAAC,KAAK,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC;QAAE,MAAM,EAAE,IAAI,CAAA;KAAE,CAAC,CAAA;IACtE,MAAM,CAAC,KAAK,EAAE;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC,CAAA;CAC9D;AAED,OAAO,QAAQ,qBAAqB,CAAC;IACnC,UAAU,OAAO;QACf,gBAAgB,EAAE,uBAAuB,CAAA;KAC1C;CACF;AAED,8CAA8C;AAC9C,eAAO,MAAM,kBAAkB,mBAAmB,CAAA;AAElD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAGtD;AAgID;;;;GAIG;AACH,qBAAa,uBAAwB,SAAQ,OAAO;gBACtC,GAAG,EAAE,OAAO,EAAE,OAAO,GAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,UAAU,CAAC;QAAC,MAAM,CAAC,EAAE,sBAAsB,CAAA;KAAO;IAY9G;;;gDAG4C;IAC5C,OAAO,CAAC,MAAM;IAKd,2EAA2E;IAC3E,OAAO,CAAC,MAAM;IAKd;;;;;OAKG;IACH,IAAI,CAAC,SAAS,EAAE,OAAO,GAAG,gBAAgB;CAiL3C"}

package/lib/types/dsh-adapter/plugin-storage.js

@@ -38,7 +38,8 @@ import { writeFileAtomic, withFileLock } from '@deepseek-ai/dsh-atomic-write';
 import { Service } from '@deepseek-ai/cordis';
 import { validateDeleteInput, validateGetInput, validateSetInput, validateGetOutput, validateSetOutput, validateDeleteOutput, } from '@dsh-std/storage';
 import { DATA_DIR } from '../utils/paths.js';
-import { declaresPermission, requireComponentIdentity } from './component-identity.js';
+import { activationContext, assertCallerContext, bindCallerEffect, compositionRoot, concreteService } from './host-access.js';
+import { declaresPermission, requireComponentIdentity, requiresContract } from './component-identity.js';
 import { readGrantStore } from './grants.js';
 /** Quota: max distinct keys per namespace. */
 export const STORAGE_MAX_KEYS = 256;
@@ -55,6 +56,13 @@ export class PluginStorageError extends Error {
         this.code = code;
     }
 }
+const storageStates = new WeakMap();
+function storageStateFor(runtime) {
+    const state = storageStates.get(concreteService(runtime));
+    if (state === undefined)
+        throw new Error('tuiPluginStorage host state is unavailable');
+    return state;
+}
 /** Namespace directory under the data dir. */
 export const PLUGIN_STORAGE_DIR = 'plugin-storage';
 /**
@@ -203,28 +211,29 @@ function isJsonValue(value, seen) {
  * (normal path) or a private read otherwise (bare mounts in tests).
  */
 export class TuiPluginStorageRuntime extends Service {
-    grantsOption;
-    fallbackGrants;
-    ledgerOption;
-    namespaces = new Map();
-    dir;
     constructor(ctx, options = {}) {
         super(ctx, 'tuiPluginStorage');
-        this.grantsOption = options.grants;
-        this.fallbackGrants = readGrantStore();
-        this.ledgerOption = options.ledger;
-        this.dir = options.dir ?? join(DATA_DIR, PLUGIN_STORAGE_DIR);
+        storageStates.set(this, {
+            hostContext: compositionRoot(ctx),
+            grantsOption: options.grants,
+            fallbackGrants: readGrantStore(),
+            ledgerOption: options.ledger,
+            namespaces: new Map(),
+            dir: options.dir ?? join(DATA_DIR, PLUGIN_STORAGE_DIR),
+        });
     }
     /** Grants: the plugin-host row's store when mounted, else a private read.
      *  Resolved PER CALL — sibling services mounted later by the same apply()
      *  are not visible to constructors (cordis), so a constructor-time probe
      *  would silently stick to the fallback. */
     grants() {
-        return this.grantsOption ?? this.ctx.get('tuiPluginHost')?.grants ?? this.fallbackGrants;
+        const state = storageStateFor(this);
+        return state.grantsOption ?? state.hostContext.get('tuiPluginHost')?.grants ?? state.fallbackGrants;
     }
     /** Optional observability; a bare mount (tests) simply records nothing. */
     ledger() {
-        return this.ledgerOption ?? this.ctx.get('tuiEffectLedger');
+        const state = storageStateFor(this);
+        return state.ledgerOption ?? state.hostContext.get('tuiEffectLedger');
     }
     /**
      * Open the caller's private namespace. Identity = the PASSED context's
@@ -233,40 +242,43 @@ export class TuiPluginStorageRuntime extends Service {
      * disposer); data is retained (contract cleanup rule).
      */
     open(pluginCtx) {
-        const identity = requireComponentIdentity(pluginCtx);
+        const caller = activationContext(pluginCtx);
+        if (caller === undefined)
+            throw new PluginStorageError('STORAGE_UNAVAILABLE', 'storage.local.open requires a live activation context');
+        assertCallerContext(this.ctx, caller, 'storage.local.open', this);
+        const state = storageStateFor(this);
+        const identity = requireComponentIdentity(caller);
+        if (!requiresContract(identity, 'storage.dsh/v1alpha1', 'LocalStorage')) {
+            throw new PluginStorageError('PERMISSION_NOT_GRANTED', 'storage.local requires the storage.dsh/v1alpha1#LocalStorage contract in the admitted manifest');
+        }
         const plugin = identity.componentId;
-        let state = this.namespaces.get(plugin);
-        if (state === undefined) {
-            state = { chain: Promise.resolve() };
-            this.namespaces.set(plugin, state);
+        let namespace = state.namespaces.get(plugin);
+        if (namespace === undefined) {
+            namespace = { chain: Promise.resolve() };
+            state.namespaces.set(plugin, namespace);
         }
-        this.ledger()?.record({ operation: 'create', resource: { kind: 'storage-namespace', id: plugin }, result: 'applied' }, pluginCtx);
+        this.ledger()?.record({ operation: 'create', resource: { kind: 'storage-namespace', id: plugin }, result: 'applied' }, caller);
         // `closed` is PER HANDLE, not per namespace: unloading one fiber must not
         // kill another handle opened on the same namespace. Close on unload;
-        // idempotent (a double-close stays harmless by design); degraded contexts
-        // without `effect` simply never auto-close.
+        // idempotent (a double-close stays harmless by design).
         let closed = false;
-        try {
-            pluginCtx.effect(() => () => {
-                if (closed)
-                    return;
-                closed = true;
-                this.ledger()?.record({ operation: 'release', resource: { kind: 'storage-namespace', id: plugin }, result: 'applied' }, pluginCtx);
-            });
-        }
-        catch {
-            // Degraded context: the handle lives until process end.
-        }
-        const file = join(this.dir, `${storageFileName(plugin)}.json`);
+        const close = () => {
+            if (closed)
+                return;
+            closed = true;
+            this.ledger()?.record({ operation: 'release', resource: { kind: 'storage-namespace', id: plugin }, result: 'applied' }, caller);
+        };
+        bindCallerEffect(caller, close);
+        const file = join(state.dir, `${storageFileName(plugin)}.json`);
         const grants = () => this.grants();
         const ledger = () => this.ledger();
         const enqueue = (operation) => {
             if (closed) {
                 return Promise.reject(new PluginStorageError('STORAGE_UNAVAILABLE', `storage namespace "${plugin}" handle is closed`));
             }
-            const run = state.chain.then(operation);
+            const run = namespace.chain.then(operation);
             // Keep the chain alive after a failure without unhandled rejections.
-            state.chain = run.catch(() => { });
+            namespace.chain = run.catch(() => { });
             return run;
         };
         const readTable = () => {
@@ -306,7 +318,7 @@ export class TuiPluginStorageRuntime extends Service {
                     resource: { kind: 'permission', id: permission },
                     result: 'failed',
                     errorCode: 'PERMISSION_NOT_GRANTED',
-                }, pluginCtx);
+                }, caller);
                 throw new PluginStorageError('PERMISSION_NOT_GRANTED', `storage.${permission.endsWith('.read') ? 'get' : 'set/delete'} from plugin "${plugin}" denied — grant "${permission}" ` +
                     `for "${plugin}" in ~/.dsh-tui/extension-grants.json first`);
             }
@@ -316,7 +328,7 @@ export class TuiPluginStorageRuntime extends Service {
         // path (read paths tolerate ENOENT as an empty namespace and never
         // materialize the tree).
         const ensureDir = () => {
-            mkdirSync(this.dir, { recursive: true, mode: 0o700 });
+            mkdirSync(state.dir, { recursive: true, mode: 0o700 });
         };
         return {
             get: (input) => enqueue(async () => {

package/lib/types/dsh-adapter/plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../../src/dsh-adapter/plugin.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,KAAK,EAAe,MAAM,wBAAwB,CAAA;AAGhE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAGlD,OAAO,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAiCnC;;;;;;;;GAQG;AACH,wBAAsB,KAAK,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA6iBvE;AA6GD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE;IAAE,UAAU,EAAE,CAAC,KAAK,CAAC,EAAE,OAAO,KAAK,IAAI,CAAA;CAAE,GAAG;IACjF,UAAU,EAAE,CAAC,KAAK,CAAC,EAAE,OAAO,KAAK,IAAI,CAAA;IACrC,YAAY,EAAE,MAAM,IAAI,CAAA;CACzB,CAcA;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE;IACpC,YAAY,EAAE,MAAM,CAAA;IACpB,SAAS,EAAE,KAAK,GAAG,SAAS,CAAA;IAC5B,YAAY,EAAE,KAAK,CAAA;CACpB,GAAG,OAAO,CAQV"}
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../../src/dsh-adapter/plugin.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,KAAK,EAAe,MAAM,wBAAwB,CAAA;AAGhE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAGlD,OAAO,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAmCnC;;;;;;;;GAQG;AACH,wBAAsB,KAAK,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAmmBvE;AA6GD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE;IAAE,UAAU,EAAE,CAAC,KAAK,CAAC,EAAE,OAAO,KAAK,IAAI,CAAA;CAAE,GAAG;IACjF,UAAU,EAAE,CAAC,KAAK,CAAC,EAAE,OAAO,KAAK,IAAI,CAAA;IACrC,YAAY,EAAE,MAAM,IAAI,CAAA;CACzB,CAcA;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE;IACpC,YAAY,EAAE,MAAM,CAAA;IACpB,SAAS,EAAE,KAAK,GAAG,SAAS,CAAA;IAC5B,YAAY,EAAE,KAAK,CAAA;CACpB,GAAG,OAAO,CAQV"}