@deepseek-harness-tui/dsh-tui 0.10.0 → 0.10.2

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,aA6FhC,CAAA;AAsCF;;;;;;;;GAQG;AACH,wBAAgB,kCAAkC,CAChD,MAAM,EAAE,SAAS,OAAO,EAAE,EAC1B,IAAI,EAAE,wBAAwB,GAC7B,SAAS,kBAAkB,EAAE,CAqE/B"}

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

@@ -0,0 +1,247 @@
+/**
+ * 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 { TUI_CHANNEL_WIRE_REVISION } from '../spec/index.js';
+export class DshSessionProjectionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'DshSessionProjectionError';
+    }
+}
+/**
+ * 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 const KNOWN_DSH_EVENT_TYPES = new Set([
+    // dsh-session core event map
+    'turn/start',
+    'turn/end',
+    'step/start',
+    'step/end',
+    'user/message',
+    // Retired by 0.1.5 (stream timing moved into the settlement events) but
+    // still present in pre-V3 logs this projection must keep replaying.
+    'assistant/chunk',
+    'assistant/message',
+    // 0.1.5: abandoned attempt (failed/retried/cancelled, no surface message).
+    'assistant/attempt',
+    // 0.1.5: the system prompt became a surface node.
+    'system/message',
+    'tool/call',
+    'tool/result',
+    'command/run',
+    'command/done',
+    'hook/invoked',
+    'hook/result',
+    'agent/inbox/spliced',
+    'todo/write',
+    'request/header',
+    'request/context',
+    'session/end-seed',
+    // Not an appendable session event: 0.1.5 declares it in the same types file
+    // as a RemoteErrorDetailsMap key (SessionId resolution failure). Recognized
+    // here so the conformance sweep over that file stays total; it folds to no
+    // row like every other non-transcript type.
+    'session/not-found',
+    // Known dsh-tui / ecosystem plugin event types (exact, not prefix-based)
+    'session/created',
+    'session/disposed',
+    'session/flush',
+    'session/title',
+    'session/color',
+    'session/title-llm-request',
+    'session/event',
+    'agent/status',
+    'agent/disposed',
+    'agent/request',
+    'agent/inbox/claimed',
+    'agent/inbox/discarded',
+    'agent-preset/selected',
+    'approval/asked',
+    'approval/decided',
+    'approval/policy',
+    'commands/change',
+    'skills/change',
+    'goal/change',
+    'plan/mode',
+    'sandbox/mode',
+    'permission/preset',
+    'llm/retry',
+    'llm/retry-started',
+    'model/selection',
+    'compaction/start',
+    'compaction/end',
+    'compaction/prune',
+    'compaction/summary',
+    'deliverables/presented',
+    'feedback/record',
+    'feedback/message-put',
+    'feedback/message-delete',
+    'schedule/change',
+    'session-invariant',
+    'session-log-deepseek/delivery-accepted',
+    'subagent/start',
+    'subagent/end',
+    'subagent/descriptor',
+    'subagent/catalog',
+    'subagent/model-selection-policy',
+    'team/member',
+    'team/message/delivered',
+    'team/message/queued',
+    'team/task',
+    'tool-workflow/agent-start',
+    'tool-workflow/agent-end',
+    'tool-workflow/run-start',
+    'tool-workflow/run-end',
+    // The code runner's dispatch bracket was renamed in 0.1.5; old logs still
+    // carry the `code-` spellings, so both generations stay recognized.
+    'tool/code-dispatch',
+    'tool/code-dispatch-start',
+    'tool/ptc-dispatch',
+    'tool/ptc-dispatch-start',
+    'web/deepseek-search-llm-request',
+    'dsh-tui/btw',
+    'dsh-tui/recap',
+    'dsh-working-activity/config',
+    'dsh-working-activity/status',
+    'activity/status',
+]);
+function isKnownEventType(type) {
+    return KNOWN_DSH_EVENT_TYPES.has(type);
+}
+function firstText(value) {
+    if (typeof value === 'string')
+        return value;
+    if (value === null || typeof value !== 'object')
+        return '';
+    const record = value;
+    if (typeof record.text === 'string')
+        return record.text;
+    const content = record.content;
+    if (!Array.isArray(content))
+        return '';
+    const parts = [];
+    for (const block of content) {
+        if (block === null || typeof block !== 'object')
+            continue;
+        const item = block;
+        if (typeof item.text === 'string')
+            parts.push(item.text);
+    }
+    return parts.join('');
+}
+function projectEvent(event) {
+    const type = typeof event.type === 'string' ? event.type : '';
+    const data = (event.data ?? {});
+    const text = firstText(data.message ?? data);
+    if (text === '')
+        return undefined;
+    if (type === 'user/message')
+        return { kind: 'user', text };
+    if (type === 'assistant/message')
+        return { kind: 'assistant', text };
+    return undefined;
+}
+function isIgnorable(event) {
+    // DSH `SessionEvent` places `ignorable` at the top level of the event,
+    // never inside `data`.
+    return event.ignorable === true;
+}
+/**
+ * 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 function projectDshSessionEventsToSnapshots(events, meta) {
+    const rows = [];
+    const snapshots = [];
+    let version = 0;
+    let status = 'idle';
+    let usage = Object.freeze({});
+    let context = meta.context;
+    let pending = meta.pending;
+    let diagnostic = meta.diagnostic;
+    let trace = meta.trace ?? Object.freeze([]);
+    const push = () => {
+        const state = {
+            status,
+            sessionTitle: meta.sessionTitle ?? 'dsh session',
+            homeDir: meta.homeDir ?? '/',
+            pathCaseInsensitive: meta.pathCaseInsensitive ?? false,
+            transcript: Object.freeze(rows.map(row => Object.freeze({ ...row }))),
+            commandCatalog: Object.freeze([]),
+            ...(Object.keys(usage).length === 0 ? {} : { usage }),
+            ...(meta.model === undefined ? {} : { model: meta.model }),
+            ...(meta.mode === undefined ? {} : { mode: meta.mode }),
+            ...(meta.agentPreset === undefined ? {} : { agentPreset: meta.agentPreset }),
+            ...(meta.settingsSections === undefined ? {} : { settingsSections: Object.freeze([...meta.settingsSections]) }),
+            ...(meta.scene === undefined ? {} : { scene: meta.scene }),
+            ...(context === undefined ? {} : { context }),
+            ...(pending === undefined ? {} : { pending: Object.freeze([...pending]) }),
+            ...(diagnostic === undefined ? {} : { diagnostic }),
+            ...(trace === undefined ? {} : { trace }),
+        };
+        version += 1;
+        snapshots.push({
+            wireRevision: TUI_CHANNEL_WIRE_REVISION,
+            channelId: meta.channelId,
+            version,
+            state: Object.freeze(state),
+        });
+    };
+    push();
+    for (const raw of events) {
+        if (raw === null || typeof raw !== 'object') {
+            throw new DshSessionProjectionError('DSH session event must be an object');
+        }
+        const event = raw;
+        const type = typeof event.type === 'string' ? event.type : '';
+        if (type === '') {
+            // Missing type is always rejectable: even an `ignorable` marker cannot
+            // describe which event is being skipped.
+            throw new DshSessionProjectionError('DSH session event is missing a type');
+        }
+        if (!isKnownEventType(type)) {
+            if (isIgnorable(event))
+                continue;
+            throw new DshSessionProjectionError(`unknown non-ignorable DSH session event: ${type}`);
+        }
+        const data = (event.data ?? {});
+        if (type === 'turn/start')
+            status = 'working';
+        if (type === 'turn/end' || type === 'session/end-seed')
+            status = 'idle';
+        if (type === 'assistant/message' && data.usage !== null && typeof data.usage === 'object') {
+            usage = Object.freeze({ ...data.usage });
+        }
+        if (type === 'request/context') {
+            context = data;
+        }
+        const row = projectEvent(event);
+        if (row !== undefined)
+            rows.push(row);
+        push();
+    }
+    return Object.freeze(snapshots);
+}

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

@@ -0,0 +1,11 @@
+/**
+ * Channel state module (P4 channel split).
+ *
+ * Reads the live Channel's mutable reactive state and returns a frozen,
+ * JSON-ish state snapshot. This module only projects; it never mutates.
+ */
+import type { Channel } from '../../dsh-adapter/channel.js';
+import type { HostChannelStateSnapshot } from '../ports/channel.js';
+/** Project the live Channel state into a serializable host-internal snapshot. */
+export declare function projectChannelState(channel: Channel): HostChannelStateSnapshot;
+//# sourceMappingURL=state.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../../src/adapter/channel/state.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,8BAA8B,CAAA;AAC3D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAA;AAgBnE,iFAAiF;AACjF,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,wBAAwB,CAgC9E"}

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

@@ -0,0 +1,55 @@
+/**
+ * Channel state module (P4 channel split).
+ *
+ * Reads the live Channel's mutable reactive state and returns a frozen,
+ * JSON-ish state snapshot. This module only projects; it never mutates.
+ */
+function asRecord(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    return Object.freeze({ ...value });
+}
+function asNumberRecord(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return Object.freeze({});
+    const out = {};
+    for (const [key, item] of Object.entries(value)) {
+        if (typeof item === 'number' && Number.isFinite(item))
+            out[key] = item;
+    }
+    return Object.freeze(out);
+}
+/** Project the live Channel state into a serializable host-internal snapshot. */
+export function projectChannelState(channel) {
+    return Object.freeze({
+        version: channel.version,
+        status: channel.status,
+        sessionTitle: channel.sessionTitle,
+        sessionColor: channel.sessionColor,
+        agentId: channel.agentId,
+        agentBindingGeneration: channel.agentBindingGeneration,
+        model: channel.model,
+        provider: channel.provider,
+        cwd: channel.cwd,
+        displayCwd: channel.displayCwd,
+        ...(channel.gitBranch === undefined ? {} : { gitBranch: channel.gitBranch }),
+        working: channel.working,
+        cancelPending: channel.cancelPending,
+        spinnerMode: channel.spinnerMode,
+        responseChars: channel.responseChars,
+        activeToolCount: channel.activeToolCount,
+        turnStart: channel.turnStart,
+        lastUserText: channel.lastUserText,
+        tokens: asNumberRecord(channel.tokens),
+        ...(channel.lastUsage === undefined ? {} : { lastUsage: asNumberRecord(channel.lastUsage) }),
+        ...(channel.workingActivity === undefined ? {} : { workingActivity: asRecord(channel.workingActivity) }),
+        ...(channel.activityFrames === undefined ? {} : { activityFrames: channel.activityFrames }),
+        ...(channel.goal === undefined ? {} : { goal: asRecord(channel.goal) }),
+        todos: Object.freeze(channel.todos.map(todo => Object.freeze({ ...todo }))),
+        ...(channel.loadedContext === undefined ? {} : { loadedContext: asRecord(channel.loadedContext) }),
+        pending: Object.freeze(channel.pending.map(pending => Object.freeze({ ...pending }))),
+        ...(channel.pluginScene === undefined ? {} : { pluginScene: asRecord(channel.pluginScene) }),
+        mode: asRecord(channel.mode) ?? Object.freeze({}),
+        ...(channel.agentPreset === undefined ? {} : { agentPreset: channel.agentPreset }),
+    });
+}

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

@@ -0,0 +1,15 @@
+/**
+ * Channel transcript module (P4 channel split).
+ *
+ * Provides the durable transcript/event access half of the live Channel:
+ * rendered rows plus the raw DSH session event log used by `/trace`.
+ *
+ * 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 { HostChannelTranscriptPort } from '../ports/channel.js';
+/** Build the host-internal transcript surface over one live Channel. */
+export declare function createChannelTranscript(channel: Channel, token: symbol): HostChannelTranscriptPort;
+//# sourceMappingURL=transcript.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transcript.d.ts","sourceRoot":"","sources":["../../../../src/adapter/channel/transcript.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,8BAA8B,CAAA;AAC3D,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAA;AAIpE,wEAAwE;AACxE,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,yBAAyB,CAQlG"}

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

@@ -0,0 +1,22 @@
+/**
+ * Channel transcript module (P4 channel split).
+ *
+ * Provides the durable transcript/event access half of the live Channel:
+ * rendered rows plus the raw DSH session event log used by `/trace`.
+ *
+ * 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 { projectChannelRows } from './projection.js';
+import { CHANNEL_SPLIT_TOKEN } from './internal-token.js';
+/** Build the host-internal transcript surface over one live Channel. */
+export function createChannelTranscript(channel, token) {
+    if (token !== CHANNEL_SPLIT_TOKEN) {
+        throw new Error('dsh-tui: Channel split transcript requires the internal host token');
+    }
+    return Object.freeze({
+        rows: () => projectChannelRows(channel.rows),
+        traceEvents: () => channel.traceEvents(),
+    });
+}

package/lib/types/adapter/channel/ui-policy.d.ts

@@ -0,0 +1,106 @@
+/** Explicit in-process UI method inventory; never a wire protocol.
+ * Queries that warm caches or publish notices remain effectful.
+ */
+import type { ChannelUi } from '../ports/channel-ui.js';
+export type { ChannelUi } from '../ports/channel-ui.js';
+export type ChannelPreferences = Pick<ChannelUi, 'setDiffLayout' | 'setThinkingFold' | 'setToolBackground' | 'setScrollGutter' | 'setPageMargin' | 'setFoldTerminalCommand' | 'setPromptSessionLabel' | 'setExpandEditor' | 'setSmoothStreaming' | 'setStatusBar' | 'setWhale' | 'setWhaleIdle' | 'setMinimal'>;
+export declare const CHANNEL_UI_EFFECTS: Readonly<{
+    setDiffLayout: "mutate";
+    setThinkingFold: "mutate";
+    setToolBackground: "mutate";
+    setScrollGutter: "mutate";
+    setPageMargin: "mutate";
+    setFoldTerminalCommand: "mutate";
+    setPromptSessionLabel: "mutate";
+    setExpandEditor: "mutate";
+    setSmoothStreaming: "mutate";
+    setStatusBar: "mutate";
+    setWhale: "mutate";
+    setWhaleIdle: "mutate";
+    setMinimal: "mutate";
+    commandCompletions: "mutate";
+    runExternalCommand: "mutate";
+    runExternalCommandOutcome: "mutate";
+    openPluginScene: "mutate";
+    closePluginScene: "mutate";
+    sideQuestion: "mutate";
+    stagedImageGeneration: "read-only";
+    stageImage: "mutate";
+    stageComposerImage: "mutate";
+    hasStagedImage: "read-only";
+    discardStagedImage: "mutate";
+    stagedImage: "read-only";
+    stagedImageLimits: "read-only";
+    submit: "mutate";
+    steer: "mutate";
+    removePending: "mutate";
+    cancel: "mutate";
+    interruptAndDeliver: "mutate";
+    rewindTo: "mutate";
+    promptRewind: "mutate";
+    buildSessionTree: "mutate";
+    rewindToNode: "mutate";
+    forkSession: "mutate";
+    resumeTo: "mutate";
+    newSession: "mutate";
+    listWorkspaces: "read-only";
+    resolveWorkspace: "mutate";
+    switchWorkspace: "mutate";
+    renameWorkspace: "mutate";
+    workspaceCommands: "read-only";
+    runWorkspaceCommand: "mutate";
+    switchModel: "mutate";
+    listEfforts: "mutate";
+    setEffort: "mutate";
+    setDefaultEffort: "mutate";
+    cycleMode: "mutate";
+    permissionPresets: "read-only";
+    runPermissionPreset: "mutate";
+    listPresets: "read-only";
+    switchPreset: "mutate";
+    clear: "mutate";
+    loadOlder: "mutate";
+    notify: "mutate";
+    setActivityFrames: "mutate";
+    listModels: "read-only";
+    listProviders: "read-only";
+    invalidateModelCompletion: "mutate";
+    listSkills: "read-only";
+    describeCredential: "read-only";
+    balanceInfo: "mutate";
+    providerSetup: "read-only";
+    oauthProviderStatuses: "read-only";
+    settingsHost: "read-only";
+    settingsSections: "read-only";
+    subscribeSettingsSections: "subscribe";
+    listFileCandidates: "read-only";
+    listFiles: "read-only";
+    listSessions: "read-only";
+    previewSession: "read-only";
+    setResumeTarget: "mutate";
+    renameSession: "mutate";
+    setSessionColor: "mutate";
+    recapRecent: "mutate";
+    deleteSession: "mutate";
+    renameSessionTo: "mutate";
+    compact: "mutate";
+    pushLocal: "mutate";
+    mcpStatus: "read-only";
+    exportSession: "mutate";
+    initWorkspace: "mutate";
+    doctorInfo: "read-only";
+    pluginsInfo: "mutate";
+    listSubagents: "read-only";
+    agentViewRows: "read-only";
+    subscribeAgentView: "subscribe";
+    dispatchBackgroundAgent: "mutate";
+    stopBackgroundAgent: "mutate";
+    attachToAgent: "mutate";
+    peekAgentSession: "read-only";
+    backgroundCurrent: "mutate";
+    replyToAgent: "mutate";
+    traceEvents: "read-only";
+    subscribe: "subscribe";
+}>;
+export declare const CHANNEL_UI_PROPERTIES: readonly ["version", "rows", "status", "sessionTitle", "sessionColor", "agentId", "agentBindingGeneration", "autoRecapOnOpen", "model", "provider", "configuredProvider", "configuredModel", "configuredPreset", "configuredActivityFrames", "configuredLang", "tokens", "cwd", "displayCwd", "gitBranch", "working", "cancelPending", "spinnerMode", "responseChars", "activeToolCount", "turnStart", "lastUserText", "notifications", "contextWindow", "reasoningEffort", "effortLevels", "lastUsage", "tps", "tpsSamples", "workingActivity", "activityFrames", "diffLayout", "thinkingFold", "toolBackground", "scrollGutter", "pageMargin", "foldTerminalCommand", "promptSessionLabel", "expandEditor", "smoothStreaming", "statusBar", "whale", "whaleIdle", "minimal", "activityEnabled", "contextBarEnabled", "goal", "todos", "loadedContext", "pending", "commandList", "pluginScene", "contextSegments", "subagents", "subagentControl", "backgroundJobs", "jobControl", "mode", "modeIndex", "agentPreset"];
+//# sourceMappingURL=ui-policy.d.ts.map

package/lib/types/adapter/channel/ui-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ui-policy.d.ts","sourceRoot":"","sources":["../../../../src/adapter/channel/ui-policy.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAA;AACvD,YAAY,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAA;AAIvD,MAAM,MAAM,kBAAkB,GAAG,IAAI,CAAC,SAAS,EAC3C,eAAe,GAAG,iBAAiB,GAAG,mBAAmB,GAAG,iBAAiB,GAC7E,eAAe,GAAG,wBAAwB,GAAG,uBAAuB,GACpE,iBAAiB,GAAG,oBAAoB,GAAG,cAAc,GAAG,UAAU,GAAG,cAAc,GAAG,YAAY,CACzG,CAAA;AACD,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiG4B,CAAA;AAE3D,eAAO,MAAM,qBAAqB,09BAiEe,CAAA"}