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

package/lib/types/client/aggregate.js

@@ -0,0 +1,213 @@
+/**
+ * Render one {@link ResponseSummary} for the card title / anchor header:
+ * the tool case groups repeated names as `name ×N` (single calls keep hints), the text case is the
+ * caller's localized assistant reply, the reasoning case is a pure thinking response, an empty
+ * response is the plain dash.
+ */
+export function summaryText(summary, assistantReply, compaction = 'Compaction', thinking = 'Thinking') {
+    switch (summary.kind) {
+        case 'compaction':
+            return compaction;
+        case 'tool':
+            if (summary.toolCounts?.length)
+                return summary.toolCounts.map(tool => `${tool.name}${tool.count > 1 ? ` ×${tool.count}` : ''}`).join(' · ');
+            // Older hosts only expose the first name and a total; never guess repeated tools.
+            return `${summary.name}${summary.hint === undefined ? '' : `:${summary.hint}`}${summary.more === undefined ? '' : ` +${summary.more}`}`;
+        case 'text':
+            return assistantReply;
+        case 'reasoning':
+            return thinking;
+        case 'none':
+            return '—';
+    }
+}
+/**
+ * Resolve an assistant message id to its turn: the turn whose
+ * `closingMessageId` matches, else the latest turn (the list arrives newest
+ * last), else undefined when the session has no captured turns.
+ */
+export function resolveTurnSeq(turns, messageId) {
+    if (turns.length === 0)
+        return undefined;
+    if (messageId !== undefined) {
+        const match = turns.find(turn => turn.closingMessageId === messageId);
+        if (match !== undefined)
+            return match.turnSeq;
+    }
+    return turns[turns.length - 1]?.turnSeq;
+}
+/** The latest turn's seq (the panel's default), undefined on an empty list. */
+export function latestTurnSeq(turns) {
+    return turns[turns.length - 1]?.turnSeq;
+}
+/** Turns per backfill window (the store's default `maxTurnsPerSession`). */
+export const WINDOW_TURNS = 30;
+/** The unloaded runs: the store's (numbered with room rounds), else derived from the log's host-turn range. */
+export function turnGaps(list, turns) {
+    if (list?.unloaded !== undefined)
+        return list.unloaded.map(run => ({ from: run.firstHost, to: run.lastHost, shown: { from: run.from, to: run.to } }));
+    return unloadedGaps(list?.range, turns);
+}
+/** A gap's displayed span. */
+export const gapShown = (gap) => gap.shown ?? gap;
+/** A turn's displayed number: its place in the session's numbering, else its host turn. */
+export const turnNumber = (turn) => turn.ordinal ?? turn.hostTurn;
+/** The runs of turns in the log's range that the loaded list lacks, oldest first. */
+export function unloadedGaps(range, turns) {
+    if (range === undefined)
+        return [];
+    const loaded = new Set(turns.map(turn => turn.hostTurn).filter((n) => n !== undefined));
+    const gaps = [];
+    for (let n = range.first; n <= range.last; n += 1) {
+        if (loaded.has(n))
+            continue;
+        const last = gaps.at(-1);
+        if (last !== undefined && last.to === n - 1)
+            last.to = n;
+        else
+            gaps.push({ from: n, to: n });
+    }
+    return gaps;
+}
+/** Total input = uncached + cache-read + cache-write (the host's usage fields are disjoint). */
+export function inputTotal(usage) {
+    return usage.inputTokens + (usage.cacheReadTokens ?? 0) + (usage.cacheWriteTokens ?? 0);
+}
+/** Input NOT served from cache = uncached + cache-write (a cache write was processed in full too). */
+export function inputMiss(usage) {
+    return usage.inputTokens + (usage.cacheWriteTokens ?? 0);
+}
+/** Cache-hit percentage of the total input, one decimal; null when nothing was read. */
+export function cachePct(usage) {
+    const total = inputTotal(usage);
+    // A provider that does not report cache reads: unknown, not 0%.
+    if (total === 0 || usage.cacheReadTokens === undefined)
+        return null;
+    return Math.round(((usage.cacheReadTokens ?? 0) / total) * 1000) / 10;
+}
+/**
+ * One request's composition by category: the system/history/added message
+ * items plus the tools segment as `tool-definition`, sorted by chars desc.
+ */
+export function aggregateCategories(request) {
+    const byCategory = new Map();
+    const add = (category, chars) => {
+        const entry = byCategory.get(category) ?? { category, count: 0, chars: 0 };
+        entry.count += 1;
+        entry.chars += chars;
+        byCategory.set(category, entry);
+    };
+    for (const item of [...request.segments.system, ...request.segments.history, ...request.segments.added]) {
+        add(item.category, item.chars);
+    }
+    for (const tool of request.segments.tools)
+        add('tool-definition', tool.chars);
+    return [...byCategory.values()].sort((a, b) => b.chars - a.chars);
+}
+/** The timing vocabulary, in timeline order (the design's six-way split). */
+export const TIMING_KINDS = ['wait', 'reasoning', 'tool-args', 'text', 'tool-exec', 'other'];
+const ZERO_KINDS = () => ({
+    wait: 0, reasoning: 0, 'tool-args': 0, text: 0, 'tool-exec': 0, other: 0,
+});
+/**
+ * Reduce the turn's lanes to the timing tab's data. Lanes are strictly
+ * ordered and carry their scope, so a scope filter is exact; gaps between
+ * lanes (inter-request overhead) fold into `other`, the reference design's
+ * 调用间隙并入其他开销. Whole-turn, the bucket sums equal the host's
+ * `TurnTiming.buckets` by construction (the host sums the same lanes).
+ */
+export function summarizeLanes(lanes, scopeId) {
+    const filtered = (scopeId === undefined ? lanes : lanes.filter(lane => lane.scopeId === scopeId))
+        .slice()
+        .sort((a, b) => a.startedAt - b.startedAt || a.requestSeq - b.requestSeq);
+    const buckets = ZERO_KINDS();
+    const counts = ZERO_KINDS();
+    const tools = new Map();
+    const requests = new Map();
+    let t0 = 0;
+    let t1 = 0;
+    let cursor;
+    for (const lane of filtered) {
+        const end = lane.startedAt + lane.durationMs;
+        if (cursor === undefined) {
+            t0 = lane.startedAt;
+        }
+        else if (lane.startedAt > cursor) {
+            // The inter-lane gap is turn overhead the host never lane-tags.
+            buckets.other += lane.startedAt - cursor;
+        }
+        cursor = cursor === undefined ? end : Math.max(cursor, end);
+        t1 = Math.max(t1, end);
+        buckets[lane.kind] += lane.durationMs;
+        counts[lane.kind] += 1;
+        if (lane.tool !== undefined) {
+            const aggregate = tools.get(lane.tool) ?? { tool: lane.tool, calls: 0, argsMs: 0, execMs: 0 };
+            if (lane.kind === 'tool-exec') {
+                aggregate.calls += 1;
+                aggregate.execMs += lane.durationMs;
+            }
+            else if (lane.kind === 'tool-args') {
+                aggregate.argsMs += lane.durationMs;
+            }
+            tools.set(lane.tool, aggregate);
+        }
+        const request = requests.get(lane.requestSeq) ?? {
+            requestSeq: lane.requestSeq, scopeId: lane.scopeId,
+            startedAt: lane.startedAt, endedAt: end, byKind: ZERO_KINDS(),
+        };
+        request.startedAt = Math.min(request.startedAt, lane.startedAt);
+        request.endedAt = Math.max(request.endedAt, end);
+        request.byKind[lane.kind] += lane.durationMs;
+        requests.set(lane.requestSeq, request);
+    }
+    return {
+        buckets,
+        counts,
+        t0,
+        t1,
+        tools: [...tools.values()].sort((a, b) => b.execMs - a.execMs),
+        requests: [...requests.values()].sort((a, b) => a.startedAt - b.startedAt || a.requestSeq - b.requestSeq),
+    };
+}
+/** Thousands-separated integer (the design's fmt). */
+export function fmt(n) {
+    return n.toLocaleString('en-US');
+}
+/** Compact count: 12.3k over a thousand (the design's fmtK). */
+export function fmtK(n) {
+    return n >= 1000 ? `${(n / 1000).toFixed(1)}k` : String(n);
+}
+/** Wall-clock HH:MM of a timestamp (the timeline scale). */
+export function fmtClock(timestamp) {
+    const date = new Date(timestamp);
+    const pad = (value) => String(value).padStart(2, '0');
+    return `${pad(date.getHours())}:${pad(date.getMinutes())}`;
+}
+/** Row-level duration: milliseconds under a second, whole seconds above (the design's fmtDur). */
+export function fmtDur(ms) {
+    return fmtSpan(ms);
+}
+/** Span duration: one decimal in seconds, minutes above 60s (the design's ms()). */
+export function fmtSpan(ms) {
+    return ms >= 60000
+        ? `${Math.floor(Math.round(ms / 100) / 600)}m ${(Math.round(ms / 100) % 600 / 10).toFixed(1)}s`
+        : `${(ms / 1000).toFixed(1)}s`;
+}
+/** Exact full-text matches, excluding the first occurrence from excess size. */
+export function duplicateStats(items) {
+    const counts = new Map();
+    let extraChars = 0;
+    for (const item of items) {
+        if (item.full.length < 40)
+            continue;
+        const count = counts.get(item.full) ?? 0;
+        if (count > 0)
+            extraChars += item.chars;
+        counts.set(item.full, count + 1);
+    }
+    return { counts, extraChars };
+}
+/** Public ordinal only. The internal seq must never be a display fallback. */
+export function requestNumberText(request) {
+    return request?.requestNumber === undefined ? '—' : String(request.requestNumber);
+}

package/lib/types/client/contract.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Slot-facing types of the context-lens client half: the injected faces
+ * and the composed props of its three entries — the right-Sidebar page tab
+ * (`sidebar.right.pane.tab`), the per-turn icon in the assistant message's
+ * action row (`conversation.chat.assistant-actions`), and the session-header
+ * utility (`conversation.session.header.utilities`).
+ */
+import type { SessionId } from '@deepseek-ai/dsh-api-remotes/client';
+import type { InjectFace, PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+import type { RemoteResult, TypertRemoteNamespaceMap } from '@deepseek-ai/dsh-typert-protocol';
+import type { SessionTrend, CapturedRequest, ListTurnsResult, ScopedRefusal, TurnOverview, TurnTiming } from '../types.ts';
+/** The requestInspector Remote namespace (as mounted by this plugin). */
+export type InspectorRemote = TypertRemoteNamespaceMap['requestInspector'];
+/** Business face injected into the right-Sidebar tab body. */
+export interface InspectorTabInjected {
+    getSessionTrend?: (sessionId: SessionId) => Promise<RemoteResult<SessionTrend>>;
+    /** Light turn list of one session plus its backfill watermark, newest last. */
+    listTurns: (sessionId: SessionId) => Promise<RemoteResult<ListTurnsResult>>;
+    /**
+     * Page the chat's loaded history back until it covers log `seq` (the
+     * session's own jump loader, the one message-timeline uses). Absent on a
+     * host without a session binding; a jump then only scrolls what is loaded.
+     */
+    loadThrough?: (sessionId: SessionId, seq: number) => Promise<void>;
+    /** Move the loaded window to the turns ending at `end` (latest when null); answers the new list. */
+    loadTurns?: (sessionId: SessionId, end: number | null) => Promise<RemoteResult<ListTurnsResult>>;
+    /** One turn's scope/request overview — the left column, no segments. */
+    getTurn: (sessionId: SessionId, turnSeq: number) => Promise<RemoteResult<TurnOverview | undefined>>;
+    /**
+     * One request's full four-segment breakdown — the right column. The
+     * {@link ScopedRefusal} half only answers a query that carried a scope
+     * filter; the panel never sends one and narrows it away at the call site.
+     */
+    getRequest: (sessionId: SessionId, seq: number) => Promise<RemoteResult<CapturedRequest | ScopedRefusal | undefined>>;
+    /** One turn's whole-turn timing aggregation — the 耗时分布 tab. */
+    getTurnTiming: (sessionId: SessionId, turnSeq: number) => Promise<RemoteResult<TurnTiming | undefined>>;
+}
+/** Full props of the right-Sidebar tab body entry. */
+export type InspectorTabProps = PropsRuntime<'sidebar.right.pane.tab'> & InjectFace<InspectorTabInjected> & PropsLocale<'requestInspector'>;
+/**
+ * Business face injected into the assistant message's turn action: resolve
+ * the message's turn (`TurnListItem.closingMessageId`, latest-turn fallback)
+ * and open the inspector tab on it.
+ */
+export interface InspectorActionInjected {
+    /** Resolve `messageId`'s turn and open the tab there. Never throws. */
+    open: (sessionId: SessionId, messageId: string) => Promise<void>;
+}
+/** Full props of the assistant-message turn action entry. */
+export type InspectorActionProps = PropsRuntime<'conversation.chat.assistant-actions'> & InjectFace<InspectorActionInjected> & PropsLocale<'requestInspector'>;
+/** Business face injected into the session-header utility: open the tab at the latest turn. */
+export interface InspectorUtilityInjected {
+    /** Open the inspector tab at the session's latest turn. Never throws. */
+    openLatest: (sessionId: SessionId) => void;
+}
+/** Full props of the session-header utility entry. */
+export type InspectorUtilityProps = PropsRuntime<'conversation.session.header.utilities'> & InjectFace<InspectorUtilityInjected> & PropsLocale<'requestInspector'>;
+//# sourceMappingURL=contract.d.ts.map

package/lib/types/client/contract.js

@@ -0,0 +1 @@
+export {};

package/lib/types/client/definition.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Stage one of this package's right-Sidebar registration: what the
+ * `context-lens` tab type IS.
+ *
+ * The type is a page, not a viewer: it claims no address and is opened by
+ * kind — by the session-header utility, by the assistant message's turn
+ * action, or from the guide — through `ctx.sidebarRight.openTab(
+ * 'context-lens', { params: { turnSeq } })`. Pages deduplicate within a
+ * pane, so a repeat open re-navigates the one tab and the body follows
+ * `navigation.params`.
+ *
+ * @module @khorsheed/dsh-context-lens/client
+ */
+import type { SidebarRightTabDefinition } from '@deepseek-ai/dsh-client-ui-sidebar-right/client';
+import type { TranslateNS } from '@deepseek-ai/dsh-client-locale/client';
+/** The tab kind this package owns. */
+export declare const REQUEST_INSPECTOR_KIND = "context-lens";
+/** This implementation's identity in the tab system, and the key its body registers under. */
+export declare const REQUEST_INSPECTOR_TAB_ID = "@khorsheed/dsh-context-lens";
+/** Navigation params an `openTab` caller hands the tab: which turn to show. */
+export interface RequestInspectorTabParams {
+    /** 1-based per-session turn number; absent = the latest turn. */
+    readonly turnSeq?: number;
+    /**
+     * Inspect ANOTHER session than the one the sidebar belongs to (a room
+     * member's child session); `messageId` picks the turn that message closed.
+     * The next navigation without a session returns to the sidebar's own.
+     */
+    readonly sessionId?: string;
+    readonly messageId?: string;
+    /** A room decision (`room/decision` id): opens the turn holding it on the 房间 tab, that call selected. */
+    readonly roomDecision?: string;
+}
+declare module '@deepseek-ai/dsh-client-ui-sidebar-right/client' {
+    interface SidebarRightTabParamsMap {
+        /** The context-lens page's initial turn. */
+        'context-lens': RequestInspectorTabParams;
+    }
+}
+/**
+ * The type's registry definition. No `priority`: the default `extension` band
+ * is exactly what a type shipped from outside the product is.
+ * @param t - namespace-bound translate, read fresh on every label call.
+ * @returns the definition to register.
+ */
+export declare function requestInspectorDefinition(t: TranslateNS<'requestInspector'>): SidebarRightTabDefinition;
+//# sourceMappingURL=definition.d.ts.map

package/lib/types/client/definition.js

@@ -0,0 +1,25 @@
+import { IconRequestInspectorOutlineMedium } from "./icons-local.js";
+/** The tab kind this package owns. */
+export const REQUEST_INSPECTOR_KIND = 'context-lens';
+/** This implementation's identity in the tab system, and the key its body registers under. */
+export const REQUEST_INSPECTOR_TAB_ID = '@khorsheed/dsh-context-lens';
+/**
+ * The type's registry definition. No `priority`: the default `extension` band
+ * is exactly what a type shipped from outside the product is.
+ * @param t - namespace-bound translate, read fresh on every label call.
+ * @returns the definition to register.
+ */
+export function requestInspectorDefinition(t) {
+    return {
+        id: REQUEST_INSPECTOR_TAB_ID,
+        kind: REQUEST_INSPECTOR_KIND,
+        title: () => t('tab.title'),
+        guide: [{
+                id: REQUEST_INSPECTOR_KIND,
+                order: 60,
+                title: () => t('tab.title'),
+                description: () => t('guide.description'),
+                icon: IconRequestInspectorOutlineMedium,
+            }],
+    };
+}

package/lib/types/client/icons-local.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Package-owned icons for glyphs ui-primitives does not ship — the canvas /
+ * message-tools supplement pattern; upstream glyphs come from the generated
+ * icons.tsx (scripts/sync-icon-artwork.mts), which never touches this file.
+ * The context-lens glyph is a stacked-list sheet with a probe dot — the
+ * four-segment breakdown read at a glance.
+ *
+ * @module @khorsheed/dsh-context-lens/client
+ */
+/** Shared props for every product icon component (mirrors the upstream IconProps). */
+export interface IconProps {
+    /** Square edge in px; defaults to the glyph's own drawn size. */
+    size?: number | undefined;
+    /** Extra class for layout placement; color rides currentColor. */
+    className?: string | undefined;
+}
+/** The context-lens glyph: a stacked breakdown sheet. */
+export declare const IconRequestInspectorOutlineMedium: ({ size, className }: IconProps) => import("react").JSX.Element;
+//# sourceMappingURL=icons-local.d.ts.map

package/lib/types/client/icons-local.js

@@ -0,0 +1,3 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/** The context-lens glyph: a stacked breakdown sheet. */
+export const IconRequestInspectorOutlineMedium = ({ size = 16, className }) => (_jsxs("svg", { width: size, height: size, className: className, viewBox: "0 0 16 16", fill: "none", xmlns: "http://www.w3.org/2000/svg", "aria-hidden": "true", strokeWidth: 1.2, children: [_jsx("rect", { x: "2.5", y: "1.5", width: "11", height: "13", rx: "2", stroke: "currentColor" }), _jsx("path", { d: "M5 5.2H11", stroke: "currentColor" }), _jsx("path", { d: "M5 8H11", stroke: "currentColor" }), _jsx("path", { d: "M5 10.8H8.6", stroke: "currentColor" }), _jsx("circle", { cx: "11.2", cy: "11.2", r: "1.7", fill: "currentColor", stroke: "none" })] }));

package/lib/types/client/icons.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Generated by scripts/sync-icon-artwork.mts from @deepseek-ai/dsh-client-ui-primitives
+ * (v0.2.1-rc.1, harness 1600d8a1e1) — do not edit by hand. The 0.1.5 and rc.1 host lines
+ * share no icon export name, so the rc.1 artwork is inlined here: pure SVG,
+ * no host runtime identity, identical on every line. Re-run the generator
+ * after adding an icon import or bumping the harness checkout.
+ *
+ * @module @khorsheed/dsh-context-lens/client
+ */
+/** Shared props for every product icon component (mirrors the upstream IconProps). */
+export interface IconProps {
+    /** Square edge in px; defaults to the glyph's own drawn size. */
+    size?: number | undefined;
+    /** Extra class for layout placement; color rides currentColor. */
+    className?: string | undefined;
+}
+export declare const IconChevronDownOutlineMedium: ({ size, className }: IconProps) => import("react").JSX.Element;
+//# sourceMappingURL=icons.d.ts.map

package/lib/types/client/icons.js

@@ -0,0 +1,2 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+export const IconChevronDownOutlineMedium = ({ size = 14, className }) => (_jsx("svg", { width: size, height: size, className: className, viewBox: "0 0 16 16", fill: "none", xmlns: "http://www.w3.org/2000/svg", "aria-hidden": "true", strokeWidth: 1.3, children: _jsx("path", { d: "M4 6L7.29289 9.29289C7.68342 9.68342 8.31658 9.68342 8.70711 9.29289L12 6", stroke: "currentColor" }) }));

package/lib/types/client/index.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Request-inspector, browser half: mounts this package's generated Remote
+ * contribution so `remote.requestInspector` exists, then surfaces the panel —
+ * the `context-lens` right-Sidebar page tab (the official two-stage path:
+ * the type into `ctx.sidebarRightTabs`, the body into the keyed seat under the
+ * type's id), the per-turn icon in the assistant message's action row
+ * (`conversation.chat.assistant-actions`), and the session-header utility
+ * (`conversation.session.header.utilities`). All three registrations ride
+ * registration-level toggles on the preset-visibility criterion (the package's
+ * own row, root-mounted by its bundle patch, grants every session; a
+ * preset-mounted row grants that preset's sessions); every unreadable path
+ * fails open.
+ *
+ * @module @khorsheed/dsh-context-lens/client
+ */
+import type { Context } from '@deepseek-ai/cordis';
+export { InspectorPanel } from './InspectorPanel.tsx';
+export { TokenView } from './TokenView.tsx';
+export { TimingView } from './TimingView.tsx';
+export { SegmentBlocks, OutputBlock } from './SegmentBlocks.tsx';
+export { RawView } from './RawView.tsx';
+export { SegCtl } from './SegCtl.tsx';
+export { TurnMenu, turnTitle } from './TurnMenu.tsx';
+export { TurnInspectAction } from './TurnAction.tsx';
+export { HeaderInspectUtility } from './HeaderUtility.tsx';
+export { scrollConversationToTurn, scrollConversationToBottom, preferredScrollBehavior, } from './scroll-sync.ts';
+export { REQUEST_INSPECTOR_KIND, REQUEST_INSPECTOR_TAB_ID, requestInspectorDefinition } from './definition.tsx';
+export type { RequestInspectorTabParams } from './definition.tsx';
+export { InspectorTabVisibility, RegistrationToggle, REQUEST_INSPECTOR_ROW_MODULE, } from './preset-visibility.ts';
+export type { InspectorPluginInventorySnapshot } from './preset-visibility.ts';
+export { resolveTurnSeq, latestTurnSeq, aggregateCategories, summarizeLanes } from './aggregate.ts';
+export type { InspectorRemote, InspectorTabInjected, InspectorTabProps, InspectorActionInjected, InspectorActionProps, InspectorUtilityInjected, InspectorUtilityProps, } from './contract.ts';
+/** Required services: slots, the remote channel, the locale, the session list (the visibility criterion), and the right-Sidebar faces. */
+export declare const inject: string[];
+/**
+ * Client plugin body: mount the Remote, register the dictionaries, then the
+ * tab type (toggled on the visibility criterion), its body, and the two entry
+ * points.
+ * @param ctx - client root context.
+ */
+export declare function apply(ctx: Context): Promise<() => Promise<void>>;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/client/index.js

@@ -0,0 +1,139 @@
+import requestInspectorRemote from '@khorsheed/dsh-context-lens/remote';
+import { resolveTurnSeq } from "./aggregate.js";
+import { inspectorWire } from "./wire.js";
+import { REQUEST_INSPECTOR_KIND, REQUEST_INSPECTOR_TAB_ID, requestInspectorDefinition } from "./definition.js";
+import { HeaderInspectUtility } from "./HeaderUtility.js";
+import { InspectorPanel } from "./InspectorPanel.js";
+import { en, NS, zh } from "./locales.js";
+import { InspectorTabVisibility, RegistrationToggle, } from "./preset-visibility.js";
+import { TurnInspectAction } from "./TurnAction.js";
+export { InspectorPanel } from "./InspectorPanel.js";
+export { TokenView } from "./TokenView.js";
+export { TimingView } from "./TimingView.js";
+export { SegmentBlocks, OutputBlock } from "./SegmentBlocks.js";
+export { RawView } from "./RawView.js";
+export { SegCtl } from "./SegCtl.js";
+export { TurnMenu, turnTitle } from "./TurnMenu.js";
+export { TurnInspectAction } from "./TurnAction.js";
+export { HeaderInspectUtility } from "./HeaderUtility.js";
+export { scrollConversationToTurn, scrollConversationToBottom, preferredScrollBehavior, } from "./scroll-sync.js";
+export { REQUEST_INSPECTOR_KIND, REQUEST_INSPECTOR_TAB_ID, requestInspectorDefinition } from "./definition.js";
+export { InspectorTabVisibility, RegistrationToggle, REQUEST_INSPECTOR_ROW_MODULE, } from "./preset-visibility.js";
+export { resolveTurnSeq, latestTurnSeq, aggregateCategories, summarizeLanes } from "./aggregate.js";
+function mainSessionId(list) {
+    const view = list;
+    return Object.values(view.byId).find(s => (s.retainedBy?.mainView ?? 0) > 0)?.id ?? view.current;
+}
+/** Required services: slots, the remote channel, the locale, the session list (the visibility criterion), and the right-Sidebar faces. */
+export const inject = ['slots', 'remote', 'locale', 'sessions', 'sidebarRight', 'sidebarRightTabs'];
+/**
+ * Client plugin body: mount the Remote, register the dictionaries, then the
+ * tab type (toggled on the visibility criterion), its body, and the two entry
+ * points.
+ * @param ctx - client root context.
+ */
+export async function apply(ctx) {
+    const disposers = [];
+    try {
+        disposers.push(await ctx.remote.$mount(requestInspectorRemote));
+    }
+    catch (error) {
+        // A duplicate mount (two compositions) fails loud here but breaks nothing
+        // else: the namespace exists once, which is all callers probe.
+        /* v8 ignore next -- double-mount is a composition error, not a runtime path */
+        ctx.logger.error(error);
+    }
+    ctx.effect(() => ctx.locale.register(NS, { zh, en }), 'context-lens: dictionaries');
+    const t = ctx.locale.bind(NS);
+    // Read lazily: a composition without the host half yields RPC errors on the
+    // verbs, which the panel surfaces as its error state — never a boot failure.
+    // All wire calls route through `inspectorWire`: the gateway runtime enforces
+    // each verb's declared parameter count EXACTLY (a trailing optional param
+    // counts), so the trailing filter arg is always passed explicitly.
+    const remote = () => ctx.get('remote.requestInspector');
+    const wire = () => inspectorWire(remote());
+    const tabFace = () => ({
+        ...wire(),
+        loadThrough: async (sessionId, seq) => {
+            const binding = ctx.sessions.binding(sessionId);
+            if (binding !== undefined)
+                await binding.session.loadThrough(seq);
+        },
+    });
+    /** Open the inspector tab; a kind hidden by the criterion throws, degrade to a log. */
+    const openTab = (turnSeq) => {
+        try {
+            ctx.sidebarRight.openTab(REQUEST_INSPECTOR_KIND, turnSeq === undefined ? undefined : { params: { turnSeq } });
+        }
+        catch (error) {
+            ctx.logger.warn('context-lens: openTab failed (tab type not registered?)', error);
+        }
+    };
+    /** The turn action's resolve-and-open: closingMessageId match, latest-turn fallback. */
+    const openForMessage = async (sessionId, messageId) => {
+        let turnSeq;
+        try {
+            const result = await wire().listTurns(sessionId);
+            if (result.ok)
+                turnSeq = resolveTurnSeq(result.value.turns, messageId);
+        }
+        catch {
+            // A dead namespace still opens the tab (its own error state reports it).
+        }
+        openTab(turnSeq);
+    };
+    const openLatest = (sessionId) => {
+        void openForMessage(sessionId);
+    };
+    // The OFFICIAL pluginInventory namespace, probed the canvas way: through
+    // ctx.get, never injected — a host without it must fail the criterion OPEN.
+    const pluginInventory = ctx.get('remote.pluginInventory');
+    const visibility = new InspectorTabVisibility(ctx, pluginInventory);
+    // The tab type and the two entries register exactly while the current
+    // session's criterion passes (hidden means NOT registered; an opened tab of
+    // an unregistered kind renders the host's designed tab.unavailable fallback).
+    ctx.effect(() => {
+        const toggles = [
+            new RegistrationToggle(() => ctx.sidebarRightTabs.register(requestInspectorDefinition(t)), () => visibility.show(mainSessionId(ctx.sessions.list.getSnapshot()))),
+            new RegistrationToggle(() => ctx.slots.inject('conversation.chat.assistant-actions', () => ctx.slots.register({
+                name: 'conversation.chat.assistant-actions',
+                id: 'context-lens-turn',
+                // After the official actions and the sidechat quote (order 20).
+                order: 30,
+                locale: NS,
+                inject: () => ({ open: openForMessage }),
+            }, TurnInspectAction)), () => visibility.show(mainSessionId(ctx.sessions.list.getSnapshot()))),
+            new RegistrationToggle(() => ctx.slots.inject('conversation.session.header.utilities', () => ctx.slots.register({
+                name: 'conversation.session.header.utilities',
+                id: 'context-lens-header',
+                // After the official entries and the worktrees badge (order -20).
+                order: 40,
+                locale: NS,
+                inject: () => ({ openLatest }),
+            }, HeaderInspectUtility)), () => visibility.show(mainSessionId(ctx.sessions.list.getSnapshot()))),
+        ];
+        for (const toggle of toggles)
+            toggle.setReady(true);
+        const unsubscribe = visibility.subscribe(() => {
+            for (const toggle of toggles)
+                toggle.sync();
+        });
+        return () => {
+            unsubscribe();
+            for (const toggle of toggles)
+                toggle.setReady(false);
+        };
+    }, 'context-lens: surface visibility');
+    // Stage two: the body under the type's id in the keyed pane seat. The body
+    // registers unconditionally — an opened tab of a hidden type renders the
+    // host's tab.unavailable without ever mounting this component.
+    ctx.effect(() => ctx.slots.inject('sidebar.right.pane.tab', () => ctx.slots.register({
+        name: 'sidebar.right.pane.tab',
+        key: REQUEST_INSPECTOR_TAB_ID,
+        locale: NS,
+        inject: tabFace,
+    }, InspectorPanel)), 'context-lens: tab body');
+    return async () => {
+        await Promise.all(disposers.map(dispose => dispose()));
+    };
+}