@khorsheed/dsh-context-lens 0.0.0-stage → 0.1.0

package/lib/types/messages.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Normalized message form the capture pipeline segments. Both lanes — the
+ * in-process `llm/stream` waterfall (typed `RequestMessage` values, possibly
+ * deep-frozen) and the child-log lane (untrusted JSON from another process's
+ * session log) — reduce to {@link CapturedMessage} before classification, so
+ * the segmenter sees exactly one shape.
+ *
+ * Classification maps the host's merge-extensible `MessageSource.kind` /
+ * `ContextForm` vocabulary onto the panel's closed {@link SegmentCategory}
+ * set. Unknown producer kinds degrade to `plugin-injection`; the mapping is
+ * additive — a new host kind never throws, it just lands in the plugin bucket
+ * until the map learns it.
+ *
+ * @module @khorsheed/dsh-context-lens/messages
+ */
+import type { RequestMessage } from '@deepseek-ai/dsh-llm';
+import type { SegmentCategory } from './types.ts';
+/** One content block, flattened to the fields the panel displays. */
+export interface CapturedBlock {
+    type: string;
+    text?: string;
+    /** tool-call blocks: provider-issued call id, tool name, raw JSON arguments. */
+    id?: string;
+    name?: string;
+    arguments?: string;
+    /** tool-addition / tool-removal blocks: the affected tool name. */
+    toolName?: string;
+    /** file / image blocks: display label for the placeholder line. */
+    ref?: string;
+}
+/** The lane-neutral message record the segmenter consumes. */
+export interface CapturedMessage {
+    /** Durable message id when the message has one (hand-built one-shot inputs do not). */
+    id?: string;
+    role: 'system' | 'user' | 'assistant' | 'tool' | 'developer';
+    /** `MessageSource.kind` — producer identity in the host's own vocabulary. */
+    sourceKind: string;
+    /** `ContextFormed.form` when the producer declared one. */
+    sourceForm?: string;
+    compactionId?: string;
+    pruning?: {
+        beforeChars: number;
+        afterChars: number;
+    };
+    content: CapturedBlock[];
+    /** tool-role messages: the answered call. */
+    toolCallId?: string;
+    sourceTurn?: number | undefined;
+    isError?: boolean;
+}
+/**
+ * User-role producers that ride along every turn rather than start one: a
+ * turn with no human message is attributed to its first message from any
+ * other producer (a room delivery, a schedule, a plugin trigger).
+ */
+export declare const AMBIENT_SOURCES: ReadonlySet<string>;
+/**
+ * The trigger preview: injected triggers lead with standing instructions and
+ * end with what this turn delivers (a report, a forwarded message), so the
+ * last paragraph is the part that differs turn to turn.
+ */
+export declare function lastParagraph(text: string): string;
+/** Collapse whitespace for the single-line preview, capped at `max` chars. */
+export declare function previewLine(text: string, max?: number): string;
+/**
+ * The verbatim wire form of one message — what `SegmentItem.full` carries.
+ * Assistant rows serialize to a JSON string `{reasoning?, text?, calls?}`
+ * (calls keep the raw argument JSON), the shape the reference panel renders;
+ * every other role is its plain text. The content is pre-projection: the
+ * waterfall sees file/image blocks before the adapter rewrites them to handle
+ * text, so they appear as bracketed placeholders.
+ */
+export declare function serializeMessage(message: CapturedMessage): string;
+/** Tool names one assistant message invoked (the chip on assistant rows). */
+export declare function toolCallNames(message: CapturedMessage): string[];
+/** Single-line summary of one message for the collapsed row. */
+export declare function previewMessage(message: CapturedMessage): string;
+/**
+ * Classify one message into its panel category. Role decides first; user-role
+ * rows refine by producer `kind`, with `form: 'snapshot'` as the fallback
+ * signal for runtime snapshots from producers the explicit map predates.
+ */
+export declare function classifyMessage(message: CapturedMessage): SegmentCategory;
+/** The label a row shows as its origin — producer kind, refined where the panel knows more. */
+export declare function messageSourceLabel(message: CapturedMessage, toolName?: string): string;
+/**
+ * Diff identity for one message: the durable id when present, else a content
+ * hash. Tool-result pruning preserves ids while changing content; the hash
+ * fallback keeps hand-built id-less inputs (aux requests) diffable.
+ */
+export declare function messageKey(message: CapturedMessage, hash: (text: string) => string): string;
+/** Normalize one typed waterfall message (loop-built or hand-built). Never mutates the input. */
+export declare function fromRequestMessage(message: RequestMessage): CapturedMessage;
+/** Structural read of one log-lane message (untrusted JSON). Returns undefined for unreadable rows. */
+export declare function fromLogMessage(raw: unknown): CapturedMessage | undefined;
+//# sourceMappingURL=messages.d.ts.map

package/lib/types/messages.js

@@ -0,0 +1,254 @@
+/**
+ * User-role producers that ride along every turn rather than start one: a
+ * turn with no human message is attributed to its first message from any
+ * other producer (a room delivery, a schedule, a plugin trigger).
+ */
+export const AMBIENT_SOURCES = new Set(['user', 'runtime-context', 'skill-catalog', 'skill-invocation', 'repeat-tool-reminder', 'compact-checkpoint']);
+/**
+ * The trigger preview: injected triggers lead with standing instructions and
+ * end with what this turn delivers (a report, a forwarded message), so the
+ * last paragraph is the part that differs turn to turn.
+ */
+export function lastParagraph(text) {
+    const paragraphs = text.split(/\n\s*\n/).map(p => p.trim()).filter(p => p.length > 0);
+    return previewLine(paragraphs.at(-1) ?? text, 120);
+}
+/** Collapse whitespace for the single-line preview, capped at `max` chars. */
+export function previewLine(text, max = 80) {
+    const collapsed = text.replace(/\s+/g, ' ').trim();
+    return collapsed.length <= max ? collapsed : `${collapsed.slice(0, max - 1)}…`;
+}
+/** Model-facing text of non-assistant content: text verbatim, file/image as placeholder lines. */
+function plainText(blocks) {
+    const parts = [];
+    for (const block of blocks) {
+        switch (block.type) {
+            case 'text':
+                parts.push(block.text ?? '');
+                break;
+            case 'file':
+                parts.push(`[file: ${block.ref ?? 'attachment'}]`);
+                break;
+            case 'image':
+                parts.push(`[image${block.ref === undefined ? '' : `: ${block.ref}`}]`);
+                break;
+            default:
+                break;
+        }
+    }
+    return parts.join('\n');
+}
+/**
+ * The verbatim wire form of one message — what `SegmentItem.full` carries.
+ * Assistant rows serialize to a JSON string `{reasoning?, text?, calls?}`
+ * (calls keep the raw argument JSON), the shape the reference panel renders;
+ * every other role is its plain text. The content is pre-projection: the
+ * waterfall sees file/image blocks before the adapter rewrites them to handle
+ * text, so they appear as bracketed placeholders.
+ */
+export function serializeMessage(message) {
+    if (message.role === 'assistant') {
+        const reasoning = message.content
+            .filter(block => block.type === 'reasoning')
+            .map(block => block.text ?? '')
+            .join('');
+        const text = message.content
+            .filter(block => block.type === 'text')
+            .map(block => block.text ?? '')
+            .join('');
+        const calls = message.content
+            .filter(block => block.type === 'tool-call')
+            .map(block => ({ id: block.id ?? '', name: block.name ?? '', arguments: block.arguments ?? '' }));
+        return JSON.stringify({
+            ...reasoning.length > 0 ? { reasoning } : {},
+            ...text.length > 0 ? { text } : {},
+            ...calls.length > 0 ? { calls } : {},
+        });
+    }
+    if (message.role === 'developer') {
+        return JSON.stringify(message.content);
+    }
+    return plainText(message.content);
+}
+/** Tool names one assistant message invoked (the chip on assistant rows). */
+export function toolCallNames(message) {
+    return message.content
+        .filter(block => block.type === 'tool-call')
+        .map(block => block.name ?? '')
+        .filter(name => name.length > 0);
+}
+/** Single-line summary of one message for the collapsed row. */
+export function previewMessage(message) {
+    if (message.role === 'assistant') {
+        const names = toolCallNames(message);
+        if (names.length > 0)
+            return `→ ${names.join(', ')}`;
+        const text = message.content
+            .filter(block => block.type === 'text')
+            .map(block => block.text ?? '')
+            .join('');
+        return previewLine(text);
+    }
+    if (message.role === 'developer') {
+        const changes = message.content
+            .map(block => (block.type === 'tool-addition' ? `+${block.toolName ?? ''}`
+            : block.type === 'tool-removal' ? `-${block.toolName ?? ''}` : ''))
+            .filter(part => part.length > 1);
+        return previewLine(changes.length > 0 ? `tools ${changes.join(' ')}` : serializeMessage(message));
+    }
+    return previewLine(plainText(message.content));
+}
+/**
+ * Classify one message into its panel category. Role decides first; user-role
+ * rows refine by producer `kind`, with `form: 'snapshot'` as the fallback
+ * signal for runtime snapshots from producers the explicit map predates.
+ */
+export function classifyMessage(message) {
+    switch (message.role) {
+        case 'system':
+            return 'system';
+        case 'assistant':
+            return 'assistant';
+        case 'tool':
+            return 'tool-result';
+        case 'developer':
+            return 'tool-change';
+        case 'user':
+            break;
+    }
+    switch (message.sourceKind) {
+        case 'user':
+            return 'user';
+        case 'runtime-context':
+            return 'runtime-snapshot';
+        case 'skill-catalog':
+        case 'skill-invocation':
+            return 'skill-injection';
+        case 'compact-checkpoint':
+            return 'compaction';
+        case 'repeat-tool-reminder':
+            return 'reminder-injection';
+        default:
+            return message.sourceForm === 'snapshot' ? 'runtime-snapshot' : 'plugin-injection';
+    }
+}
+/** The label a row shows as its origin — producer kind, refined where the panel knows more. */
+export function messageSourceLabel(message, toolName) {
+    if (message.role === 'tool' && toolName !== undefined)
+        return toolName;
+    return message.sourceKind;
+}
+/**
+ * Diff identity for one message: the durable id when present, else a content
+ * hash. Tool-result pruning preserves ids while changing content; the hash
+ * fallback keeps hand-built id-less inputs (aux requests) diffable.
+ */
+export function messageKey(message, hash) {
+    return `${message.id === undefined ? 'h' : `id:${message.id}`}:${hash(JSON.stringify({
+        ...'turn' in message && typeof message.turn === 'number' ? { sourceTurn: message.turn } : {},
+        role: message.role,
+        kind: message.sourceKind,
+        content: message.content,
+        ...message.toolCallId === undefined ? {} : { toolCallId: message.toolCallId },
+    }))}`;
+}
+/** Normalize one typed waterfall message (loop-built or hand-built). Never mutates the input. */
+export function fromRequestMessage(message) {
+    const content = message.content.map(normalizeBlock);
+    // A hand-built one-shot input has neither id nor source; durable messages
+    // carry both. Narrowing through `in` keeps the `?: never` arms honest.
+    const id = 'id' in message && typeof message.id === 'string' ? message.id : undefined;
+    const source = 'source' in message && typeof message.source === 'object'
+        ? message.source
+        : undefined;
+    const base = {
+        ...id === undefined ? {} : { id },
+        ...'turn' in message && typeof message.turn === 'number' ? { sourceTurn: message.turn } : {},
+        role: message.role,
+        ...source?.compactionId === undefined ? {} : { compactionId: source.compactionId },
+        sourceKind: source?.kind ?? 'user',
+        ...source?.form === undefined ? {} : { sourceForm: source.form },
+        content,
+    };
+    if (message.role === 'tool') {
+        return {
+            ...base,
+            toolCallId: message.toolCallId,
+            ...message.isError === undefined ? {} : { isError: message.isError },
+        };
+    }
+    return base;
+}
+/** Flatten one typed content block. Unknown block types keep only their tag. */
+function normalizeBlock(block) {
+    switch (block.type) {
+        case 'text':
+        case 'reasoning':
+            return { type: block.type, text: block.text };
+        case 'tool-call':
+            return { type: 'tool-call', id: block.id, name: block.name, arguments: block.arguments };
+        case 'tool-addition':
+        case 'tool-removal':
+            return { type: block.type, toolName: block.toolName };
+        case 'file':
+        case 'image': {
+            const ref = attachmentLabel(block.attachment);
+            return ref === undefined ? { type: block.type } : { type: block.type, ref };
+        }
+        default:
+            return { type: block.type };
+    }
+}
+/** Best-effort display label out of an attachment reference. */
+function attachmentLabel(attachment) {
+    if (typeof attachment !== 'object' || attachment === null)
+        return undefined;
+    const name = attachment.name;
+    return typeof name === 'string' && name.length > 0 ? name : undefined;
+}
+/** Structural read of one log-lane message (untrusted JSON). Returns undefined for unreadable rows. */
+export function fromLogMessage(raw) {
+    if (typeof raw !== 'object' || raw === null)
+        return undefined;
+    const value = raw;
+    const role = value['role'];
+    if (role !== 'system' && role !== 'user' && role !== 'assistant' && role !== 'tool' && role !== 'developer') {
+        return undefined;
+    }
+    const content = Array.isArray(value['content']) ? value['content'].map(readBlock).filter(isDefined) : [];
+    const source = typeof value['source'] === 'object' && value['source'] !== null
+        ? value['source']
+        : undefined;
+    const sourceKind = typeof source?.['kind'] === 'string' ? source['kind'] : role === 'user' ? 'user' : role;
+    return {
+        ...typeof value['id'] === 'string' ? { id: value['id'] } : {},
+        ...typeof value['turn'] === 'number' ? { sourceTurn: value['turn'] } : {},
+        role,
+        sourceKind,
+        ...typeof source?.['compactionId'] === 'string' ? { compactionId: source['compactionId'] } : {},
+        ...typeof source?.['form'] === 'string' ? { sourceForm: source['form'] } : {},
+        content,
+        ...typeof value['toolCallId'] === 'string' ? { toolCallId: value['toolCallId'] } : {},
+        ...value['isError'] === undefined ? {} : { isError: value['isError'] === true },
+    };
+}
+/** Structural read of one log-lane content block. */
+function readBlock(raw) {
+    if (typeof raw !== 'object' || raw === null)
+        return undefined;
+    const value = raw;
+    const type = value['type'];
+    if (typeof type !== 'string')
+        return undefined;
+    return {
+        type,
+        ...typeof value['text'] === 'string' ? { text: value['text'] } : {},
+        ...typeof value['id'] === 'string' ? { id: value['id'] } : {},
+        ...typeof value['name'] === 'string' ? { name: value['name'] } : {},
+        ...typeof value['arguments'] === 'string' ? { arguments: value['arguments'] } : {},
+        ...typeof value['toolName'] === 'string' ? { toolName: value['toolName'] } : {},
+    };
+}
+function isDefined(value) {
+    return value !== undefined;
+}

package/lib/types/prefix-diff.d.ts

@@ -0,0 +1,4 @@
+import type { PrefixTextChange } from './types.ts';
+/** Linear comparison on full text; never infer a change from already-truncated previews. */
+export declare function prefixTextChange(before: string, after: string): PrefixTextChange;
+//# sourceMappingURL=prefix-diff.d.ts.map

package/lib/types/prefix-diff.js

@@ -0,0 +1,20 @@
+/** Linear comparison on full text; never infer a change from already-truncated previews. */
+export function prefixTextChange(before, after) {
+    const a = Array.from(before), b = Array.from(after);
+    let start = 0, end = 0;
+    while (start < a.length && start < b.length && a[start] === b[start])
+        start++;
+    while (end < a.length - start && end < b.length - start && a[a.length - end - 1] === b[b.length - end - 1])
+        end++;
+    return {
+        offset: start,
+        leading: a.slice(Math.max(0, start - 48), start).join(''),
+        trailing: end ? a.slice(a.length - end, a.length - end + 48).join('') : '',
+        leadingOmitted: start > 48,
+        trailingOmitted: end > 48,
+        removed: a.slice(start, Math.min(a.length - end, start + 160)).join(''),
+        added: b.slice(start, Math.min(b.length - end, start + 160)).join(''),
+        removedChars: a.length - start - end,
+        addedChars: b.length - start - end,
+    };
+}

package/lib/types/remote.d.ts

@@ -0,0 +1,45 @@
+import type { SessionTrend } from './types.ts';
+/**
+ * The context-lens Remote: the wire face, and nothing else. Each verb is
+ * a one-line delegation to {@link InspectorService} and returns the BARE domain
+ * value; the wire layer wraps it in the protocol's result envelope, and thrown
+ * `RemoteError`s arrive as that envelope's error branch.
+ *
+ * Namespace `requestInspector`: the browser calls
+ * `remote.requestInspector.listTurns` etc. Pull-based (no subscription): the
+ * panel refetches on open / turn switch; capture is cheap and in-memory.
+ *
+ * @module @khorsheed/dsh-context-lens/remote
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
+import type { CapturedRequest, ListTurnsResult, ScopeFilter, ScopedRefusal, TurnOverview, TurnTiming } from './types.ts';
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        requestInspectorRemote: RequestInspectorRemoteService;
+    }
+}
+/** Reserved for future config-driven knobs; the service owns today's config. */
+export interface RequestInspectorRemoteConfig {
+}
+/** The wire namespace is `requestInspector`. */
+export declare class RequestInspectorRemoteService extends TypertRemoteService<RequestInspectorRemoteConfig> {
+    static inject: string[];
+    constructor(ctx: Context, _config?: RequestInspectorRemoteConfig);
+    /** The service core this face delegates to. */
+    private get core();
+    /** Light turn list of one session plus its backfill watermark, newest last. */
+    listTurns(sessionId: string, filter?: ScopeFilter): Promise<ListTurnsResult>;
+    /** Move the backfill window to the turns ending at `end` (latest when null); answers the new turn list. */
+    loadTurns(sessionId: string, end: number | null, filter?: ScopeFilter): Promise<ListTurnsResult>;
+    /** One turn's scope/request overview — the left column, no segments. */
+    getTurn(sessionId: string, turnSeq: number, filter?: ScopeFilter): Promise<TurnOverview | undefined>;
+    /** One request's full four-segment breakdown — the right column. */
+    getRequest(sessionId: string, seq: number, filter?: ScopeFilter): Promise<CapturedRequest | ScopedRefusal | undefined>;
+    /** Lightweight session map, with no message bodies. */
+    getSessionTrend(sessionId: string, filter?: ScopeFilter): Promise<SessionTrend>;
+    /** One turn's whole-turn timing aggregation — the 耗时分布 tab. */
+    getTurnTiming(sessionId: string, turnSeq: number, filter?: ScopeFilter): Promise<TurnTiming | undefined>;
+}
+export default RequestInspectorRemoteService;
+//# sourceMappingURL=remote.d.ts.map

package/lib/types/remote.js

@@ -0,0 +1,99 @@
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+import { Remote, TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
+/** The wire namespace is `requestInspector`. */
+let RequestInspectorRemoteService = (() => {
+    let _classSuper = TypertRemoteService;
+    let _instanceExtraInitializers = [];
+    let _listTurns_decorators;
+    let _loadTurns_decorators;
+    let _getTurn_decorators;
+    let _getRequest_decorators;
+    let _getSessionTrend_decorators;
+    let _getTurnTiming_decorators;
+    return class RequestInspectorRemoteService extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _listTurns_decorators = [Remote('listTurns')];
+            _loadTurns_decorators = [Remote('loadTurns')];
+            _getTurn_decorators = [Remote('getTurn')];
+            _getRequest_decorators = [Remote('getRequest')];
+            _getSessionTrend_decorators = [Remote('getSessionTrend')];
+            _getTurnTiming_decorators = [Remote('getTurnTiming')];
+            __esDecorate(this, null, _listTurns_decorators, { kind: "method", name: "listTurns", static: false, private: false, access: { has: obj => "listTurns" in obj, get: obj => obj.listTurns }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _loadTurns_decorators, { kind: "method", name: "loadTurns", static: false, private: false, access: { has: obj => "loadTurns" in obj, get: obj => obj.loadTurns }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getTurn_decorators, { kind: "method", name: "getTurn", static: false, private: false, access: { has: obj => "getTurn" in obj, get: obj => obj.getTurn }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getRequest_decorators, { kind: "method", name: "getRequest", static: false, private: false, access: { has: obj => "getRequest" in obj, get: obj => obj.getRequest }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getSessionTrend_decorators, { kind: "method", name: "getSessionTrend", static: false, private: false, access: { has: obj => "getSessionTrend" in obj, get: obj => obj.getSessionTrend }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getTurnTiming_decorators, { kind: "method", name: "getTurnTiming", static: false, private: false, access: { has: obj => "getTurnTiming" in obj, get: obj => obj.getTurnTiming }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        static inject = ['requestInspector'];
+        constructor(ctx, _config = {}) {
+            super(ctx, 'requestInspectorRemote', { namespace: 'requestInspector' });
+            __runInitializers(this, _instanceExtraInitializers);
+        }
+        /** The service core this face delegates to. */
+        get core() {
+            return this.ctx.requestInspector;
+        }
+        /** Light turn list of one session plus its backfill watermark, newest last. */
+        listTurns(sessionId, filter) {
+            return this.core.listTurns(sessionId, filter);
+        }
+        /** Move the backfill window to the turns ending at `end` (latest when null); answers the new turn list. */
+        loadTurns(sessionId, end, filter) {
+            return this.core.loadTurns(sessionId, end, filter);
+        }
+        /** One turn's scope/request overview — the left column, no segments. */
+        getTurn(sessionId, turnSeq, filter) {
+            return this.core.getTurn(sessionId, turnSeq, filter);
+        }
+        /** One request's full four-segment breakdown — the right column. */
+        getRequest(sessionId, seq, filter) {
+            return this.core.getRequest(sessionId, seq, filter);
+        }
+        /** Lightweight session map, with no message bodies. */
+        getSessionTrend(sessionId, filter) {
+            return this.core.getSessionTrend(sessionId, filter);
+        }
+        /** One turn's whole-turn timing aggregation — the 耗时分布 tab. */
+        getTurnTiming(sessionId, turnSeq, filter) {
+            return this.core.getTurnTiming(sessionId, turnSeq, filter);
+        }
+    };
+})();
+export { RequestInspectorRemoteService };
+export default RequestInspectorRemoteService;

package/lib/types/room.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Room rounds. In a room session the main conversation stops running turns
+ * once another member coordinates or a human addresses members directly; the
+ * work then happens in the members' own child sessions, started by the room
+ * plugin's dispatches. This module reads the room plugin's session events
+ * structurally (no dependency on the package; absent events change nothing)
+ * and keeps what the panel needs to show each human dispatch made outside a
+ * main turn as a round of its own, with the member runs it started:
+ *
+ * - `room/member-added` / `room/member-updated`: member id → display name.
+ * - `room/dispatch` with `origin: 'human'`: the message, its time, its targets.
+ * - `room/run-state`: one member run per `runId` (`<dispatchSeq>:<memberId>`),
+ *   its time span, its child session, and — when the producer records it —
+ *   the child turn the run became (`childTurn`).
+ * - `room/coordinator`: coordinator handoffs, drawn on the session map.
+ *
+ * @module @khorsheed/dsh-context-lens/room
+ */
+import type { RoomDecisionRow } from './types.ts';
+/** One member run of a dispatch. */
+export interface RoomRun {
+    runId: string;
+    dispatchSeq: number;
+    memberId: string;
+    member?: string;
+    state?: string;
+    startedAt?: number;
+    endedAt?: number;
+    childSessionId?: string;
+    /** The child session turn this run became, when the producer records it. */
+    childTurn?: number;
+}
+/** One human message to the room. */
+export interface RoomDispatch {
+    seq: number;
+    at: number;
+    text: string;
+    targets: string[];
+}
+/** What one session's room events say, accumulated (log backfill and live alike). */
+export interface RoomState {
+    members: Map<string, string>;
+    dispatches: RoomDispatch[];
+    runs: Map<string, RoomRun>;
+    handoffs: {
+        seq: number;
+        at: number;
+        memberId: string;
+    }[];
+    /** The decision-model calls the room recorded (`room/decision` with a call). */
+    decisions: RoomDecisionRow[];
+    /** Event seqs already applied (backfill and live may both deliver one). */
+    seen: Set<number>;
+}
+export declare function emptyRoom(): RoomState;
+/**
+ * Apply one `room/*` event. Unknown types and malformed payloads are ignored.
+ * @returns whether the event was a room event this module reads.
+ */
+export declare function applyRoomEvent(room: RoomState, type: string, data: unknown, seq: number | undefined, at: number | undefined): boolean;
+/** The runs a dispatch started, in start order. */
+export declare function runsOf(room: RoomState, dispatchSeq: number): RoomRun[];
+/** A synthetic, stable panel address for a room round (far below any purpose bucket). */
+export declare const ROOM_TURN_BASE = -1000000;
+export declare const roomTurnSeq: (dispatchSeq: number) => number;
+//# sourceMappingURL=room.d.ts.map