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

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

@@ -1 +1 @@
-{"version":3,"file":"childStderr.d.ts","sourceRoot":"","sources":["../../../src/dsh-adapter/childStderr.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAsDH;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAAG,MAAM,IAAI,CA8BhF;AAED,0EAA0E;AAC1E,MAAM,WAAW,iBAAiB;IAChC,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,GAAG,SAAS,GAAG,SAAS,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAA;CAChG;AAED,MAAM,WAAW,0BAA0B;IACzC,qFAAqF;IACrF,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,8EAA8E;IAC9E,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,yFAAyF;IACzF,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB;AAED,MAAM,WAAW,mBAAmB;IAClC,gCAAgC;IAChC,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,iDAAiD;IACjD,OAAO,IAAI,IAAI,CAAA;CAChB;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,iBAAiB,EACzB,OAAO,GAAE,0BAA+B,GACvC,mBAAmB,CA4CrB"}
+{"version":3,"file":"childStderr.d.ts","sourceRoot":"","sources":["../../../src/dsh-adapter/childStderr.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAsDH;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAAG,MAAM,IAAI,CA8BhF;AAED,0EAA0E;AAC1E,MAAM,WAAW,iBAAiB;IAChC,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,GAAG,SAAS,GAAG,SAAS,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAA;CAChG;AAED,MAAM,WAAW,0BAA0B;IACzC,qFAAqF;IACrF,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,8EAA8E;IAC9E,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,yFAAyF;IACzF,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB;AAED,MAAM,WAAW,mBAAmB;IAClC,gCAAgC;IAChC,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,iDAAiD;IACjD,OAAO,IAAI,IAAI,CAAA;CAChB;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,iBAAiB,EACzB,OAAO,GAAE,0BAA+B,GACvC,mBAAmB,CAqDrB"}

package/lib/types/dsh-adapter/childStderr.js

@@ -145,6 +145,16 @@ export function createChildStderrReporter(notify, options = {}) {
                 // A burst inside the cooldown window is counted but stays silent.
                 if ((mutedUntil.get(line) ?? 0) > Date.now())
                     return;
+                // Prune expired cooldowns on the way in: entries are child-stderr
+                // lines and a long-lived MCP reconnect loop would otherwise grow the
+                // dedup table without bound.
+                if (mutedUntil.size > 64) {
+                    const now = Date.now();
+                    for (const [key, until] of mutedUntil) {
+                        if (until <= now)
+                            mutedUntil.delete(key);
+                    }
+                }
                 mutedUntil.set(line, Date.now() + cooldownMs);
                 const text = group.count > 1
                     ? t('child-stderr-line-repeat', { line, count: group.count })

package/lib/types/dsh-adapter/command-attribution.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Command ownership attribution — the data source for the C-041 invoke
+ * checkpoint's per-owner grant decision.
+ *
+ * dsh-commands has NO owner concept (its `normalizeDefinition` rebuilds a
+ * frozen object and drops unknown fields, and its scoped layers key by
+ * agent, not by registrant), and neither realistic access path can carry
+ * the caller's identity to `register` for us: `ctx.get('commands')` is an
+ * accessor that bypasses cordis's `internal/get` waterfall, and an
+ * inject-declared property read resolves before it. So attribution does
+ * NOT try to spy on the registry — it is a MEDIATED REGISTRATION surface,
+ * the same honest-identity pattern as storage.local / messages.observe:
+ * the plugin-host row's `registerCommand(pluginCtx, definition)` supplies a
+ * unique wrapper handler and stamps that actual registered definition with
+ * the verified Component id and activation on success. The invoke checkpoint resolves the
+ * effective definition for its receiving agent first, then looks up that
+ * definition's handler here. This mirrors dsh-commands' scoped shadowing:
+ * same-name definitions in separate agent scopes never share attribution.
+ *
+ * A plugin that registers directly through `ctx.get('commands')` keeps its
+ * command UNATTRIBUTED: the invoke checkpoint then applies the root grant
+ * only — the documented C-070 trusted-in-process boundary, exactly like a
+ * plugin calling `ctx.commands.execute` directly. Attribution only ever
+ * TIGHTENS the check, never widens it.
+ *
+ * The map is keyed by the cordis ROOT so the row and the channel (two
+ * different contexts of one runtime) share one view.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { VerifiedComponentIdentity } from './component-identity.js';
+export interface CommandOwner {
+    componentId: string;
+    activationId: string;
+    commandId: string;
+}
+/** The registrant's display name for diagnostics only: the passed context's
+ * fiber name (nearest named ancestor), 'root' for host-side or degraded
+ * contexts. Authorization never uses this display value. */
+export declare function fiberNameOf(ctx: Context): string;
+/** Record one mediated command definition's owner after successful registration. */
+export declare function stampCommandOwner(ctx: Context, definition: unknown, identity: VerifiedComponentIdentity, commandId: string): void;
+/** Lift one definition's stamp without touching a later registration. */
+export declare function unstampCommandOwner(ctx: Context, definition: unknown, activationId: string): void;
+/**
+ * The recorded owner of the EFFECTIVE command definition, or undefined when
+ * it is unattributed (root-side/direct registrations are the documented
+ * C-070 boundary). Callers must pass `commands.find(agent, name)`, not only
+ * the command name, so agent-scoped shadows select their own owner.
+ */
+export declare function commandOwner(ctx: Context, definition: unknown): CommandOwner | undefined;
+//# sourceMappingURL=command-attribution.d.ts.map

package/lib/types/dsh-adapter/command-attribution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-attribution.d.ts","sourceRoot":"","sources":["../../../src/dsh-adapter/command-attribution.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAA;AAGxE,MAAM,WAAW,YAAY;IAC3B,WAAW,EAAE,MAAM,CAAA;IACnB,YAAY,EAAE,MAAM,CAAA;IACpB,SAAS,EAAE,MAAM,CAAA;CAClB;AAQD;;4DAE4D;AAC5D,wBAAgB,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAQhD;AAYD,oFAAoF;AACpF,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,OAAO,EACZ,UAAU,EAAE,OAAO,EACnB,QAAQ,EAAE,yBAAyB,EACnC,SAAS,EAAE,MAAM,GAChB,IAAI,CAUN;AAED,yEAAyE;AACzE,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI,CAMjG;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,GAAG,YAAY,GAAG,SAAS,CAKxF"}

package/lib/types/dsh-adapter/command-attribution.js

@@ -0,0 +1,93 @@
+/**
+ * Command ownership attribution — the data source for the C-041 invoke
+ * checkpoint's per-owner grant decision.
+ *
+ * dsh-commands has NO owner concept (its `normalizeDefinition` rebuilds a
+ * frozen object and drops unknown fields, and its scoped layers key by
+ * agent, not by registrant), and neither realistic access path can carry
+ * the caller's identity to `register` for us: `ctx.get('commands')` is an
+ * accessor that bypasses cordis's `internal/get` waterfall, and an
+ * inject-declared property read resolves before it. So attribution does
+ * NOT try to spy on the registry — it is a MEDIATED REGISTRATION surface,
+ * the same honest-identity pattern as storage.local / messages.observe:
+ * the plugin-host row's `registerCommand(pluginCtx, definition)` supplies a
+ * unique wrapper handler and stamps that actual registered definition with
+ * the verified Component id and activation on success. The invoke checkpoint resolves the
+ * effective definition for its receiving agent first, then looks up that
+ * definition's handler here. This mirrors dsh-commands' scoped shadowing:
+ * same-name definitions in separate agent scopes never share attribution.
+ *
+ * A plugin that registers directly through `ctx.get('commands')` keeps its
+ * command UNATTRIBUTED: the invoke checkpoint then applies the root grant
+ * only — the documented C-070 trusted-in-process boundary, exactly like a
+ * plugin calling `ctx.commands.execute` directly. Attribution only ever
+ * TIGHTENS the check, never widens it.
+ *
+ * The map is keyed by the cordis ROOT so the row and the channel (two
+ * different contexts of one runtime) share one view.
+ */
+import { compositionRoot } from './host-access.js';
+const ownerMaps = new WeakMap();
+function rootKeyOf(ctx) {
+    return compositionRoot(ctx);
+}
+/** The registrant's display name for diagnostics only: the passed context's
+ * fiber name (nearest named ancestor), 'root' for host-side or degraded
+ * contexts. Authorization never uses this display value. */
+export function fiberNameOf(ctx) {
+    try {
+        const resolved = ctx.fiber?.name;
+        if (typeof resolved === 'string' && resolved !== '')
+            return resolved;
+    }
+    catch {
+        // Degraded context without fiber access: 'root'.
+    }
+    return 'root';
+}
+function handlerOf(definition) {
+    try {
+        const handler = definition?.handler;
+        return typeof handler === 'function' ? handler : undefined;
+    }
+    catch {
+        // An exotic definition cannot participate in attribution safely.
+        return undefined;
+    }
+}
+/** Record one mediated command definition's owner after successful registration. */
+export function stampCommandOwner(ctx, definition, identity, commandId) {
+    const key = rootKeyOf(ctx);
+    const handler = handlerOf(definition);
+    if (key === undefined || handler === undefined)
+        return;
+    let map = ownerMaps.get(key);
+    if (map === undefined) {
+        map = new WeakMap();
+        ownerMaps.set(key, map);
+    }
+    map.set(handler, Object.freeze({ componentId: identity.componentId, activationId: identity.activationId, commandId }));
+}
+/** Lift one definition's stamp without touching a later registration. */
+export function unstampCommandOwner(ctx, definition, activationId) {
+    const key = rootKeyOf(ctx);
+    const handler = handlerOf(definition);
+    if (key === undefined || handler === undefined)
+        return;
+    const map = ownerMaps.get(key);
+    if (map?.get(handler)?.activationId === activationId)
+        map.delete(handler);
+}
+/**
+ * The recorded owner of the EFFECTIVE command definition, or undefined when
+ * it is unattributed (root-side/direct registrations are the documented
+ * C-070 boundary). Callers must pass `commands.find(agent, name)`, not only
+ * the command name, so agent-scoped shadows select their own owner.
+ */
+export function commandOwner(ctx, definition) {
+    const key = rootKeyOf(ctx);
+    const handler = handlerOf(definition);
+    if (key === undefined || handler === undefined)
+        return undefined;
+    return ownerMaps.get(key)?.get(handler);
+}

package/lib/types/dsh-adapter/command-errors.d.ts

@@ -0,0 +1,42 @@
+/**
+ * commands contract error-code alignment (C-041,
+ * `commands.dsh/v1alpha1#Command`): the official `dsh-commands` runtime
+ * reports a duplicate registration as a plain `Error` whose MESSAGE is the
+ * only signal:
+ *
+ *   `command "<name>" is already registered (…)`
+ *   `command "<name>" is already registered in this scope`
+ *
+ * The v0.15 contract names the code `DUPLICATE_CONTRIBUTION_ID`. This module
+ * maps the message-shaped error onto an `Error` carrying that `.code`, at
+ * the HOST-MEDIATED registration/invocation points (the channel's skill
+ * command registration and registry-command execution).
+ *
+ * Known boundary (C-070, trusted-in-process): a plugin calling
+ * `ctx.commands.register` / `ctx.commands.execute` DIRECTLY bypasses this
+ * mapping — code-level wrapping can only cover the points the host owns.
+ * That is declared platform behavior, not a bug.
+ */
+/** The contract's command error vocabulary. */
+export declare const COMMAND_ERROR_CODES: readonly ["COMMAND_NOT_FOUND", "DUPLICATE_CONTRIBUTION_ID", "PERMISSION_NOT_GRANTED", "COMMAND_FAILED", "INVOCATION_CANCELLED", "INVOCATION_DEADLINE_EXCEEDED"];
+export type CommandErrorCode = (typeof COMMAND_ERROR_CODES)[number];
+/** An Error carrying a contract error code on `.code`. */
+export interface CodedCommandError extends Error {
+    code: CommandErrorCode;
+    cause?: unknown;
+}
+/**
+ * Map a thrown dsh-commands error onto its contract code. A duplicate
+ * registration comes back as a CodedCommandError with
+ * `DUPLICATE_CONTRIBUTION_ID` (original on `.cause`); every other value
+ * passes through unchanged.
+ */
+export declare function mapCommandError(error: unknown): unknown;
+/** True when `error` carries the given contract code. */
+export declare function hasCommandErrorCode(error: unknown, code: CommandErrorCode): boolean;
+/**
+ * Run `operation` and rethrow any duplicate-registration failure with its
+ * contract code attached (see {@link mapCommandError}).
+ */
+export declare function withCommandErrorMapping<T>(operation: () => T | Promise<T>): Promise<T>;
+//# sourceMappingURL=command-errors.d.ts.map

package/lib/types/dsh-adapter/command-errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-errors.d.ts","sourceRoot":"","sources":["../../../src/dsh-adapter/command-errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,+CAA+C;AAC/C,eAAO,MAAM,mBAAmB,iKAOtB,CAAA;AACV,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,mBAAmB,CAAC,CAAC,MAAM,CAAC,CAAA;AAEnE,0DAA0D;AAC1D,MAAM,WAAW,iBAAkB,SAAQ,KAAK;IAC9C,IAAI,EAAE,gBAAgB,CAAA;IACtB,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB;AAID;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CASvD;AAED,yDAAyD;AACzD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAMnF;AAED;;;GAGG;AACH,wBAAsB,uBAAuB,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAM5F"}

package/lib/types/dsh-adapter/command-errors.js

@@ -0,0 +1,63 @@
+/**
+ * commands contract error-code alignment (C-041,
+ * `commands.dsh/v1alpha1#Command`): the official `dsh-commands` runtime
+ * reports a duplicate registration as a plain `Error` whose MESSAGE is the
+ * only signal:
+ *
+ *   `command "<name>" is already registered (…)`
+ *   `command "<name>" is already registered in this scope`
+ *
+ * The v0.15 contract names the code `DUPLICATE_CONTRIBUTION_ID`. This module
+ * maps the message-shaped error onto an `Error` carrying that `.code`, at
+ * the HOST-MEDIATED registration/invocation points (the channel's skill
+ * command registration and registry-command execution).
+ *
+ * Known boundary (C-070, trusted-in-process): a plugin calling
+ * `ctx.commands.register` / `ctx.commands.execute` DIRECTLY bypasses this
+ * mapping — code-level wrapping can only cover the points the host owns.
+ * That is declared platform behavior, not a bug.
+ */
+/** The contract's command error vocabulary. */
+export const COMMAND_ERROR_CODES = [
+    'COMMAND_NOT_FOUND',
+    'DUPLICATE_CONTRIBUTION_ID',
+    'PERMISSION_NOT_GRANTED',
+    'COMMAND_FAILED',
+    'INVOCATION_CANCELLED',
+    'INVOCATION_DEADLINE_EXCEEDED',
+];
+const DUPLICATE_PATTERN = /^command "[^"]+" is already registered/;
+/**
+ * Map a thrown dsh-commands error onto its contract code. A duplicate
+ * registration comes back as a CodedCommandError with
+ * `DUPLICATE_CONTRIBUTION_ID` (original on `.cause`); every other value
+ * passes through unchanged.
+ */
+export function mapCommandError(error) {
+    if (error instanceof Error && DUPLICATE_PATTERN.test(error.message)) {
+        const mapped = new Error(error.message);
+        mapped.name = error.name;
+        mapped.code = 'DUPLICATE_CONTRIBUTION_ID';
+        mapped.cause = error;
+        return mapped;
+    }
+    return error;
+}
+/** True when `error` carries the given contract code. */
+export function hasCommandErrorCode(error, code) {
+    return (error !== null &&
+        typeof error === 'object' &&
+        error.code === code);
+}
+/**
+ * Run `operation` and rethrow any duplicate-registration failure with its
+ * contract code attached (see {@link mapCommandError}).
+ */
+export async function withCommandErrorMapping(operation) {
+    try {
+        return await operation();
+    }
+    catch (error) {
+        throw mapCommandError(error);
+    }
+}

package/lib/types/dsh-adapter/command-trees.d.ts

@@ -9,6 +9,12 @@ export interface TuiCommandTreeProvider {
     /** Children for the full canonical path, including `root` at index zero. */
     children(canonicalPath: readonly string[]): readonly CommandCompletionNode[];
 }
+/** Host-only completion access. Plugins see only their own provider through
+ * the traceable service; the channel uses this facade to merge all providers. */
+export interface TuiCommandTreeHost {
+    children(canonicalPath: readonly string[]): readonly CommandCompletionNode[];
+    descriptions(root: string): LocalizedDescriptions | undefined;
+}
 declare module '@deepseek-ai/cordis' {
     interface Context {
         tuiCommandTrees: TuiCommandTreeRuntime;
@@ -17,11 +23,11 @@ declare module '@deepseek-ai/cordis' {
 export declare const name = "dsh-tui-command-trees";
 /** Small host-only registry; command execution remains owned by dsh-commands. */
 export declare class TuiCommandTreeRuntime extends Service {
-    private readonly providers;
     constructor(ctx: Context);
     register(provider: TuiCommandTreeProvider): () => void;
     children(canonicalPath: readonly string[]): readonly CommandCompletionNode[];
     descriptions(root: string): LocalizedDescriptions | undefined;
 }
+export declare function getHostCommandTrees(runtime: TuiCommandTreeRuntime | undefined): TuiCommandTreeHost | undefined;
 export default TuiCommandTreeRuntime;
 //# sourceMappingURL=command-trees.d.ts.map

package/lib/types/dsh-adapter/command-trees.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"command-trees.d.ts","sourceRoot":"","sources":["../../../src/dsh-adapter/command-trees.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAEhF,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AACtD,OAAO,KAAK,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAA;AAElF,MAAM,WAAW,sBAAsB;IACrC,4EAA4E;IAC5E,IAAI,EAAE,MAAM,CAAA;IACZ,qEAAqE;IACrE,YAAY,CAAC,EAAE,qBAAqB,CAAA;IACpC,4EAA4E;IAC5E,QAAQ,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,qBAAqB,EAAE,CAAA;CAC7E;AAED,OAAO,QAAQ,qBAAqB,CAAC;IACnC,UAAU,OAAO;QACf,eAAe,EAAE,qBAAqB,CAAA;KACvC;CACF;AAED,eAAO,MAAM,IAAI,0BAA0B,CAAA;AAE3C,iFAAiF;AACjF,qBAAa,qBAAsB,SAAQ,OAAO;IAChD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA4C;gBAE1D,GAAG,EAAE,OAAO;IAIxB,QAAQ,CAAC,QAAQ,EAAE,sBAAsB,GAAG,MAAM,IAAI;IAWtD,QAAQ,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,qBAAqB,EAAE;IAa5E,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,qBAAqB,GAAG,SAAS;CAG9D;AAED,eAAe,qBAAqB,CAAA"}
+{"version":3,"file":"command-trees.d.ts","sourceRoot":"","sources":["../../../src/dsh-adapter/command-trees.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAEhF,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AACtD,OAAO,KAAK,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAA;AAGlF,MAAM,WAAW,sBAAsB;IACrC,4EAA4E;IAC5E,IAAI,EAAE,MAAM,CAAA;IACZ,qEAAqE;IACrE,YAAY,CAAC,EAAE,qBAAqB,CAAA;IACpC,4EAA4E;IAC5E,QAAQ,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,qBAAqB,EAAE,CAAA;CAC7E;AAED;iFACiF;AACjF,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,qBAAqB,EAAE,CAAA;IAC5E,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,qBAAqB,GAAG,SAAS,CAAA;CAC9D;AAED,OAAO,QAAQ,qBAAqB,CAAC;IACnC,UAAU,OAAO;QACf,eAAe,EAAE,qBAAqB,CAAA;KACvC;CACF;AAED,eAAO,MAAM,IAAI,0BAA0B,CAAA;AAE3C,iFAAiF;AACjF,qBAAa,qBAAsB,SAAQ,OAAO;gBACpC,GAAG,EAAE,OAAO;IAYxB,QAAQ,CAAC,QAAQ,EAAE,sBAAsB,GAAG,MAAM,IAAI;IAoBtD,QAAQ,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,qBAAqB,EAAE;IAM5E,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,qBAAqB,GAAG,SAAS;CAK9D;AAyCD,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,qBAAqB,GAAG,SAAS,GAAG,kBAAkB,GAAG,SAAS,CAO9G;AAED,eAAe,qBAAqB,CAAA"}

package/lib/types/dsh-adapter/command-trees.js

@@ -1,42 +1,92 @@
 /** Provider-neutral subcommand completion registry for terminal front doors. */
 import { Service } from '@deepseek-ai/cordis';
+import { activationFiber, bindCallerEffect, compositionRoot, concreteService, requirePluginCaller } from './host-access.js';
 export const name = 'dsh-tui-command-trees';
 /** Small host-only registry; command execution remains owned by dsh-commands. */
 export class TuiCommandTreeRuntime extends Service {
-    providers = new Map();
     constructor(ctx) {
         super(ctx, 'tuiCommandTrees');
+        compositionRoot(ctx);
+        const runtime = this;
+        const state = { providers: new Map(), owners: new Map(), host: undefined };
+        state.host = Object.freeze({
+            children: path => childrenFor(runtime, path),
+            descriptions: root => descriptionsFor(runtime, root),
+        });
+        commandTreeStates.set(this, state);
     }
     register(provider) {
+        const caller = requirePluginCaller(this.ctx, 'tuiCommandTrees.register', this);
+        const state = commandTreeStateFor(this);
+        const owner = activationFiber(caller);
+        if (owner === undefined)
+            throw new Error('dsh-tui: tuiCommandTrees.register requires a live activation');
         const root = provider.root.trim().toLowerCase();
         if (!/^[a-z][a-z0-9_-]*$/u.test(root))
             throw new TypeError(`invalid TUI command-tree root: ${provider.root}`);
-        if (this.providers.has(root))
+        if (state.providers.has(root))
             throw new Error(`TUI command-tree root "${root}" is already registered`);
         const normalized = { ...provider, root };
-        this.providers.set(root, normalized);
-        return () => {
-            if (this.providers.get(root) === normalized)
-                this.providers.delete(root);
+        state.providers.set(root, normalized);
+        state.owners.set(root, owner);
+        const dispose = () => {
+            if (state.providers.get(root) !== normalized)
+                return;
+            state.providers.delete(root);
+            state.owners.delete(root);
         };
+        bindCallerEffect(caller, dispose);
+        return dispose;
     }
     children(canonicalPath) {
-        const root = canonicalPath[0]?.toLowerCase();
-        if (root === undefined)
-            return [];
-        const provider = this.providers.get(root);
-        if (provider === undefined)
-            return [];
-        try {
-            return provider.children(canonicalPath);
-        }
-        catch {
-            // Completion is optional UI metadata and must never block execution.
-            return [];
-        }
+        const caller = requirePluginCaller(this.ctx, 'tuiCommandTrees.children', this);
+        const owner = activationFiber(caller);
+        return childrenFor(this, canonicalPath, owner);
     }
     descriptions(root) {
-        return this.providers.get(root.trim().toLowerCase())?.descriptions;
+        const caller = requirePluginCaller(this.ctx, 'tuiCommandTrees.descriptions', this);
+        const owner = activationFiber(caller);
+        return descriptionsFor(this, root, owner);
+    }
+}
+const commandTreeStates = new WeakMap();
+function commandTreeStateFor(runtime) {
+    const state = commandTreeStates.get(concreteService(runtime));
+    if (state === undefined)
+        throw new Error('tuiCommandTrees host state is unavailable');
+    return state;
+}
+function childrenFor(runtime, canonicalPath, owner) {
+    const state = commandTreeStateFor(runtime);
+    const root = canonicalPath[0]?.toLowerCase();
+    if (root === undefined || (owner !== undefined && state.owners.get(root) !== owner))
+        return [];
+    const provider = state.providers.get(root);
+    if (provider === undefined)
+        return [];
+    try {
+        return provider.children(canonicalPath);
+    }
+    catch {
+        // Completion is optional UI metadata and must never block execution.
+        return [];
+    }
+}
+function descriptionsFor(runtime, root, owner) {
+    const state = commandTreeStateFor(runtime);
+    const normalized = root.trim().toLowerCase();
+    if (owner !== undefined && state.owners.get(normalized) !== owner)
+        return undefined;
+    return state.providers.get(normalized)?.descriptions;
+}
+export function getHostCommandTrees(runtime) {
+    if (runtime === undefined)
+        return undefined;
+    try {
+        return commandTreeStateFor(runtime).host;
+    }
+    catch {
+        return undefined;
     }
 }
 export default TuiCommandTreeRuntime;

package/lib/types/dsh-adapter/component-identity.d.ts

@@ -0,0 +1,33 @@
+/** Verified Component identity bound to one Cordis activation owner. */
+import type { Context } from '@deepseek-ai/cordis';
+import type { ComponentManifest, PluginManifest } from '@dsh-std/manifest';
+export type ComponentIdentityErrorCode = 'COMPONENT_NOT_ADMITTED' | 'COMPONENT_ALREADY_ADMITTED';
+export declare class ComponentIdentityError extends Error {
+    readonly code: ComponentIdentityErrorCode;
+    constructor(code: ComponentIdentityErrorCode, message: string);
+}
+export interface VerifiedComponentIdentity {
+    readonly componentId: string;
+    readonly version: string;
+    readonly facet: 'host';
+    readonly activationId: string;
+    readonly manifest: PluginManifest;
+    readonly projection: ComponentManifest;
+}
+/** Activation ids are host-issued opaque values. Keep them bounded and free
+ * of control characters because the same value is written to the effect
+ * ledger and used as a grant principal selector. */
+export declare const ACTIVATION_ID_MAX_LENGTH = 128;
+export declare function bindComponentIdentity(context: Context, manifest: PluginManifest, projection: ComponentManifest, activationId?: string): VerifiedComponentIdentity;
+export declare function componentIdentityOf(context: Context): VerifiedComponentIdentity | undefined;
+export declare function requireComponentIdentity(context: Context): VerifiedComponentIdentity;
+export declare function declaresPermission(identity: VerifiedComponentIdentity, permission: string, actualScope: string): boolean;
+export declare function declaresCommand(identity: VerifiedComponentIdentity, commandId: string): boolean;
+export declare function declaresObserverScope(identity: VerifiedComponentIdentity, actualScope: string): boolean;
+export declare function requiresDecisionEvents(identity: VerifiedComponentIdentity): boolean;
+/** Whether admission negotiated the protocol that backs a mediated runtime
+ * capability.  Permissions alone are not a capability grant: a plugin must
+ * explicitly require the corresponding contract before the host can expose
+ * its calls. */
+export declare function requiresContract(identity: VerifiedComponentIdentity, apiVersion: string, kind: string): boolean;
+//# sourceMappingURL=component-identity.d.ts.map

package/lib/types/dsh-adapter/component-identity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-identity.d.ts","sourceRoot":"","sources":["../../../src/dsh-adapter/component-identity.ts"],"names":[],"mappings":"AAAA,wEAAwE;AAGxE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAI1E,MAAM,MAAM,0BAA0B,GAAG,wBAAwB,GAAG,4BAA4B,CAAA;AAEhG,qBAAa,sBAAuB,SAAQ,KAAK;IACnC,QAAQ,CAAC,IAAI,EAAE,0BAA0B;gBAAhC,IAAI,EAAE,0BAA0B,EAAE,OAAO,EAAE,MAAM;CAIvE;AAED,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAA;IACjC,QAAQ,CAAC,UAAU,EAAE,iBAAiB,CAAA;CACvC;AAED;;oDAEoD;AACpD,eAAO,MAAM,wBAAwB,MAAM,CAAA;AAqB3C,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,cAAc,EACxB,UAAU,EAAE,iBAAiB,EAC7B,YAAY,GAAE,MAAqB,GAClC,yBAAyB,CAyB3B;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,yBAAyB,GAAG,SAAS,CAM3F;AAED,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,OAAO,GAAG,yBAAyB,CASpF;AAED,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,yBAAyB,EACnC,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,GAClB,OAAO,CAQT;AAED,wBAAgB,eAAe,CAAC,QAAQ,EAAE,yBAAyB,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAE/F;AAED,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,yBAAyB,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAUvG;AAED,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,yBAAyB,GAAG,OAAO,CAEnF;AAED;;;gBAGgB;AAChB,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,yBAAyB,EACnC,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,MAAM,GACX,OAAO,CAGT"}

package/lib/types/dsh-adapter/component-identity.js

@@ -0,0 +1,108 @@
+/** Verified Component identity bound to one Cordis activation owner. */
+import { randomUUID } from 'node:crypto';
+import { normalizePermissionScope, scopeCovers } from '../plugin-spec/permission-scope.js';
+import { activationFiber, bindCallerEffect } from './host-access.js';
+export class ComponentIdentityError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'ComponentIdentityError';
+    }
+}
+/** Activation ids are host-issued opaque values. Keep them bounded and free
+ * of control characters because the same value is written to the effect
+ * ledger and used as a grant principal selector. */
+export const ACTIVATION_ID_MAX_LENGTH = 128;
+function validateActivationId(value) {
+    if (typeof value !== 'string' || value.length === 0 || value.length > ACTIVATION_ID_MAX_LENGTH
+        || /[\x00-\x1f\x7f-\x9f]/u.test(value)) {
+        throw new ComponentIdentityError('COMPONENT_NOT_ADMITTED', `activationId must be a non-empty control-free string of at most ${ACTIVATION_ID_MAX_LENGTH} characters`);
+    }
+    return value;
+}
+const identities = new WeakMap();
+function ownerKey(context) {
+    const fiber = activationFiber(context);
+    if (fiber !== undefined)
+        return fiber;
+    throw new ComponentIdentityError('COMPONENT_NOT_ADMITTED', 'a Component activation requires an owning Cordis fiber');
+}
+export function bindComponentIdentity(context, manifest, projection, activationId = randomUUID()) {
+    const key = ownerKey(context);
+    if (identities.has(key)) {
+        throw new ComponentIdentityError('COMPONENT_ALREADY_ADMITTED', 'this activation already has a verified Component identity');
+    }
+    const identity = Object.freeze({
+        componentId: projection.metadata.name,
+        version: projection.metadata.version,
+        facet: 'host',
+        activationId: validateActivationId(activationId),
+        manifest,
+        projection,
+    });
+    identities.set(key, identity);
+    const release = () => {
+        if (identities.get(key) === identity)
+            identities.delete(key);
+    };
+    if (!bindCallerEffect(context, release)) {
+        identities.delete(key);
+        throw new ComponentIdentityError('COMPONENT_NOT_ADMITTED', 'cannot bind Component identity to an inactive activation');
+    }
+    return identity;
+}
+export function componentIdentityOf(context) {
+    try {
+        return identities.get(ownerKey(context));
+    }
+    catch {
+        return undefined;
+    }
+}
+export function requireComponentIdentity(context) {
+    const identity = componentIdentityOf(context);
+    if (identity === undefined) {
+        throw new ComponentIdentityError('COMPONENT_NOT_ADMITTED', 'the calling activation has no verified dsh-plugin.json Component identity');
+    }
+    return identity;
+}
+export function declaresPermission(identity, permission, actualScope) {
+    const actual = normalizePermissionScope(permission, actualScope, identity.componentId);
+    if (actual === undefined)
+        return false;
+    return identity.manifest.permissions.some(request => {
+        if (request.name !== permission)
+            return false;
+        const declared = normalizePermissionScope(permission, request.scope, identity.componentId);
+        return declared !== undefined && scopeCovers(declared, actual);
+    });
+}
+export function declaresCommand(identity, commandId) {
+    return identity.manifest.contributes.commands.some(command => command.id === commandId);
+}
+export function declaresObserverScope(identity, actualScope) {
+    const actual = normalizePermissionScope('messages.observe.read', actualScope, identity.componentId);
+    if (actual === undefined)
+        return false;
+    return identity.manifest.subscriptions.some(subscription => {
+        if (typeof subscription === 'string')
+            return subscription === 'messages.observe';
+        if (subscription.apiVersion !== 'messages.dsh/v1alpha1' || subscription.kind !== 'MessageObserver')
+            return false;
+        if (subscription.scope === undefined)
+            return true;
+        const declared = normalizePermissionScope('messages.observe.read', subscription.scope, identity.componentId);
+        return declared !== undefined && scopeCovers(declared, actual);
+    });
+}
+export function requiresDecisionEvents(identity) {
+    return requiresContract(identity, 'tui.dsh/v1alpha1', 'DecisionEvents');
+}
+/** Whether admission negotiated the protocol that backs a mediated runtime
+ * capability.  Permissions alone are not a capability grant: a plugin must
+ * explicitly require the corresponding contract before the host can expose
+ * its calls. */
+export function requiresContract(identity, apiVersion, kind) {
+    return identity.manifest.requires.contracts.some(requirement => requirement.apiVersion === apiVersion && requirement.kind === kind);
+}

package/lib/types/dsh-adapter/contract.d.ts

@@ -1,4 +1,4 @@
-export declare const UPSTREAM_VALIDATED_VERSION = "0.1.0-rc.6";
+export declare const UPSTREAM_VALIDATED_VERSION = "0.1.0-rc.7";
 /**
  * Framework packages version on their own lines; the contract validates
  * their MAJOR (breaking surface), not the harness rc number.

package/lib/types/dsh-adapter/contract.js

@@ -1,7 +1,7 @@
 /**
  * Upstream compatibility contract.
  *
- * The TUI is validated against one upstream release line (0.1.0-rc.6).
+ * The TUI is validated against one upstream release line (0.1.0-rc.7).
  * Every official package this adapter touches is blessed here; anything
  * else must go through upstream channels or the adapter, never the UI.
  *
@@ -11,7 +11,7 @@
  */
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
-export const UPSTREAM_VALIDATED_VERSION = '0.1.0-rc.6';
+export const UPSTREAM_VALIDATED_VERSION = '0.1.0-rc.7';
 /**
  * Framework packages version on their own lines; the contract validates
  * their MAJOR (breaking surface), not the harness rc number.