@askdkc/dsh-cli 0.11.3

package/lib/types/activityPrefs.js

@@ -0,0 +1,126 @@
+/**
+ * Persisted working-activity indicator preference, mirroring the pi
+ * working-activity extension's `~/.pi/agent/working-activity.json`
+ * (`frames` key). dsh-tui keeps its own copy at
+ * `~/.dsh-tui/working-activity.json` so the `/activity` choice survives
+ * restarts. The file is best-effort: a missing or corrupt file (or an
+ * unknown preset left behind by an older version) just falls back to the
+ * default preset.
+ */
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { isPresetName, normalizeActivityPreset } from './components/activityFrames.js';
+import { featureOn, FEATURE_FLAGS, parseWorkingActivityConfig } from 'dsh-working-activity/config';
+import { DATA_DIR } from './utils/paths.js';
+const PREFS_DIR = DATA_DIR;
+/**
+ * Parse a persisted `{ frames }` value; anything else yields undefined.
+ * @param text - Raw file contents.
+ * @returns The preset name when valid, else undefined.
+ */
+export function parseActivityFrames(text) {
+    try {
+        const parsed = JSON.parse(text);
+        if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed))
+            return undefined;
+        const frames = parsed.frames;
+        return typeof frames === 'string' && isPresetName(frames) ? normalizeActivityPreset(frames) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * The persisted indicator preset name, or undefined when unset or invalid.
+ * @param dir - Prefs directory (injectable for tests).
+ * @returns The persisted preset name, if any.
+ */
+export function readActivityFrames(dir = PREFS_DIR) {
+    try {
+        return parseActivityFrames(readFileSync(join(dir, 'working-activity.json'), 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Read the full pi-style working-activity config (frames / mode / features /
+ * customPhrases / customActions / narrate / thresholds) from the same JSON
+ * file the `/activity` command writes, parsed by the wa package. Best-effort:
+ * a missing or corrupt file yields undefined (callers use their defaults).
+ * @param dir - Prefs directory (injectable for tests).
+ * @returns The parsed config, or undefined when unreadable.
+ */
+export function readActivityConfig(dir = PREFS_DIR) {
+    try {
+        return parseWorkingActivityConfig(readFileSync(join(dir, 'working-activity.json'), 'utf8')).config;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Fold the parsed user file into the mounted working-activity plugin config.
+ *
+ * The line's semantics moved into the plugin, but the file this app's own UI
+ * writes (`/activity`, the settings panel) is still where a user's feature
+ * switches live — without this fold they were parsed and silently dropped.
+ * Precedence keeps the old contract: an explicit row value wins over the
+ * file, the file fills everything the row leaves at its schema default. The
+ * flags come through `featureOn`, so the file's `mode: minimal` turns them
+ * off exactly as it did when the deleted channel sidecar built its tracker.
+ * (The sidecar also hardcoded `detailLimit: 40`, which is the plugin's own
+ * schema default — nothing to fold.)
+ *
+ * The plugin schema materializes its defaults before `apply` sees the config,
+ * so "equal to the default" is the honest reading of "the row did not set
+ * this key"; a row value explicitly set to the default is indistinguishable
+ * from an unset one and the file wins there. None of these keys are set by
+ * the shipped rows.
+ * @param config - Schema-resolved row config for the mounted plugin.
+ * @param file - Parsed user preferences (undefined when unreadable/absent).
+ * @returns the config to mount the plugin with.
+ */
+export function mergeActivityPreferences(config, file) {
+    if (file === undefined)
+        return config;
+    // Every flag the PLUGIN honours (its own FEATURE_FLAGS list), not a local
+    // copy: when the plugin grows or trims switches, the file folds through
+    // without this seam growing a stale mirror. `phrases` rides the top-level
+    // switch below instead.
+    const fileFeatures = Object.fromEntries(FEATURE_FLAGS.filter(name => name !== 'phrases').map(name => [name, featureOn(file, name)]));
+    return {
+        ...config,
+        // `phrases: false` in the row is the one spelling that cannot mean
+        // "unset" (the default is true), so it is the only one that overrides.
+        phrases: config.phrases === false ? false : featureOn(file, 'phrases'),
+        // Per flag: a row entry wins (see the schema-default note above).
+        features: { ...fileFeatures, ...config.features },
+        customPhrases: config.customPhrases !== undefined && config.customPhrases.length > 0
+            ? config.customPhrases
+            : [...(file.customPhrases ?? [])],
+        customActions: config.customActions !== undefined && Object.keys(config.customActions).length > 0
+            ? config.customActions
+            : Object.fromEntries(Object.entries(file.customActions ?? {}).map(([name, phrases]) => [name, [...phrases]])),
+        showTokPerSec: config.showTokPerSec === true ? true : file.showTokPerSec ?? false,
+        workRemindAt: config.workRemindAt !== undefined && config.workRemindAt !== 0
+            ? config.workRemindAt
+            : file.workRemindAt ?? 0,
+    };
+}
+/**
+ * Persist the chosen indicator preset (best effort).
+ * @param name - Preset name to persist.
+ * @param dir - Prefs directory (injectable for tests).
+ * @returns True when the file was written, false on failure.
+ */
+export function writeActivityFrames(name, dir = PREFS_DIR) {
+    try {
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(join(dir, 'working-activity.json'), JSON.stringify({ frames: normalizeActivityPreset(name) }, null, 2));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/lib/types/adapter/channel/actions.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Channel actions module (P4 channel split).
+ *
+ * This is the action half of the live Channel: a thin adapter over the
+ * public Channel mutation methods. The Kernel HostFacade wraps these methods
+ * with the unified shadow-policy enforcement before any caller can invoke
+ * them, so this module never performs its own shadow check.
+ *
+ * The internal `CHANNEL_SPLIT_TOKEN` is required to prevent arbitrary TUI
+ * code from importing this split builder directly and bypassing the
+ * HostFacade shadow gate.
+ */
+import type { Channel } from '../../dsh-adapter/channel.js';
+import type { HostChannelActionsPort } from '../ports/channel.js';
+/** Build the host-internal action surface over one live Channel. */
+export declare function createChannelActions(channel: Channel, token: symbol): HostChannelActionsPort;
+//# sourceMappingURL=actions.d.ts.map

package/lib/types/adapter/channel/actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../../../src/adapter/channel/actions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,8BAA8B,CAAA;AAC3D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAA;AAGjE,oEAAoE;AACpE,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,MAAM,GACZ,sBAAsB,CAaxB"}

package/lib/types/adapter/channel/actions.js

@@ -0,0 +1,28 @@
+/**
+ * Channel actions module (P4 channel split).
+ *
+ * This is the action half of the live Channel: a thin adapter over the
+ * public Channel mutation methods. The Kernel HostFacade wraps these methods
+ * with the unified shadow-policy enforcement before any caller can invoke
+ * them, so this module never performs its own shadow check.
+ *
+ * The internal `CHANNEL_SPLIT_TOKEN` is required to prevent arbitrary TUI
+ * code from importing this split builder directly and bypassing the
+ * HostFacade shadow gate.
+ */
+import { CHANNEL_SPLIT_TOKEN } from './internal-token.js';
+/** Build the host-internal action surface over one live Channel. */
+export function createChannelActions(channel, token) {
+    if (token !== CHANNEL_SPLIT_TOKEN) {
+        throw new Error('dsh-tui: Channel split actions require the internal host token');
+    }
+    return Object.freeze({
+        submit: text => channel.submit(text),
+        steer: text => channel.steer(text),
+        cancel: () => channel.cancel(),
+        interruptAndDeliver: texts => channel.interruptAndDeliver(texts),
+        clear: () => channel.clear(),
+        loadOlder: () => channel.loadOlder(),
+        notify: (text, options) => channel.notify(text, options),
+    });
+}

package/lib/types/adapter/channel/consumer.d.ts

@@ -0,0 +1,34 @@
+/**
+ * TUI Channel Consumer (P5).
+ *
+ * A Channel Consumer owns the visible terminal side of
+ * `tui.dsh/v1alpha1#Channel`. This module is the conformance-facing client:
+ * it opens a provider, subscribes to snapshots, enforces monotonic versions
+ * and full-snapshot continuity, invokes JSON-value methods, and closes the
+ * channel. It never interprets provider business methods itself.
+ *
+ * Continuity violations are fail-closed by default: the consumer throws
+ * instead of silently retaining a discontinuous snapshot.
+ */
+import type { TuiChannelInvokeOutput, TuiChannelSnapshot } from '../spec/index.js';
+import type { ChannelProvider, ChannelProviderOpenInput } from './provider.js';
+export interface ChannelConsumerOptions {
+    /** When true (default), a continuity violation throws immediately and the
+     * discontinuous snapshot is not retained. */
+    readonly failClosed?: boolean;
+}
+export interface ChannelConsumer {
+    open(input: ChannelProviderOpenInput): Promise<TuiChannelSnapshot>;
+    subscribe(channelId: string, afterVersion: number, listener: (snapshot: TuiChannelSnapshot) => void): Promise<() => void>;
+    invoke(channelId: string, method: string, args: readonly unknown[]): Promise<TuiChannelInvokeOutput>;
+    close(channelId: string): Promise<{
+        readonly closed: true;
+    }>;
+    lastSnapshot(): TuiChannelSnapshot | undefined;
+    /** Version continuity failures observed while consuming (gap/backwards/
+     * wire-revision change). A conformant replay must keep this empty. */
+    continuityErrors(): readonly string[];
+}
+/** Wrap a Channel Provider with the consumer-side protocol envelope checks. */
+export declare function createChannelConsumer(provider: ChannelProvider, options?: ChannelConsumerOptions): ChannelConsumer;
+//# sourceMappingURL=consumer.d.ts.map

package/lib/types/adapter/channel/consumer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consumer.d.ts","sourceRoot":"","sources":["../../../../src/adapter/channel/consumer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,KAAK,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAClF,OAAO,KAAK,EAAE,eAAe,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAA;AAE9E,MAAM,WAAW,sBAAsB;IACrC;iDAC6C;IAC7C,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAA;CAC9B;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,CAAC,KAAK,EAAE,wBAAwB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAA;IAClE,SAAS,CACP,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,CAAC,QAAQ,EAAE,kBAAkB,KAAK,IAAI,GAC/C,OAAO,CAAC,MAAM,IAAI,CAAC,CAAA;IACtB,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,OAAO,EAAE,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAA;IACpG,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAA;KAAE,CAAC,CAAA;IAC5D,YAAY,IAAI,kBAAkB,GAAG,SAAS,CAAA;IAC9C;0EACsE;IACtE,gBAAgB,IAAI,SAAS,MAAM,EAAE,CAAA;CACtC;AAED,+EAA+E;AAC/E,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,eAAe,EACzB,OAAO,GAAE,sBAA2B,GACnC,eAAe,CAqEjB"}

package/lib/types/adapter/channel/consumer.js

@@ -0,0 +1,87 @@
+/**
+ * TUI Channel Consumer (P5).
+ *
+ * A Channel Consumer owns the visible terminal side of
+ * `tui.dsh/v1alpha1#Channel`. This module is the conformance-facing client:
+ * it opens a provider, subscribes to snapshots, enforces monotonic versions
+ * and full-snapshot continuity, invokes JSON-value methods, and closes the
+ * channel. It never interprets provider business methods itself.
+ *
+ * Continuity violations are fail-closed by default: the consumer throws
+ * instead of silently retaining a discontinuous snapshot.
+ */
+import { validateTuiChannelOutput, validateTuiChannelSnapshot } from '../spec/index.js';
+/** Wrap a Channel Provider with the consumer-side protocol envelope checks. */
+export function createChannelConsumer(provider, options = {}) {
+    const failClosed = options.failClosed !== false;
+    let last;
+    const continuityErrors = [];
+    function accept(snapshotValue, allowEqual = false) {
+        const snapshot = validateTuiChannelSnapshot(snapshotValue);
+        const errorCountBefore = continuityErrors.length;
+        if (last !== undefined) {
+            if (snapshot.channelId !== last.channelId) {
+                continuityErrors.push(`channel id changed: ${last.channelId} -> ${snapshot.channelId}`);
+            }
+            else if (snapshot.wireRevision !== last.wireRevision) {
+                continuityErrors.push(`wire revision changed: ${last.wireRevision} -> ${snapshot.wireRevision}`);
+            }
+            else if (snapshot.version < last.version) {
+                continuityErrors.push(`version went backwards: ${last.version} -> ${snapshot.version}`);
+            }
+            else if (snapshot.version === last.version && !allowEqual) {
+                continuityErrors.push(`version did not advance: ${last.version} -> ${snapshot.version}`);
+            }
+            else if (snapshot.version > last.version && snapshot.version !== last.version + 1) {
+                continuityErrors.push(`version gap: expected ${last.version + 1}, got ${snapshot.version}`);
+            }
+        }
+        const hasNewError = continuityErrors.length > errorCountBefore;
+        if (hasNewError && failClosed) {
+            throw new Error(`dsh-tui: Channel continuity violation: ${continuityErrors[continuityErrors.length - 1]}`);
+        }
+        // When not fail-closed, keep advancing `last` to the snapshot that was
+        // actually observed so later continuity messages describe the real
+        // sequence rather than a stale pre-violation baseline.
+        if (last === undefined || snapshot.version >= last.version) {
+            last = snapshot;
+        }
+        return snapshot;
+    }
+    return Object.freeze({
+        async open(input) {
+            const snapshot = await provider.open(input);
+            last = undefined;
+            continuityErrors.length = 0;
+            return accept(snapshot);
+        },
+        async subscribe(channelId, afterVersion, listener) {
+            let firstReplay = true;
+            return provider.subscribe(channelId, afterVersion, value => {
+                // Provider semantics are "not earlier than afterVersion": an equal
+                // version echo after `open()` is the first snapshot of a subscription
+                // and must be accepted, while later equal-version duplicates still
+                // violate continuity.
+                listener(accept(value, firstReplay));
+                firstReplay = false;
+            });
+        },
+        async invoke(channelId, method, args) {
+            const output = await provider.invoke(channelId, method, args);
+            const validated = validateTuiChannelOutput('invoke', output);
+            if (validated.snapshot !== undefined)
+                accept(validated.snapshot, true);
+            return validated;
+        },
+        async close(channelId) {
+            const output = await provider.close(channelId);
+            return validateTuiChannelOutput('close', output);
+        },
+        lastSnapshot() {
+            return last;
+        },
+        continuityErrors() {
+            return Object.freeze([...continuityErrors]);
+        },
+    });
+}

package/lib/types/adapter/channel/features.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Shared Channel Host-Port effect-capability map and derived feature list.
+ *
+ * This is the single source that `HostFacade` shadow policy, the Channel
+ * upstream driver and the Kernel channel slice all consume. Keeping it here
+ * prevents the slice declaration / driver feature list from drifting from the
+ * methods actually exposed by `HostChannelPort`.
+ */
+export declare const CHANNEL_PORT_METHOD_CAPABILITIES: Readonly<Record<string, Readonly<Record<string, string>>>>;
+export declare const CHANNEL_FEATURES: readonly string[];
+export declare const CHANNEL_STANDARD_DECLARATIONS: readonly string[];
+//# sourceMappingURL=features.d.ts.map

package/lib/types/adapter/channel/features.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"features.d.ts","sourceRoot":"","sources":["../../../../src/adapter/channel/features.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CA6BtG,CAAA;AAEF,eAAO,MAAM,gBAAgB,EAAE,SAAS,MAAM,EAK7C,CAAA;AAED,eAAO,MAAM,6BAA6B,EAAE,SAAS,MAAM,EAAqB,CAAA"}

package/lib/types/adapter/channel/features.js

@@ -0,0 +1,41 @@
+/**
+ * Shared Channel Host-Port effect-capability map and derived feature list.
+ *
+ * This is the single source that `HostFacade` shadow policy, the Channel
+ * upstream driver and the Kernel channel slice all consume. Keeping it here
+ * prevents the slice declaration / driver feature list from drifting from the
+ * methods actually exposed by `HostChannelPort`.
+ */
+export const CHANNEL_PORT_METHOD_CAPABILITIES = Object.freeze({
+    projection: Object.freeze({
+        ui: 'host.channel.projection.ui',
+        snapshot: 'host.channel.projection.snapshot',
+        subscribe: 'host.channel.projection.subscribe',
+    }),
+    actions: Object.freeze({
+        submit: 'host.channel.actions.submit',
+        steer: 'host.channel.actions.steer',
+        cancel: 'host.channel.actions.cancel',
+        interruptAndDeliver: 'host.channel.actions.interruptAndDeliver',
+        clear: 'host.channel.actions.clear',
+        loadOlder: 'host.channel.actions.loadOlder',
+        notify: 'host.channel.actions.notify',
+    }),
+    state: Object.freeze({
+        snapshot: 'host.channel.state.snapshot',
+    }),
+    plugins: Object.freeze({
+        runExternalCommand: 'host.channel.plugins.run-external-command',
+        openPluginScene: 'host.channel.plugins.open-scene',
+        closePluginScene: 'host.channel.plugins.close-scene',
+        settingsSections: 'host.channel.plugins.settings-sections',
+        subscribeSettingsSections: 'host.channel.plugins.subscribe-settings-sections',
+    }),
+    transcript: Object.freeze({
+        rows: 'host.channel.transcript.rows',
+        traceEvents: 'host.channel.transcript.trace-events',
+    }),
+});
+export const CHANNEL_FEATURES = Object.freeze([...new Set(Object.values(CHANNEL_PORT_METHOD_CAPABILITIES)
+        .flatMap(subPort => Object.values(subPort)))]);
+export const CHANNEL_STANDARD_DECLARATIONS = CHANNEL_FEATURES;

package/lib/types/adapter/channel/host-registry.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Host-internal Channel registry for the adapter Kernel.
+ *
+ * The live `Channel` is created by the TUI plugin row after the plugin-host
+ * Kernel may already have been constructed/mounted. Rather than trying to
+ * reorder service mounting, the TUI stores the live Channel under its
+ * composition root in a WeakMap; the Channel driver resolves it lazily when
+ * a Port method is actually called. This keeps the Kernel's composition
+ * independent of the TUI render lifecycle.
+ *
+ * Every entry is normalized to the Cordis composition root before it is used
+ * as a WeakMap key: a child/plugin context passed by a caller must never
+ * create a registry entry that the Kernel (which queries through the root)
+ * cannot resolve.
+ */
+export type TuiChannelRegistration = Readonly<{
+    channel: unknown;
+    token: symbol;
+}>;
+/** Register the live Channel for a composition root.
+ * @returns A token-safe disposer. Registrations have identity independent of
+ * their Channel object: A → B → A and repeated registration of the same
+ * Channel cannot let an older disposer erase or revive the current entry.
+ */
+export declare function registerTuiChannel(ctx: unknown, channel: unknown): () => boolean;
+/** Resolve the live Channel for a composition root. */
+export declare function getRegisteredTuiChannel(ctx: unknown): unknown | undefined;
+/** Return the current registration identity, not only its Channel object. */
+export declare function getTuiChannelRegistration(ctx: unknown): TuiChannelRegistration | undefined;
+/**
+ * Subscribe to live-Channel registration for one composition root.
+ *
+ * The Kernel uses this to re-run a refresh/mount when the TUI plugin creates
+ * and registers its Channel after the plugin-host row has already started.
+ * Returns a disposer; listeners are keyed by normalized composition root.
+ */
+export declare function onTuiChannelRegistered(ctx: unknown, listener: (channel: unknown) => void): () => void;
+/** Subscribe to registration identities for consumers that own capabilities. */
+export declare function onTuiChannelRegistration(ctx: unknown, listener: (registration: TuiChannelRegistration | undefined) => void): () => void;
+//# sourceMappingURL=host-registry.d.ts.map

package/lib/types/adapter/channel/host-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"host-registry.d.ts","sourceRoot":"","sources":["../../../../src/adapter/channel/host-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,MAAM,MAAM,sBAAsB,GAAG,QAAQ,CAAC;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,CAAA;AAgBlF;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,OAAO,CAehF;AAyBD,uDAAuD;AACvD,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,GAAG,SAAS,CAEzE;AAED,6EAA6E;AAC7E,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,OAAO,GAAG,sBAAsB,GAAG,SAAS,CAG1F;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,OAAO,EACZ,QAAQ,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,GACnC,MAAM,IAAI,CAUZ;AAED,gFAAgF;AAChF,wBAAgB,wBAAwB,CACtC,GAAG,EAAE,OAAO,EACZ,QAAQ,EAAE,CAAC,YAAY,EAAE,sBAAsB,GAAG,SAAS,KAAK,IAAI,GACnE,MAAM,IAAI,CAUZ"}

package/lib/types/adapter/channel/host-registry.js

@@ -0,0 +1,120 @@
+/**
+ * Host-internal Channel registry for the adapter Kernel.
+ *
+ * The live `Channel` is created by the TUI plugin row after the plugin-host
+ * Kernel may already have been constructed/mounted. Rather than trying to
+ * reorder service mounting, the TUI stores the live Channel under its
+ * composition root in a WeakMap; the Channel driver resolves it lazily when
+ * a Port method is actually called. This keeps the Kernel's composition
+ * independent of the TUI render lifecycle.
+ *
+ * Every entry is normalized to the Cordis composition root before it is used
+ * as a WeakMap key: a child/plugin context passed by a caller must never
+ * create a registry entry that the Kernel (which queries through the root)
+ * cannot resolve.
+ */
+import { compositionRoot } from '../../dsh-adapter/host-access.js';
+const channels = new WeakMap();
+const channelListeners = new WeakMap();
+const registrationListeners = new WeakMap();
+function rootKey(ctx) {
+    if (ctx === null || (typeof ctx !== 'object' && typeof ctx !== 'function'))
+        return undefined;
+    try {
+        return compositionRoot(ctx);
+    }
+    catch {
+        // Non-Cordis test values / minimal embedders are their own root.
+        return ctx;
+    }
+}
+/** Register the live Channel for a composition root.
+ * @returns A token-safe disposer. Registrations have identity independent of
+ * their Channel object: A → B → A and repeated registration of the same
+ * Channel cannot let an older disposer erase or revive the current entry.
+ */
+export function registerTuiChannel(ctx, channel) {
+    const key = rootKey(ctx);
+    if (key === undefined)
+        return () => false;
+    const registration = Object.freeze({ channel, token: Symbol('tui-channel-registration') });
+    channels.set(key, registration);
+    notifyChannelListeners(key, registration);
+    let disposed = false;
+    return () => {
+        if (disposed)
+            return false;
+        disposed = true;
+        if (channels.get(key)?.token !== registration.token)
+            return false;
+        channels.delete(key);
+        notifyChannelListeners(key, undefined);
+        return true;
+    };
+}
+function notifyChannelListeners(key, registration) {
+    const listeners = channelListeners.get(key);
+    if (listeners !== undefined) {
+        for (const listener of [...listeners]) {
+            try {
+                listener(registration?.channel);
+            }
+            catch {
+                // A registration notification is advisory; one faulty listener must not
+                // prevent the Channel from being stored.
+            }
+        }
+    }
+    const identityListeners = registrationListeners.get(key);
+    if (identityListeners === undefined)
+        return;
+    for (const listener of [...identityListeners]) {
+        try {
+            listener(registration);
+        }
+        catch {
+            // Identity notifications have the same advisory, fan-out semantics.
+        }
+    }
+}
+/** Resolve the live Channel for a composition root. */
+export function getRegisteredTuiChannel(ctx) {
+    return getTuiChannelRegistration(ctx)?.channel;
+}
+/** Return the current registration identity, not only its Channel object. */
+export function getTuiChannelRegistration(ctx) {
+    const key = rootKey(ctx);
+    return key === undefined ? undefined : channels.get(key);
+}
+/**
+ * Subscribe to live-Channel registration for one composition root.
+ *
+ * The Kernel uses this to re-run a refresh/mount when the TUI plugin creates
+ * and registers its Channel after the plugin-host row has already started.
+ * Returns a disposer; listeners are keyed by normalized composition root.
+ */
+export function onTuiChannelRegistered(ctx, listener) {
+    const key = rootKey(ctx);
+    if (key === undefined)
+        return () => undefined;
+    let listeners = channelListeners.get(key);
+    if (listeners === undefined) {
+        listeners = new Set();
+        channelListeners.set(key, listeners);
+    }
+    listeners.add(listener);
+    return () => { listeners?.delete(listener); };
+}
+/** Subscribe to registration identities for consumers that own capabilities. */
+export function onTuiChannelRegistration(ctx, listener) {
+    const key = rootKey(ctx);
+    if (key === undefined)
+        return () => undefined;
+    let listeners = registrationListeners.get(key);
+    if (listeners === undefined) {
+        listeners = new Set();
+        registrationListeners.set(key, listeners);
+    }
+    listeners.add(listener);
+    return () => { listeners?.delete(listener); };
+}

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

@@ -0,0 +1,22 @@
+/**
+ * Channel split surface (P4).
+ *
+ * The live legacy `src/dsh-adapter/channel.ts` remains the implementation
+ * source, but the adapter-facing Channel behavior is decomposed here into
+ * five small modules:
+ *   projection / actions / state / plugins / transcript.
+ *
+ * This module re-exports the host-internal builder functions and the
+ * composition-root registry.
+ */
+export { projectChannelRows, projectChannelSnapshot } from './projection.js';
+export { projectChannelState } from './state.js';
+export { createChannelActions } from './actions.js';
+export { createChannelPlugins } from './plugins.js';
+export { createChannelTranscript } from './transcript.js';
+export { registerTuiChannel, onTuiChannelRegistered } from './host-registry.js';
+export { CHANNEL_FEATURES, CHANNEL_PORT_METHOD_CAPABILITIES, CHANNEL_STANDARD_DECLARATIONS } from './features.js';
+export { TUI_CHANNEL_WIRE_REVISION, type TuiChannelSnapshot } from '../spec/index.js';
+export { createReplayChannelProvider, createReplayChannelProviderFromSnapshot, REPLAY_CHANNEL_WIRE_REVISION, type ChannelProvider, type ChannelProviderOpenInput, type ReplayChannelSnapshotSource, } from './provider.js';
+export { createChannelConsumer, type ChannelConsumer, } from './consumer.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/adapter/channel/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAA;AAC5E,OAAO,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAA;AAChD,OAAO,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAA;AACnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAA;AACnD,OAAO,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAA;AACzD,OAAO,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAA;AAC/E,OAAO,EAAE,gBAAgB,EAAE,gCAAgC,EAAE,6BAA6B,EAAE,MAAM,eAAe,CAAA;AACjH,OAAO,EAAE,yBAAyB,EAAE,KAAK,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AACrF,OAAO,EACL,2BAA2B,EAC3B,uCAAuC,EACvC,4BAA4B,EAC5B,KAAK,eAAe,EACpB,KAAK,wBAAwB,EAC7B,KAAK,2BAA2B,GACjC,MAAM,eAAe,CAAA;AACtB,OAAO,EACL,qBAAqB,EACrB,KAAK,eAAe,GACrB,MAAM,eAAe,CAAA"}

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

@@ -0,0 +1,21 @@
+/**
+ * Channel split surface (P4).
+ *
+ * The live legacy `src/dsh-adapter/channel.ts` remains the implementation
+ * source, but the adapter-facing Channel behavior is decomposed here into
+ * five small modules:
+ *   projection / actions / state / plugins / transcript.
+ *
+ * This module re-exports the host-internal builder functions and the
+ * composition-root registry.
+ */
+export { projectChannelRows, projectChannelSnapshot } from './projection.js';
+export { projectChannelState } from './state.js';
+export { createChannelActions } from './actions.js';
+export { createChannelPlugins } from './plugins.js';
+export { createChannelTranscript } from './transcript.js';
+export { registerTuiChannel, onTuiChannelRegistered } from './host-registry.js';
+export { CHANNEL_FEATURES, CHANNEL_PORT_METHOD_CAPABILITIES, CHANNEL_STANDARD_DECLARATIONS } from './features.js';
+export { TUI_CHANNEL_WIRE_REVISION } from '../spec/index.js';
+export { createReplayChannelProvider, createReplayChannelProviderFromSnapshot, REPLAY_CHANNEL_WIRE_REVISION, } from './provider.js';
+export { createChannelConsumer, } from './consumer.js';

package/lib/types/adapter/channel/internal-token.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Internal capability token for the split Channel builder modules.
+ *
+ * The split `actions` / `plugins` / `transcript` builders are host-internal
+ * and must be reached through the Kernel-driven Channel driver / HostFacade
+ * shadow gate, not imported and invoked directly from arbitrary TUI code.
+ * This token is intentionally not re-exported through `src/adapter/channel`
+ * or `src/adapter/index`; only the upstream driver and the split modules
+ * themselves import it.
+ */
+export declare const CHANNEL_SPLIT_TOKEN: unique symbol;
+//# sourceMappingURL=internal-token.d.ts.map

package/lib/types/adapter/channel/internal-token.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal-token.d.ts","sourceRoot":"","sources":["../../../../src/adapter/channel/internal-token.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,eAAO,MAAM,mBAAmB,EAAE,OAAO,MAA8C,CAAA"}

package/lib/types/adapter/channel/internal-token.js

@@ -0,0 +1,11 @@
+/**
+ * Internal capability token for the split Channel builder modules.
+ *
+ * The split `actions` / `plugins` / `transcript` builders are host-internal
+ * and must be reached through the Kernel-driven Channel driver / HostFacade
+ * shadow gate, not imported and invoked directly from arbitrary TUI code.
+ * This token is intentionally not re-exported through `src/adapter/channel`
+ * or `src/adapter/index`; only the upstream driver and the split modules
+ * themselves import it.
+ */
+export const CHANNEL_SPLIT_TOKEN = Symbol('dsh-tui.channel-split-token');

package/lib/types/adapter/channel/plugins.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Channel plugins module (P4 channel split).
+ *
+ * Projects the plugin-visible seams that hang off the live Channel into a
+ * small host-internal Port: external plugin commands, plugin scenes and
+ * settings sections. It never exposes plugin registration or permission
+ * evaluation; those stay in Standard/Kernel.
+ *
+ * The internal `CHANNEL_SPLIT_TOKEN` is required so this split builder cannot
+ * be invoked outside the Kernel/driver path and bypass the HostFacade shadow
+ * gate.
+ */
+import type { Channel } from '../../dsh-adapter/channel.js';
+import type { HostChannelPluginsPort } from '../ports/channel.js';
+/** Build the host-internal plugin-facing surface over one live Channel. */
+export declare function createChannelPlugins(channel: Channel, token: symbol): HostChannelPluginsPort;
+//# sourceMappingURL=plugins.d.ts.map

package/lib/types/adapter/channel/plugins.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugins.d.ts","sourceRoot":"","sources":["../../../../src/adapter/channel/plugins.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,8BAA8B,CAAA;AAE3D,OAAO,KAAK,EACV,sBAAsB,EAEvB,MAAM,qBAAqB,CAAA;AAuB5B,2EAA2E;AAC3E,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,sBAAsB,CAa5F"}