@askdkc/dsh-cli 0.11.3

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

@@ -0,0 +1,47 @@
+/**
+ * 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 { CHANNEL_SPLIT_TOKEN } from './internal-token.js';
+function projectSettingsSection(section) {
+    return Object.freeze({
+        ns: section.ns,
+        title: section.title,
+        ...(section.groups === undefined ? {} : {
+            groups: Object.freeze(section.groups.map(group => Object.freeze({ id: group.id, title: group.title }))),
+        }),
+        fields: Object.freeze(section.fields.map(field => Object.freeze({
+            path: Object.freeze([...field.path]),
+            label: field.label,
+            kind: field.kind,
+            ...(field.hint === undefined ? {} : { hint: field.hint }),
+            ...(field.group === undefined ? {} : { group: field.group }),
+            ...(field.options === undefined ? {} : { options: Object.freeze(field.options.map(option => Object.freeze({ ...option }))) }),
+            ...(field.placeholder === undefined ? {} : { placeholder: field.placeholder }),
+            ...(field.secret === undefined ? {} : { secret: Object.freeze({ ref: field.secret.ref }) }),
+        }))),
+    });
+}
+/** Build the host-internal plugin-facing surface over one live Channel. */
+export function createChannelPlugins(channel, token) {
+    if (token !== CHANNEL_SPLIT_TOKEN) {
+        throw new Error('dsh-tui: Channel split plugins require the internal host token');
+    }
+    return Object.freeze({
+        async runExternalCommand(name, rawInput) {
+            return channel.runExternalCommand(name, rawInput);
+        },
+        openPluginScene: id => channel.openPluginScene(id),
+        closePluginScene: () => channel.closePluginScene(),
+        settingsSections: () => Object.freeze(channel.settingsSections().map(projectSettingsSection)),
+        subscribeSettingsSections: listener => channel.subscribeSettingsSections(listener),
+    });
+}

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

@@ -0,0 +1,15 @@
+/**
+ * Channel projection module (P4 channel split).
+ *
+ * This is the pure projection half of the live Channel: it maps the legacy
+ * Channel/ChannelState surface into a serializable host-internal projection
+ * used by the Kernel Channel Port. It deliberately strips functions, handles,
+ * secrets and renderer-only objects from the snapshot.
+ */
+import type { Channel, ChatRow } from '../../dsh-adapter/channel.js';
+import type { HostChannelProjectionSnapshot, HostChannelRowProjection } from '../ports/channel.js';
+/** Project the current channel transcript rows into a JSON-safe view. */
+export declare function projectChannelRows(rows: readonly ChatRow[]): readonly HostChannelRowProjection[];
+/** Project the live Channel into the serializable renderer projection. */
+export declare function projectChannelSnapshot(channel: Channel): HostChannelProjectionSnapshot;
+//# sourceMappingURL=projection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"projection.d.ts","sourceRoot":"","sources":["../../../../src/adapter/channel/projection.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAW,MAAM,8BAA8B,CAAA;AAC7E,OAAO,KAAK,EACV,6BAA6B,EAC7B,wBAAwB,EAEzB,MAAM,qBAAqB,CAAA;AA4B5B,yEAAyE;AACzE,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,SAAS,OAAO,EAAE,GAAG,SAAS,wBAAwB,EAAE,CAEhG;AAED,0EAA0E;AAC1E,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,6BAA6B,CAqBtF"}

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

@@ -0,0 +1,59 @@
+/**
+ * Channel projection module (P4 channel split).
+ *
+ * This is the pure projection half of the live Channel: it maps the legacy
+ * Channel/ChannelState surface into a serializable host-internal projection
+ * used by the Kernel Channel Port. It deliberately strips functions, handles,
+ * secrets and renderer-only objects from the snapshot.
+ */
+function projectTool(row) {
+    return Object.freeze({
+        callId: row.callId,
+        name: row.name,
+        status: row.status,
+        argsPreview: row.argsText,
+        ...(row.resultText === undefined ? {} : { resultPreview: row.resultText }),
+        ...(row.errorText === undefined ? {} : { errorText: row.errorText }),
+        startedAt: row.startedAt,
+        ...(row.durationMs === undefined ? {} : { durationMs: row.durationMs }),
+    });
+}
+function projectRow(row) {
+    return Object.freeze({
+        id: row.id,
+        kind: row.kind,
+        text: row.text,
+        ...(row.label === undefined ? {} : { label: row.label }),
+        ...(row.streaming === undefined ? {} : { streaming: row.streaming }),
+        ...(row.time === undefined ? {} : { time: row.time }),
+        ...(row.seq === undefined ? {} : { seq: row.seq }),
+        ...(row.tool === undefined ? {} : { tool: projectTool(row.tool) }),
+    });
+}
+/** Project the current channel transcript rows into a JSON-safe view. */
+export function projectChannelRows(rows) {
+    return Object.freeze(rows.map(projectRow));
+}
+/** Project the live Channel into the serializable renderer projection. */
+export function projectChannelSnapshot(channel) {
+    return Object.freeze({
+        version: channel.version,
+        rows: projectChannelRows(channel.rows),
+        status: channel.status,
+        sessionTitle: channel.sessionTitle,
+        agentId: channel.agentId,
+        model: channel.model,
+        provider: channel.provider,
+        cwd: channel.cwd,
+        displayCwd: channel.displayCwd,
+        working: channel.working,
+        activeToolCount: channel.activeToolCount,
+        lastUserText: channel.lastUserText,
+        commandList: Object.freeze(channel.commandList.map(command => Object.freeze({
+            name: command.name,
+            ...(command.description === undefined ? {} : { description: command.description }),
+        }))),
+        contextSegments: Object.freeze({ ...channel.contextSegments }),
+        subagents: Object.freeze([...channel.subagents]),
+    });
+}

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

@@ -0,0 +1,52 @@
+/**
+ * TUI Channel Provider (P5).
+ *
+ * A Channel Provider owns the Agent/Session/Workspace side of
+ * `tui.dsh/v1alpha1#Channel`. This module implements an in-memory replay
+ * provider used by the replay harness: it does not attach to a real DSH
+ * service, but it follows the protocol envelope (open/subscribe/invoke/
+ * close), validates inputs/outputs, preserves monotonic channel versions,
+ * and can be driven from a real recorded DSH session snapshot/transcript.
+ *
+ * The replay provider is intentionally protocol-envelope focused:
+ * - unknown methods are rejected (never treated as a successful no-op);
+ * - feature/support validation happens in the replay harness, not here;
+ * - values are bounded in size/depth and deep-frozen before being handed out;
+ * - method handlers only run inside the harness-provided replay isolation.
+ */
+import type { TuiChannelInvokeOutput, TuiChannelSnapshot } from '../spec/index.js';
+export interface ChannelProviderOpenInput {
+    readonly workspace?: string;
+    readonly sessionId?: string;
+    readonly options?: unknown;
+}
+export interface ChannelProvider {
+    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;
+    }>;
+}
+export interface ReplayChannelSnapshotSource {
+    /** Monotonic snapshots, oldest first. The provider serves the latest
+     * snapshot from `open` and replays newer snapshots through `subscribe`. */
+    readonly snapshots: readonly TuiChannelSnapshot[];
+    /** Optional transcript/event log carried alongside the snapshots. It is
+     * not interpreted by the provider; it exists for replay provenance and
+     * for conformance report details. */
+    readonly transcript?: readonly unknown[];
+    /** Optional method invocation handlers. Unknown methods are rejected with
+     * `FEATURE_UNAVAILABLE` (or `INVALID_ARGUMENT` for malformed input). */
+    readonly methods?: Readonly<Record<string, (args: readonly unknown[]) => unknown | Promise<unknown>>>;
+}
+/** Safety bound for replay JSON payloads. */
+export declare const REPLAY_JSON_MAX_BYTES: number;
+/** Safety bound for replay JSON nesting depth. */
+export declare const REPLAY_JSON_MAX_DEPTH = 64;
+/** Create an isolated replay Channel Provider over recorded snapshots. */
+export declare function createReplayChannelProvider(source: ReplayChannelSnapshotSource): ChannelProvider;
+/** Convenience provider over one snapshot (common replay fixture). */
+export declare function createReplayChannelProviderFromSnapshot(snapshot: TuiChannelSnapshot, transcript?: readonly unknown[]): ChannelProvider;
+export declare const REPLAY_CHANNEL_WIRE_REVISION: 6;
+//# sourceMappingURL=provider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../../src/adapter/channel/provider.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AASH,OAAO,KAAK,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAElF,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAC3B;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,CACJ,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,SAAS,OAAO,EAAE,GACvB,OAAO,CAAC,sBAAsB,CAAC,CAAA;IAClC,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAA;KAAE,CAAC,CAAA;CAC7D;AAED,MAAM,WAAW,2BAA2B;IAC1C;+EAC2E;IAC3E,QAAQ,CAAC,SAAS,EAAE,SAAS,kBAAkB,EAAE,CAAA;IACjD;;yCAEqC;IACrC,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,OAAO,EAAE,CAAA;IACxC;4EACwE;IACxE,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,SAAS,OAAO,EAAE,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAA;CACtG;AAED,6CAA6C;AAC7C,eAAO,MAAM,qBAAqB,QAAa,CAAA;AAC/C,kDAAkD;AAClD,eAAO,MAAM,qBAAqB,KAAK,CAAA;AA2EvC,0EAA0E;AAC1E,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,2BAA2B,GAAG,eAAe,CA2HhG;AAED,sEAAsE;AACtE,wBAAgB,uCAAuC,CACrD,QAAQ,EAAE,kBAAkB,EAC5B,UAAU,GAAE,SAAS,OAAO,EAAO,GAClC,eAAe,CAKjB;AAUD,eAAO,MAAM,4BAA4B,GAA4B,CAAA"}

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

@@ -0,0 +1,231 @@
+/**
+ * TUI Channel Provider (P5).
+ *
+ * A Channel Provider owns the Agent/Session/Workspace side of
+ * `tui.dsh/v1alpha1#Channel`. This module implements an in-memory replay
+ * provider used by the replay harness: it does not attach to a real DSH
+ * service, but it follows the protocol envelope (open/subscribe/invoke/
+ * close), validates inputs/outputs, preserves monotonic channel versions,
+ * and can be driven from a real recorded DSH session snapshot/transcript.
+ *
+ * The replay provider is intentionally protocol-envelope focused:
+ * - unknown methods are rejected (never treated as a successful no-op);
+ * - feature/support validation happens in the replay harness, not here;
+ * - values are bounded in size/depth and deep-frozen before being handed out;
+ * - method handlers only run inside the harness-provided replay isolation.
+ */
+import { TUI_CHANNEL_WIRE_REVISION, validateTuiChannelInput, validateTuiChannelOutput, validateTuiChannelSnapshot, } from '../spec/index.js';
+import { isReplayIsolationActive } from '../kernel/replay-isolation.js';
+/** Safety bound for replay JSON payloads. */
+export const REPLAY_JSON_MAX_BYTES = 512 * 1024;
+/** Safety bound for replay JSON nesting depth. */
+export const REPLAY_JSON_MAX_DEPTH = 64;
+function deepFreezeCopy(value, seen = new WeakMap()) {
+    if (value === null || typeof value !== 'object')
+        return value;
+    const existing = seen.get(value);
+    if (existing !== undefined)
+        return existing;
+    if (Array.isArray(value)) {
+        const copy = [];
+        seen.set(value, copy);
+        for (const item of value)
+            copy.push(deepFreezeCopy(item, seen));
+        return Object.freeze(copy);
+    }
+    const copy = {};
+    seen.set(value, copy);
+    for (const [key, item] of Object.entries(value)) {
+        copy[key] = deepFreezeCopy(item, seen);
+    }
+    return Object.freeze(copy);
+}
+function assertBoundedJson(value, label, depth = 0, ancestors = new Set()) {
+    if (depth > REPLAY_JSON_MAX_DEPTH) {
+        throw new TypeError(`${label}: JSON nesting exceeds ${REPLAY_JSON_MAX_DEPTH} levels`);
+    }
+    if (value === null || typeof value === 'boolean' || typeof value === 'string')
+        return;
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value))
+            throw new TypeError(`${label}: JSON numbers must be finite`);
+        return;
+    }
+    if (typeof value !== 'object') {
+        throw new TypeError(`${label}: must be a JSON value`);
+    }
+    if (ancestors.has(value))
+        throw new TypeError(`${label}: must not contain cycles`);
+    ancestors.add(value);
+    if (Array.isArray(value)) {
+        for (const [index, item] of value.entries())
+            assertBoundedJson(item, `${label}[${index}]`, depth + 1, ancestors);
+    }
+    else {
+        const prototype = Object.getPrototypeOf(value);
+        if (prototype !== Object.prototype && prototype !== null) {
+            throw new TypeError(`${label}: must contain only plain objects`);
+        }
+        for (const [key, item] of Object.entries(value)) {
+            assertBoundedJson(item, `${label}.${key}`, depth + 1, ancestors);
+        }
+    }
+    ancestors.delete(value);
+}
+function assertJsonSize(value, label) {
+    let json;
+    try {
+        json = JSON.stringify(value);
+    }
+    catch {
+        throw new TypeError(`${label}: value is not JSON-serializable`);
+    }
+    if (json === undefined)
+        throw new TypeError(`${label}: value is not JSON-serializable`);
+    if (Buffer.byteLength(json, 'utf8') > REPLAY_JSON_MAX_BYTES) {
+        throw new TypeError(`${label}: JSON payload exceeds ${REPLAY_JSON_MAX_BYTES} bytes`);
+    }
+}
+function channelSnapshot(value) {
+    const validated = validateTuiChannelSnapshot(value);
+    assertBoundedJson(validated, 'Channel snapshot');
+    assertJsonSize(validated, 'Channel snapshot');
+    return deepFreezeCopy(validated);
+}
+function invokeOutput(value) {
+    const validated = validateTuiChannelOutput('invoke', value);
+    assertBoundedJson(validated, 'Channel invoke output');
+    assertJsonSize(validated, 'Channel invoke output');
+    return deepFreezeCopy(validated);
+}
+/** Create an isolated replay Channel Provider over recorded snapshots. */
+export function createReplayChannelProvider(source) {
+    if (!Array.isArray(source.snapshots) || source.snapshots.length === 0) {
+        throw new TypeError('replay Channel provider requires at least one snapshot');
+    }
+    if (source.methods !== undefined && (source.methods === null
+        || typeof source.methods !== 'object'
+        || (Object.getPrototypeOf(source.methods) !== Object.prototype && Object.getPrototypeOf(source.methods) !== null))) {
+        throw new TypeError('replay Channel methods must be a plain object map');
+    }
+    for (const [name, handler] of Object.entries(source.methods ?? {})) {
+        if (typeof handler !== 'function') {
+            throw new TypeError(`replay Channel method "${name}" must be a function`);
+        }
+    }
+    const snapshots = Object.freeze([...source.snapshots].map(channelSnapshot));
+    for (let index = 1; index < snapshots.length; index += 1) {
+        const previous = snapshots[index - 1];
+        const current = snapshots[index];
+        if (current.channelId !== previous.channelId) {
+            throw new TypeError('replay Channel snapshots must share one channelId');
+        }
+        if (!(current.version > previous.version)) {
+            throw new TypeError('replay Channel snapshots must have strictly increasing versions');
+        }
+    }
+    let currentIndex = snapshots.length - 1;
+    let closed = false;
+    function latest() {
+        return snapshots[currentIndex];
+    }
+    function assertOpen() {
+        if (closed)
+            throw new Error('CHANNEL_CLOSED');
+    }
+    return Object.freeze({
+        async open(input) {
+            validateTuiChannelInput('open', {
+                ...input,
+                ...(input.options === undefined ? {} : { options: input.options }),
+            });
+            // The replay provider is a deterministic fixture harness, not a DSH
+            // endpoint that resolves workspace/session authorities. Selector
+            // resolution is explicitly unsupported: silently returning the latest
+            // snapshot for a wrong selector would be a false conformance claim.
+            if ((input.workspace !== undefined && input.workspace !== '')
+                || (input.sessionId !== undefined && input.sessionId !== '')) {
+                throw new Error('REPLAY_PROVIDER_UNSUPPORTED_SELECTOR: replay provider does not resolve workspace/sessionId selectors');
+            }
+            closed = false;
+            return latest();
+        },
+        async subscribe(channelId, afterVersion, listener) {
+            validateTuiChannelInput('subscribe', { channelId, afterVersion });
+            assertOpen();
+            const channel = latest();
+            if (channel.channelId !== channelId) {
+                throw new Error('CHANNEL_NOT_FOUND');
+            }
+            let stopped = false;
+            // RFC: subscribe is "not earlier than afterVersion", so equal/version 0
+            // snapshots must also be delivered.
+            for (const snapshot of snapshots) {
+                if (stopped)
+                    break;
+                if (snapshot.version >= afterVersion) {
+                    listener(snapshot);
+                }
+            }
+            return () => {
+                stopped = true;
+            };
+        },
+        async invoke(channelId, method, args) {
+            validateTuiChannelInput('invoke', { channelId, method, arguments: args });
+            assertBoundedJson(args, 'Channel.invoke arguments');
+            assertJsonSize(args, 'Channel.invoke arguments');
+            assertOpen();
+            const channel = latest();
+            if (channel.channelId !== channelId) {
+                throw new Error('CHANNEL_NOT_FOUND');
+            }
+            const handler = source.methods !== undefined && Object.hasOwn(source.methods, method)
+                ? source.methods[method]
+                : undefined;
+            if (typeof handler !== 'function') {
+                // Unknown methods are protocol errors, never a successful no-op.
+                throw new Error(`FEATURE_UNAVAILABLE: unknown Channel method "${method}"`);
+            }
+            if (!isReplayIsolationActive()) {
+                throw new Error('replay Channel method handlers may only run inside replay isolation');
+            }
+            const value = await handler(args);
+            assertJsonValue(value);
+            const output = invokeOutput({
+                value: value ?? null,
+                valueDefined: value !== undefined,
+                ...({ snapshot: latest() }),
+            });
+            // The protocol's `invoke` output is validated above; if a provider
+            // advances state in the future, the snapshot returned must remain
+            // monotonic. The replay provider is intentionally read-only, so the
+            // snapshot never regresses.
+            return output;
+        },
+        async close(channelId) {
+            validateTuiChannelInput('close', { channelId });
+            const channel = latest();
+            if (channel.channelId !== channelId) {
+                throw new Error('CHANNEL_NOT_FOUND');
+            }
+            closed = true;
+            return { closed: true };
+        },
+    });
+}
+/** Convenience provider over one snapshot (common replay fixture). */
+export function createReplayChannelProviderFromSnapshot(snapshot, transcript = []) {
+    return createReplayChannelProvider({
+        snapshots: [snapshot],
+        transcript,
+    });
+}
+function assertJsonValue(value) {
+    if (typeof value === 'function' || typeof value === 'symbol') {
+        throw new TypeError('replay Channel values must be JSON-serializable');
+    }
+    assertBoundedJson(value, 'Channel.invoke result');
+    assertJsonSize(value, 'Channel.invoke result');
+}
+export const REPLAY_CHANNEL_WIRE_REVISION = TUI_CHANNEL_WIRE_REVISION;

package/lib/types/adapter/channel/read-view.d.ts

@@ -0,0 +1,4 @@
+/** Detached in-process read projections. Executable leaves are guarded, not serialized. */
+export declare function markChannelReadDirty(value: object): void;
+export declare function createChannelReadView(check: (mutation: boolean) => void): <T>(value: T, nextVersion: number) => T;
+//# sourceMappingURL=read-view.d.ts.map

package/lib/types/adapter/channel/read-view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-view.d.ts","sourceRoot":"","sources":["../../../../src/adapter/channel/read-view.ts"],"names":[],"mappings":"AAAA,2FAA2F;AAgB3F,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAExD;AAQD,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,CAAC,QAAQ,EAAE,OAAO,KAAK,IAAI,IAgG9D,CAAC,EAAE,OAAO,CAAC,EAAE,aAAa,MAAM,KAAG,CAAC,CAI7C"}

package/lib/types/adapter/channel/read-view.js

@@ -0,0 +1,132 @@
+/** Detached in-process read projections. Executable leaves are guarded, not serialized. */
+/**
+ * Rows are mutable while the channel reduces live events, but renderer-facing
+ * snapshots are not. The reducer marks a row when it changes so a later read
+ * can retain every untouched immutable row from the preceding revision.
+ */
+const dirtyRevisions = new WeakMap();
+/**
+ * Projection brands distinguish inert immutable data from a graph containing
+ * an executable leaf. An outer capability may reuse the former, but MUST walk
+ * the latter so its own lifetime fence wraps every retained callback.
+ */
+const projectedValues = new WeakMap();
+let nextDirtyRevision = 1;
+export function markChannelReadDirty(value) {
+    dirtyRevisions.set(value, nextDirtyRevision++);
+}
+function isTranscriptRow(value) {
+    return 'id' in value && 'kind' in value && 'text' in value;
+}
+export function createChannelReadView(check) {
+    let version = -1;
+    let copies = new WeakMap();
+    function copy(value, key = '', receiver) {
+        if (typeof value === 'function') {
+            const prior = copies.get(value);
+            if (prior?.version === version)
+                return prior.value;
+            // Settings conversions are local presentation callbacks. Every other
+            // executable leaf (workspace continuations/run, etc.) is a mutation.
+            const result = ((...args) => {
+                check(key !== 'format' && key !== 'parse');
+                const output = Reflect.apply(value, receiver, args);
+                if (output instanceof Promise)
+                    return output.then(v => { check(false); return copy(v); });
+                return copy(output);
+            });
+            projectedValues.set(result, true);
+            copies.set(value, { value: result, version, dirtyRevision: 0 });
+            return result;
+        }
+        if (value === null || typeof value !== 'object')
+            return value;
+        // Structural containers are detached below. Every other object is a leaf
+        // with its own identity and semantics — binary buffers, Date, Error, class
+        // instances, promises — and copying one key by key silently hollows it
+        // out: a projected transcript image reached sharp as a plain object and
+        // decoded as "Input file is missing" (rendered 无法预览). Date and RegExp
+        // get a faithful detached copy; everything else is shared as-is, because
+        // no copy preserves an opaque value and a hollow one is strictly worse.
+        if (!Array.isArray(value) && !(value instanceof Map) && !(value instanceof Set)) {
+            if (value instanceof Date)
+                return new Date(value.getTime());
+            if (value instanceof RegExp)
+                return new RegExp(value.source, value.flags);
+            const proto = Object.getPrototypeOf(value);
+            if (proto !== Object.prototype && proto !== null)
+                return value;
+        }
+        // An inner ChannelUi projection is safe immutable data, but an outer
+        // production mount must still capture its own lifetime around nested
+        // callbacks. Reuse purely structural data; walk callable graphs again.
+        if (projectedValues.get(value) === false)
+            return value;
+        const prior = copies.get(value);
+        const dirtyRevision = dirtyRevisions.get(value) ?? 0;
+        // Transcript row identity is deliberately stable across unrelated channel
+        // revisions. A dirty row gets a new detached copy; old snapshots remain
+        // frozen and therefore cannot observe the backend mutation.
+        if (prior !== undefined && isTranscriptRow(value) && prior.dirtyRevision === dirtyRevision)
+            return prior.value;
+        // The transcript container is marked on membership or row changes. When
+        // no such mark occurred, activity/status versions retain the exact frozen
+        // array rather than visiting historical rows again.
+        if (prior !== undefined &&
+            Array.isArray(value) &&
+            (value.length === 0 || (value[0] !== null && typeof value[0] === 'object' && isTranscriptRow(value[0]))) &&
+            prior.value.length === value.length &&
+            prior.dirtyRevision === dirtyRevision)
+            return prior.value;
+        if (prior !== undefined && !isTranscriptRow(value) && prior.version === version)
+            return prior.value;
+        if (value instanceof Map) {
+            const entries = new Map([...value].map(([k, v]) => [copy(k), copy(v)]));
+            const view = Object.freeze({
+                get size() { return entries.size; }, has: entries.has.bind(entries), get: entries.get.bind(entries),
+                entries: entries.entries.bind(entries), keys: entries.keys.bind(entries), values: entries.values.bind(entries),
+                [Symbol.iterator]: entries[Symbol.iterator].bind(entries),
+                forEach(callback, thisArg) { entries.forEach((v, k) => callback.call(thisArg, v, k, view)); },
+            });
+            const executable = [...entries].some(([key, entry]) => projectedValues.get(key) === true || projectedValues.get(entry) === true);
+            projectedValues.set(view, executable);
+            copies.set(value, { value: view, version, dirtyRevision });
+            return view;
+        }
+        if (value instanceof Set) {
+            const entries = new Set([...value].map(v => copy(v)));
+            const view = Object.freeze({
+                get size() { return entries.size; }, has: entries.has.bind(entries),
+                entries: entries.entries.bind(entries), keys: entries.keys.bind(entries), values: entries.values.bind(entries),
+                [Symbol.iterator]: entries[Symbol.iterator].bind(entries),
+                forEach(callback, thisArg) { entries.forEach(v => callback.call(thisArg, v, v, view)); },
+            });
+            const executable = [...entries].some(entry => projectedValues.get(entry) === true);
+            projectedValues.set(view, executable);
+            copies.set(value, { value: view, version, dirtyRevision });
+            return view;
+        }
+        const result = Array.isArray(value) ? [] : Object.create(null);
+        copies.set(value, { value: result, version, dirtyRevision });
+        if (Array.isArray(value)) {
+            // Avoid Object.entries' whole-history tuple allocation. The new frozen
+            // container is required to preserve old array snapshots, while each
+            // unchanged row itself is structurally shared above.
+            for (let index = 0; index < value.length; index++)
+                result.push(copy(value[index], String(index), value));
+        }
+        else {
+            for (const [name, child] of Object.entries(value))
+                result[name] = copy(child, name, value);
+        }
+        const frozen = Object.freeze(result);
+        const executable = Object.values(result).some(child => child !== null && (typeof child === 'object' || typeof child === 'function') && projectedValues.get(child) === true);
+        projectedValues.set(frozen, executable);
+        copies.set(value, { value: frozen, version, dirtyRevision });
+        return frozen;
+    }
+    return (value, nextVersion) => {
+        version = nextVersion;
+        return copy(value);
+    };
+}

package/lib/types/adapter/channel/session-projection.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Minimal real DSH session-event → TuiChannelSnapshot projection.
+ *
+ * This is the P5 "real DSH replay" bridge: instead of only counting a
+ * transcript, it reads `agent.session.events`-shaped records and projects the
+ * visible rows/status into protocol-envelope `TuiChannelSnapshot` objects.
+ *
+ * It intentionally stays small and does not copy the full production
+ * `src/dsh-adapter/channel.ts` projection (which is still the live Channel
+ * implementation source). It is a durable-session *minimal transcript
+ * replay* projection used by the harness and documentation, not a complete
+ * RFC 0007 TUI Channel state projection.
+ *
+ * Unknown event types are fail-closed unless the event marks itself
+ * top-level `ignorable: true`, so a newer required DSH event cannot be
+ * silently skipped. Prefix-based recognition is deliberately not used.
+ */
+import type { TuiChannelSnapshot } from '../spec/index.js';
+export interface DshSessionProjectionMeta {
+    readonly channelId: string;
+    readonly sessionTitle?: string;
+    readonly homeDir?: string;
+    readonly pathCaseInsensitive?: boolean;
+    /** Optional RFC-adjacent Channel state fields carried through when known. */
+    readonly model?: string;
+    readonly mode?: string;
+    readonly agentPreset?: string;
+    readonly settingsSections?: readonly unknown[];
+    readonly scene?: unknown;
+    readonly diagnostic?: unknown;
+    readonly trace?: readonly unknown[];
+    readonly context?: unknown;
+    readonly pending?: readonly unknown[];
+}
+export declare class DshSessionProjectionError extends Error {
+    constructor(message: string);
+}
+/**
+ * Explicit DSH session event types this minimal projection recognizes.
+ *
+ * This is NOT a prefix list: `user/unknown-required` is not recognized unless
+ * the exact type is present. Unknown types must be marked top-level
+ * `ignorable: true` to be skipped.
+ */
+export declare const KNOWN_DSH_EVENT_TYPES: Set<string>;
+/**
+ * Project DSH session events to strictly-increasing channel snapshots.
+ *
+ * The returned snapshots are plain JSON-safe objects suitable for
+ * `createReplayChannelProvider`. If `events` is empty, one initial snapshot
+ * is returned so a replay can still open/subscribe cleanly.
+ *
+ * Unknown non-ignorable event types cause a `DshSessionProjectionError`.
+ */
+export declare function projectDshSessionEventsToSnapshots(events: readonly unknown[], meta: DshSessionProjectionMeta): readonly TuiChannelSnapshot[];
+//# sourceMappingURL=session-projection.d.ts.map

package/lib/types/adapter/channel/session-projection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-projection.d.ts","sourceRoot":"","sources":["../../../../src/adapter/channel/session-projection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAE1D,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAA;IAC9B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,mBAAmB,CAAC,EAAE,OAAO,CAAA;IACtC,6EAA6E;IAC7E,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,gBAAgB,CAAC,EAAE,SAAS,OAAO,EAAE,CAAA;IAC9C,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAA;IACxB,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAA;IAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,OAAO,EAAE,CAAA;IACnC,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;IAC1B,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,OAAO,EAAE,CAAA;CACtC;AAED,qBAAa,yBAA0B,SAAQ,KAAK;gBACtC,OAAO,EAAE,MAAM;CAI5B;AAaD;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,aA+FhC,CAAA;AAsCF;;;;;;;;GAQG;AACH,wBAAgB,kCAAkC,CAChD,MAAM,EAAE,SAAS,OAAO,EAAE,EAC1B,IAAI,EAAE,wBAAwB,GAC7B,SAAS,kBAAkB,EAAE,CAqE/B"}