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

package/lib/types/changes.d.ts

@@ -0,0 +1,72 @@
+import type { RequestChange, SegmentItem, ToolChange, ToolDefItem } from './types.ts';
+/** One surface replacement as the host logged it. */
+export interface ReplacementFact {
+    /** The replacing message's id (a prune keeps the shadowed id). */
+    newId: string;
+    /** Ids of the shadowed surface messages, in surface order. */
+    replacedIds: string[];
+    kind: 'replace' | 'compaction' | 'prune';
+    /** The replacing message's producer, verbatim. */
+    sourceKind: string;
+    sourceOp?: string;
+    /** Host log seq of the replacement event and of what it shadowed. */
+    eventSeq?: number;
+    replacedSeqs?: number[];
+    compactionId?: string;
+}
+/** Structural minimum of one session event / log row this module reads. */
+export interface ReplacementRow {
+    type: string;
+    seq?: number;
+    data?: unknown;
+    surfaceOp?: unknown;
+    sourceEventSeqs?: readonly number[];
+}
+/** The metering event a replacement immediately follows, when any. */
+export interface PendingMeter {
+    kind: 'compaction' | 'prune';
+    compactionId?: string;
+}
+/** Read the meter a `compaction/*` row announces for the next replacement. */
+export declare function meterOf(row: ReplacementRow): PendingMeter | undefined;
+/** The message a surface event carries: `data.message` for step events, `data` itself for user messages. */
+export declare function messageOfRow(row: ReplacementRow): {
+    id?: string;
+    source?: Record<string, unknown>;
+} | undefined;
+/**
+ * The fact one replacement row records, or undefined for appends and rows
+ * whose ids cannot be read.
+ * @param idAt - resolve a shadowed log seq to its message id.
+ * @param meter - the metering row immediately before this one, if any.
+ */
+export declare function replacementFact(row: ReplacementRow, idAt: (seq: number) => string | undefined, meter?: PendingMeter): ReplacementFact | undefined;
+/** Every replacement fact of one whole log (the backfill path). */
+export declare function replacementFactsOf(rows: readonly ReplacementRow[]): ReplacementFact[];
+/** Fact lookup the diff needs; the store's bounded registry implements it. */
+export interface FactLookup {
+    byNewId(id: string): ReplacementFact | undefined;
+    byReplacedId(id: string): ReplacementFact | undefined;
+}
+/** The comparable face of one request. */
+export interface RequestFace {
+    rows: readonly SegmentItem[];
+    tools: readonly ToolDefItem[];
+}
+/** Result of {@link diffRequests}. */
+export interface RequestChanges {
+    changes: RequestChange[];
+    tools: ToolChange[];
+    tail?: {
+        count: number;
+        sources: string[];
+    };
+}
+/**
+ * Diff two consecutive requests.
+ * @param breakIndex - the message index where the exact prefix comparison first differs, if it does.
+ */
+export declare function diffRequests(previous: RequestFace, current: RequestFace, facts: FactLookup, breakIndex?: number): RequestChanges;
+/** Tool definitions pair by name; description and parameters diff separately. */
+export declare function diffTools(previous: readonly ToolDefItem[], current: readonly ToolDefItem[]): ToolChange[];
+//# sourceMappingURL=changes.d.ts.map

package/lib/types/changes.js

@@ -0,0 +1,328 @@
+/**
+ * The change list between two consecutive requests of one scope. Every entry
+ * is a fact the host recorded or an exact comparison — never an inference:
+ *
+ * - Messages pair by durable id (content hash for id-less ones): ids only in
+ *   the previous request were removed, ids only in the current one were added,
+ *   a shared id whose text differs was rewritten in place.
+ * - A surface replacement event (`surfaceOp: replace`) names the ids it
+ *   shadowed and the id it put in their place; that pairing — and its
+ *   producer's `kind · op` — comes from the {@link ReplacementFact} registry,
+ *   fed by the live `session/event` lane and by log backfill alike. The
+ *   metering event the host appends right before a replacement
+ *   (`compaction/summary`, `compaction/prune`) types it as a compaction or a
+ *   prune. Without a fact the same rows stay an honest remove + add.
+ * - System rows group into one entry (the user's question is "did the system
+ *   prompt change"), diffed head against head, with a checkable equality when
+ *   the new head repeats a removed in-history system update verbatim.
+ * - Unexplained additions after the last kept row are the ordinary tail
+ *   append, summarized rather than listed.
+ *
+ * @module @khorsheed/dsh-context-lens/changes
+ */
+import { prefixTextChange } from "./prefix-diff.js";
+/** Read the meter a `compaction/*` row announces for the next replacement. */
+export function meterOf(row) {
+    if (row.type === 'compaction/prune')
+        return { kind: 'prune' };
+    if (row.type !== 'compaction/summary')
+        return undefined;
+    const id = record(row.data)?.['compactionId'];
+    return { kind: 'compaction', ...typeof id === 'string' ? { compactionId: id } : {} };
+}
+function record(value) {
+    return typeof value === 'object' && value !== null ? value : undefined;
+}
+/** The message a surface event carries: `data.message` for step events, `data` itself for user messages. */
+export function messageOfRow(row) {
+    const data = record(row.data);
+    if (data === undefined)
+        return undefined;
+    const message = record(data['message']) ?? data;
+    const id = message['id'];
+    const source = record(message['source']);
+    return { ...typeof id === 'string' ? { id } : {}, ...source === undefined ? {} : { source } };
+}
+/**
+ * The fact one replacement row records, or undefined for appends and rows
+ * whose ids cannot be read.
+ * @param idAt - resolve a shadowed log seq to its message id.
+ * @param meter - the metering row immediately before this one, if any.
+ */
+export function replacementFact(row, idAt, meter) {
+    const op = record(row.surfaceOp);
+    if (op === undefined || op['op'] !== 'replace')
+        return undefined;
+    const message = messageOfRow(row);
+    if (message?.id === undefined)
+        return undefined;
+    const seqs = row.sourceEventSeqs !== undefined && row.sourceEventSeqs.length > 0
+        ? [...row.sourceEventSeqs]
+        : typeof op['startSeq'] === 'number' && typeof op['endSeq'] === 'number' && op['endSeq'] >= op['startSeq']
+            ? Array.from({ length: op['endSeq'] - op['startSeq'] + 1 }, (_, i) => op['startSeq'] + i)
+            : [];
+    const replacedIds = seqs.map(idAt).filter((id) => id !== undefined);
+    const sourceKind = typeof message.source?.['kind'] === 'string' ? message.source['kind'] : row.type;
+    const sourceOp = typeof message.source?.['op'] === 'string' ? message.source['op'] : undefined;
+    const compactionId = typeof message.source?.['compactionId'] === 'string' ? message.source['compactionId'] : meter?.compactionId;
+    const kind = meter?.kind ?? (compactionId !== undefined ? 'compaction' : 'replace');
+    return {
+        newId: message.id,
+        replacedIds,
+        kind,
+        sourceKind,
+        ...sourceOp === undefined ? {} : { sourceOp },
+        ...row.seq === undefined ? {} : { eventSeq: row.seq },
+        ...seqs.length === 0 ? {} : { replacedSeqs: seqs },
+        ...kind === 'compaction' && compactionId !== undefined ? { compactionId } : {},
+    };
+}
+/** Every replacement fact of one whole log (the backfill path). */
+export function replacementFactsOf(rows) {
+    const ids = new Map();
+    const facts = [];
+    let meter;
+    for (const row of rows) {
+        const fact = replacementFact(row, seq => ids.get(seq), meter);
+        if (fact !== undefined)
+            facts.push(fact);
+        const id = messageOfRow(row)?.id;
+        if (row.seq !== undefined && id !== undefined)
+            ids.set(row.seq, id);
+        meter = meterOf(row);
+    }
+    return facts;
+}
+function messagesOf(rows) {
+    const byIndex = new Map();
+    for (const row of rows)
+        byIndex.set(row.index, [...byIndex.get(row.index) ?? [], row]);
+    const seen = new Map();
+    return [...byIndex.entries()].sort((a, b) => a[0] - b[0]).map(([index, parts]) => {
+        const first = parts[0];
+        const sectioned = parts.length > 1;
+        const sections = [];
+        let cursor = 0;
+        for (const part of parts) {
+            sections.push({ name: part.source, start: cursor, end: cursor + Array.from(part.full).length });
+            cursor += Array.from(part.full).length + 2;
+        }
+        const text = parts.map(part => part.full).join('\n\n');
+        const id = parts.find(part => part.messageId !== undefined)?.messageId;
+        const base = id === undefined ? `h:${first.category}:${text.length}:${hashText(text)}` : `id:${id}`;
+        const n = seen.get(base) ?? 0;
+        seen.set(base, n + 1);
+        return {
+            index,
+            key: n === 0 ? base : `${base}#${n}`,
+            ...id === undefined ? {} : { id },
+            category: first.category,
+            source: first.category === 'system' && sectioned ? 'system-prompt' : first.source,
+            text,
+            sections: sectioned ? sections : [],
+        };
+    });
+}
+function hashText(text) {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < text.length; i += 1) {
+        hash ^= text.charCodeAt(i);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return (hash >>> 0).toString(36);
+}
+function rowOf(message) {
+    return {
+        index: message.index,
+        ...message.id === undefined ? {} : { messageId: message.id },
+        category: message.category,
+        source: message.source,
+        preview: message.text.replace(/\s+/g, ' ').trim().slice(0, 120),
+        chars: Array.from(message.text).length,
+    };
+}
+function sectionAt(message, offset) {
+    return message.sections.find(section => offset >= section.start && offset <= section.end)?.name;
+}
+/** Contiguous runs (by index) of rows; system and non-system rows never share a run. */
+function runs(messages) {
+    const out = [];
+    for (const message of messages) {
+        const last = out[out.length - 1];
+        const tail = last?.[last.length - 1];
+        if (last !== undefined && tail !== undefined && message.index === tail.index + 1 && (message.category === 'system') === (tail.category === 'system'))
+            last.push(message);
+        else
+            out.push([message]);
+    }
+    return out;
+}
+/**
+ * Diff two consecutive requests.
+ * @param breakIndex - the message index where the exact prefix comparison first differs, if it does.
+ */
+export function diffRequests(previous, current, facts, breakIndex) {
+    const prev = messagesOf(previous.rows), cur = messagesOf(current.rows);
+    const prevByKey = new Map(prev.map(m => [m.key, m])), curByKey = new Map(cur.map(m => [m.key, m]));
+    const removed = prev.filter(m => !curByKey.has(m.key));
+    const added = cur.filter(m => !prevByKey.has(m.key));
+    const rewritten = cur.filter(m => m.id !== undefined && prevByKey.has(m.key) && prevByKey.get(m.key).text !== m.text);
+    // Resolve a replacement's shadowed ids back to ids the previous request carried (replace chains).
+    const resolve = (ids, depth = 0) => ids.flatMap(id => {
+        if (prev.some(m => m.id === id) || depth > 8)
+            return [id];
+        const inner = facts.byNewId(id);
+        return inner === undefined || inner.newId === id ? [id] : resolve(inner.replacedIds, depth + 1);
+    });
+    const explained = new Set();
+    const changes = [];
+    const seenFacts = new Set();
+    const candidates = [];
+    const want = (fact) => {
+        if (fact === undefined || seenFacts.has(fact.newId))
+            return;
+        seenFacts.add(fact.newId);
+        candidates.push(fact);
+    };
+    for (const m of added)
+        if (m.id !== undefined)
+            want(facts.byNewId(m.id));
+    for (const m of rewritten)
+        want(facts.byNewId(m.id));
+    for (const m of removed)
+        if (m.id !== undefined)
+            want(facts.byReplacedId(m.id));
+    for (const fact of candidates) {
+        const shadowed = new Set(resolve(fact.replacedIds));
+        const gone = removed.filter(m => m.id !== undefined && shadowed.has(m.id) && !explained.has(m.key));
+        const fresh = cur.filter(m => m.id === fact.newId);
+        const inPlace = fresh.filter(m => prevByKey.has(m.key));
+        const freshAdded = fresh.filter(m => !prevByKey.has(m.key));
+        if (gone.length === 0 && freshAdded.length === 0 && inPlace.length === 0)
+            continue;
+        for (const m of [...gone, ...freshAdded, ...inPlace])
+            explained.add(m.key);
+        const before = inPlace.length > 0 ? prevByKey.get(inPlace[0].key) : gone.length === 1 ? gone[0] : undefined;
+        const after = inPlace[0] ?? freshAdded[0];
+        const text = before !== undefined && after !== undefined ? prefixTextChange(before.text, after.text) : undefined;
+        changes.push({
+            kind: fact.kind,
+            removed: inPlace.length > 0 ? inPlace.map(m => rowOf(prevByKey.get(m.key))) : gone.map(rowOf),
+            added: [...inPlace, ...freshAdded].map(rowOf),
+            source: { kind: fact.sourceKind, ...fact.sourceOp === undefined ? {} : { op: fact.sourceOp } },
+            ...fact.eventSeq === undefined ? {} : { eventSeq: fact.eventSeq },
+            ...fact.replacedSeqs === undefined ? {} : { replacedSeqs: fact.replacedSeqs },
+            ...fact.compactionId === undefined ? {} : { compactionId: fact.compactionId },
+            ...text === undefined ? {} : { text },
+        });
+    }
+    // Same id, new text, no fact: an in-place rewrite the host did not label.
+    for (const m of rewritten) {
+        if (explained.has(m.key))
+            continue;
+        explained.add(m.key);
+        const before = prevByKey.get(m.key);
+        changes.push({ kind: 'replace', removed: [rowOf(before)], added: [rowOf(m)], text: prefixTextChange(before.text, m.text) });
+    }
+    const keptPrev = prev.filter(m => curByKey.has(m.key));
+    const keptCur = cur.filter(m => prevByKey.has(m.key));
+    const lastKeptPrev = Math.max(-1, ...keptPrev.map(m => m.index));
+    const anchor = Math.max(-1, ...keptCur.map(m => m.index), ...cur.filter(m => explained.has(m.key)).map(m => m.index));
+    const looseRemoved = removed.filter(m => !explained.has(m.key));
+    const looseAdded = added.filter(m => !explained.has(m.key));
+    const trailingRemovals = looseRemoved.some(m => m.index > lastKeptPrev);
+    // System rows never fold into the tail: a prompt update appended mid-history is what this list is for.
+    const tailRows = trailingRemovals ? [] : looseAdded.filter(m => m.index > anchor && m.category !== 'system');
+    const tailKeys = new Set(tailRows.map(m => m.key));
+    for (const run of runs(looseRemoved))
+        changes.push({ kind: 'remove', removed: run.map(rowOf), added: [] });
+    for (const run of runs(looseAdded.filter(m => !tailKeys.has(m.key))))
+        changes.push({ kind: 'add', removed: [], added: run.map(rowOf) });
+    const grouped = groupSystem(changes, prev, cur);
+    grouped.sort((a, b) => firstIndex(a) - firstIndex(b));
+    const tools = diffTools(previous.tools, current.tools);
+    const breakAt = breakIndex === undefined ? undefined
+        : grouped.find(c => c.added.some(r => r.index === breakIndex)) ?? grouped.find(c => c.removed.some(r => r.index === breakIndex));
+    if (breakAt !== undefined)
+        breakAt.isBreak = true;
+    else if (breakIndex === undefined && tools[0] !== undefined)
+        tools[0].isBreak = true;
+    return {
+        changes: grouped,
+        tools,
+        ...tailRows.length === 0 ? {} : { tail: { count: tailRows.length, sources: [...new Set(tailRows.map(m => m.source))] } },
+    };
+}
+function firstIndex(change) {
+    return Math.min(...change.added.map(r => r.index), ...change.removed.map(r => r.index));
+}
+/**
+ * Fold every all-system change into one entry. The text diff compares the
+ * head system message of both requests (the cache prefix); when the new head
+ * repeats a removed system message verbatim, that equality is recorded.
+ */
+function groupSystem(changes, prev, cur) {
+    const isSystem = (c) => [...c.removed, ...c.added].length > 0 && [...c.removed, ...c.added].every(r => r.category === 'system');
+    const system = changes.filter(isSystem);
+    if (system.length === 0)
+        return changes;
+    const rest = changes.filter(c => !isSystem(c));
+    const prevHead = prev.find(m => m.category === 'system'), curHead = cur.find(m => m.category === 'system');
+    let text;
+    let section;
+    if (prevHead !== undefined && curHead !== undefined && prevHead.index === curHead.index && prevHead.text !== curHead.text) {
+        text = prefixTextChange(prevHead.text, curHead.text);
+        section = sectionAt(curHead, text.offset);
+    }
+    else {
+        // Head untouched: the update landed elsewhere; diff the effective (last non-empty) prompts.
+        const effective = (list) => list.filter(m => m.category === 'system' && m.text.length > 0).at(-1);
+        const before = effective(prev), after = effective(cur);
+        if (before !== undefined && after !== undefined && before.text !== after.text)
+            text = prefixTextChange(before.text, after.text);
+    }
+    const removed = system.flatMap(c => c.removed);
+    const sameAs = curHead === undefined ? undefined
+        : removed.find(r => r.index !== curHead.index && prev.find(m => m.index === r.index)?.text === curHead.text);
+    const anyFact = system.some(c => c.kind !== 'add' && c.kind !== 'remove');
+    const merged = {
+        kind: anyFact ? 'replace' : removed.length > 0 ? 'remove' : 'add',
+        system: true,
+        removed,
+        added: system.flatMap(c => c.added),
+        source: { kind: 'system-prompt' },
+        parts: system.map(c => ({
+            kind: c.kind,
+            removed: c.removed,
+            added: c.added,
+            ...c.eventSeq === undefined ? {} : { eventSeq: c.eventSeq },
+            ...c.replacedSeqs === undefined ? {} : { replacedSeqs: c.replacedSeqs },
+        })),
+        ...text === undefined ? {} : { text },
+        ...section === undefined ? {} : { section },
+        ...sameAs === undefined ? {} : { sameAs },
+    };
+    return [merged, ...rest];
+}
+/** Tool definitions pair by name; description and parameters diff separately. */
+export function diffTools(previous, current) {
+    const before = new Map(previous.map(tool => [tool.name, tool]));
+    const after = new Set(current.map(tool => tool.name));
+    const out = [];
+    for (const tool of current) {
+        const old = before.get(tool.name);
+        if (old === undefined) {
+            out.push({ name: tool.name, change: 'added' });
+            continue;
+        }
+        const description = old.description === tool.description ? undefined : prefixTextChange(old.description, tool.description);
+        const parameters = old.parameters === tool.parameters ? undefined : prefixTextChange(old.parameters, tool.parameters);
+        if (description === undefined && parameters === undefined)
+            continue;
+        out.push({ name: tool.name, change: 'modified', ...description === undefined ? {} : { description }, ...parameters === undefined ? {} : { parameters } });
+    }
+    for (const tool of previous)
+        if (!after.has(tool.name))
+            out.push({ name: tool.name, change: 'removed' });
+    return out;
+}

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

@@ -0,0 +1,34 @@
+/**
+ * The selected turn's participants as one flat row: the main conversation,
+ * then every agent that ran in this turn (external agents and subagents
+ * alike) and the turn's compactions. Nothing that did not take part shows.
+ * Past four participants beside the main conversation, three stay visible
+ * (the selected one always among them) and the rest fold into "+N", which
+ * lists them all in the order they started. A note at the row's end holds
+ * facts with a jump — the request that delegated the view, a compaction's
+ * position — so the tabs keep the header's bottom edge. A failure shows as
+ * the tab's ✗ and the failure card below, nowhere else.
+ */
+import { type ReactNode } from 'react';
+import type { AgentScopeOverview, ListTurnsResult, RequestLink } from '../types.ts';
+import type { InspectorTabProps } from './contract.ts';
+type T = InspectorTabProps['t'];
+export interface AgentTabsProps {
+    readonly scopes: readonly AgentScopeOverview[];
+    readonly value: string;
+    readonly onSelect: (scopeId: string) => void;
+    readonly onOpenRequest: (link: RequestLink) => void;
+    readonly t: T;
+    /** The room's decision-model calls this turn: a 房间 tab after the agents when positive. */
+    readonly roomCount?: number | undefined;
+}
+/** The 房间 tab's value (no agent scope carries it). */
+export declare const ROOM_TAB = "room:decisions";
+export declare function AgentTabs({ scopes, value, onSelect, onOpenRequest, roomCount, t }: AgentTabsProps): ReactNode;
+/** A session opened on its own that is another session's child. */
+export declare function ParentLine({ parent, t }: {
+    readonly parent: NonNullable<ListTurnsResult['parent']>;
+    readonly t: T;
+}): ReactNode;
+export {};
+//# sourceMappingURL=AgentTabs.d.ts.map

package/lib/types/client/AgentTabs.js

@@ -0,0 +1,89 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * The selected turn's participants as one flat row: the main conversation,
+ * then every agent that ran in this turn (external agents and subagents
+ * alike) and the turn's compactions. Nothing that did not take part shows.
+ * Past four participants beside the main conversation, three stay visible
+ * (the selected one always among them) and the rest fold into "+N", which
+ * lists them all in the order they started. A note at the row's end holds
+ * facts with a jump — the request that delegated the view, a compaction's
+ * position — so the tabs keep the header's bottom edge. A failure shows as
+ * the tab's ✗ and the failure card below, nowhere else.
+ */
+import { useEffect, useRef, useState } from 'react';
+import { requestNumberText } from "./aggregate.js";
+import css from './AgentTabs.module.css';
+/** Participants shown beside the main conversation before the rest fold behind "+N". */
+const VISIBLE = 3;
+function labelOf(scope, t) {
+    if (scope.kind === 'main')
+        return t('scope.mainName');
+    if (scope.kind === 'compaction')
+        return t('tabs.compaction');
+    return scope.label ?? scope.scopeId;
+}
+function Mark({ scope }) {
+    // Success is the norm; only a failure earns a mark.
+    if (scope.status === 'failed')
+        return _jsx("span", { className: css.bad, "aria-hidden": "true", children: "\u2717" });
+    return null;
+}
+function Tab({ scope, selected, onSelect, t }) {
+    return _jsxs("button", { type: "button", role: "tab", "aria-selected": selected, className: css.tab, onClick: () => onSelect(scope.scopeId), title: labelOf(scope, t), children: [_jsx("span", { className: css.label, children: labelOf(scope, t) }), _jsx(Mark, { scope: scope }), _jsx("span", { className: css.count, children: scope.requests.length })] });
+}
+function Overflow({ hidden, items, value, onSelect, t }) {
+    const [open, setOpen] = useState(false);
+    const box = useRef(null);
+    useEffect(() => {
+        if (!open)
+            return;
+        const onDown = (event) => { if (!box.current?.contains(event.target))
+            setOpen(false); };
+        const onKey = (event) => { if (event.key === 'Escape')
+            setOpen(false); };
+        document.addEventListener('pointerdown', onDown);
+        document.addEventListener('keydown', onKey);
+        return () => { document.removeEventListener('pointerdown', onDown); document.removeEventListener('keydown', onKey); };
+    }, [open]);
+    return _jsxs("div", { ref: box, className: css.moreBox, children: [_jsxs("button", { type: "button", className: css.more, "aria-expanded": open, "aria-haspopup": "listbox", onClick: () => setOpen(v => !v), children: ["+", hidden, _jsx("svg", { viewBox: "0 0 10 10", "aria-hidden": "true", children: _jsx("path", { d: "M2 3.5 5 6.5 8 3.5", fill: "none", stroke: "currentColor", strokeWidth: "1.4", strokeLinecap: "round", strokeLinejoin: "round" }) })] }), open && _jsxs("div", { className: css.pop, role: "listbox", "aria-label": t('tabs.participants'), children: [_jsxs("div", { className: css.popHead, children: [_jsxs("span", { children: [t('tabs.participants'), " \u00B7 ", items.length] }), _jsx("span", { children: t('tabs.popCols') })] }), items.map(scope => _jsxs("button", { type: "button", role: "option", "aria-selected": scope.scopeId === value, className: css.popRow, title: labelOf(scope, t), onClick: () => { onSelect(scope.scopeId); setOpen(false); }, children: [_jsx("span", { className: css.label, children: labelOf(scope, t) }), _jsx("span", { className: css.mark, children: _jsx(Mark, { scope: scope }) }), _jsx("span", { className: css.num, children: scope.delegatedBy ? `#${requestNumberText(scope.delegatedBy)}` : '—' }), _jsx("span", { className: css.num, children: scope.requests.length })] }, scope.scopeId))] })] });
+}
+/** How the selected view relates to the main conversation: facts with a jump, no explanations. */
+function Relation({ scope, onOpenRequest, t }) {
+    const back = (link) => _jsx("button", { type: "button", onClick: () => onOpenRequest(link), children: t('rel.back', { seq: requestNumberText(link) }) });
+    const parts = [];
+    if (scope.kind === 'compaction') {
+        const c = scope.compaction;
+        if (c?.replacedCount !== undefined)
+            parts.push(_jsx("span", { children: t('rel.compacted', { count: String(c.replacedCount) }) }, "n"));
+        if (c?.betweenTurns)
+            parts.push(_jsx("span", { children: t('rel.betweenTurns') }, "w"));
+        else if (c?.after)
+            parts.push(_jsx("span", { children: t('rel.after', { seq: requestNumberText(c.after) }) }, "w"), _jsx("span", { children: back(c.after) }, "b"));
+    }
+    else if (scope.delegatedBy) {
+        parts.push(_jsx("span", { children: t('rel.delegatedBy', { seq: requestNumberText(scope.delegatedBy) }) }, "by"), _jsx("span", { children: back(scope.delegatedBy) }, "b"));
+    }
+    return parts.length === 0 ? null : _jsx("div", { className: css.relation, children: parts });
+}
+/** The 房间 tab's value (no agent scope carries it). */
+export const ROOM_TAB = 'room:decisions';
+export function AgentTabs({ scopes, value, onSelect, onOpenRequest, roomCount, t }) {
+    const selected = scopes.find(scope => scope.scopeId === value) ?? scopes[0];
+    const main = scopes.filter(scope => scope.kind === 'main');
+    const others = [
+        ...scopes.filter(scope => scope.kind === 'subagent').sort((a, b) => a.startedAt - b.startedAt),
+        ...scopes.filter(scope => scope.kind === 'compaction'),
+    ];
+    let shown = others;
+    if (others.length > VISIBLE + 1) {
+        shown = others.slice(0, VISIBLE);
+        const current = others.find(scope => scope.scopeId === value);
+        if (current !== undefined && !shown.includes(current))
+            shown = [...others.slice(0, VISIBLE - 1), current];
+    }
+    return _jsx("div", { className: css.root, children: _jsxs("div", { className: css.row, role: "tablist", "aria-label": t('tab.title'), children: [[...main, ...shown].map(scope => _jsx(Tab, { scope: scope, selected: value !== ROOM_TAB && scope.scopeId === selected?.scopeId, onSelect: onSelect, t: t }, scope.scopeId)), shown.length < others.length && _jsx(Overflow, { hidden: others.length - shown.length, items: others, value: value, onSelect: onSelect, t: t }), roomCount !== undefined && roomCount > 0 && (_jsxs("button", { type: "button", role: "tab", "aria-selected": value === ROOM_TAB, className: css.tab, onClick: () => onSelect(ROOM_TAB), children: [_jsx("span", { className: css.label, children: t('room.tab') }), _jsx("span", { className: css.count, children: roomCount })] })), selected && value !== ROOM_TAB && _jsx(Relation, { scope: selected, onOpenRequest: onOpenRequest, t: t })] }) });
+}
+/** A session opened on its own that is another session's child. */
+export function ParentLine({ parent, t }) {
+    return _jsxs("div", { className: css.parent, children: [_jsx("span", { className: css.muted, children: t('rel.parent') }), _jsx("b", { children: parent.title ?? parent.sessionId }), parent.hostTurn !== undefined && _jsxs("span", { className: css.muted, children: ["\u00B7 ", t('rel.parentTurn', { turn: String(parent.hostTurn) })] }), parent.label !== undefined && _jsxs("span", { className: css.muted, children: ["\u00B7 ", t('rel.parentLabel', { label: parent.label })] })] });
+}

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

@@ -0,0 +1,28 @@
+/**
+ * The cache section's break line and change list. Each card names the host
+ * fact behind it (replacement, compaction, prune, or a bare id-level
+ * remove/add), shows its producer verbatim, and expands into the exact
+ * difference; the card where the prefix first differs carries the break mark
+ * and opens by default. Jumps go to the module that owns the detail (the
+ * composition filter, the compaction request, the pre-prune request).
+ */
+import { type ReactNode } from 'react';
+import type { CapturedRequest, PrefixTextChange, RequestLink, SegmentCategory } from '../types.ts';
+import type { InspectorTabProps } from './contract.ts';
+type T = InspectorTabProps['t'];
+type Prefix = NonNullable<CapturedRequest['prefix']>;
+export interface ChangeListProps {
+    readonly request: CapturedRequest;
+    readonly prefix: Prefix;
+    readonly onOpenRequest?: ((link: RequestLink) => void) | undefined;
+    readonly onShowCategory?: ((category: SegmentCategory) => void) | undefined;
+    readonly t: T;
+}
+/** One-line character diff: shared context, then what left and what arrived. */
+export declare function InlineDiff({ text, t }: {
+    readonly text: PrefixTextChange;
+    readonly t: T;
+}): ReactNode;
+export declare function ChangeList({ request, prefix, onOpenRequest, onShowCategory, t }: ChangeListProps): ReactNode;
+export {};
+//# sourceMappingURL=ChangeList.d.ts.map