dsh-context-pruner 0.0.0-stage → 0.1.1

package/lib/client.js

@@ -0,0 +1,1230 @@
+/**
+ * dsh-context-pruner browser plugin — step 1: the Context tab renders rounds.
+ *
+ * ## Why this is a hand-written bundle
+ *
+ * Shipped client plugins are produced by rolldown into a
+ * `window.__ModuleLoader__.load({ id, factory })` wrapper. That wrapper is a
+ * small, stable contract and `dsh-client-ui-brand-official` (2 KB) is a
+ * complete worked example of exactly this shape, so this plugin is authored
+ * directly in that format: no build step, and the source a maintainer reads is
+ * the artifact the browser runs. The body only registers the factory; every
+ * side effect lives inside it and runs at materialization.
+ *
+ * ## Verified integration points
+ *
+ * These were read from the shipped type declarations rather than guessed;
+ * three earlier guesses were wrong and are noted so they are not re-made:
+ *
+ *   - Services come from `ctx.get(name)` / `ctx.<name>`, NOT `ctx.sessions.get(id)`.
+ *   - Session data arrives as framework-injected props on a session-scoped
+ *     slot body (`sessionId`, `useSessions`, `useTabInfo`, `actions`), and the
+ *     event stream is `ctx.sessions.binding(id).eventSource`.
+ *   - `ctx.slots.register(spec, Component)` is called directly; the generator
+ *     form is for `ctx.effect`.
+ *
+ * ## Scope of this step
+ *
+ * Read-only: the tab lists rounds with their token weight. Selection and the
+ * Prune button arrive in step 2, after this renders correctly in a browser —
+ * client behavior cannot be proven by a Node test.
+ */
+window.__ModuleLoader__.load({
+	id: "dsh-context-pruner",
+	factory: (require) => {
+		var module = { exports: {} };
+		var exports = module.exports;
+		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+
+		const React = require("react");
+		const jsxRuntime = require("react/jsx-runtime");
+
+		const h = jsxRuntime.jsx;
+		const jsxs = jsxRuntime.jsxs;
+
+		/** Tab type id; the body and title slots register under this same key. */
+		const TAB_ID = "dsh-context-pruner";
+
+		/** Tab kind: the discriminator `ctx.sidebarRight.openTab` names. */
+		const TAB_KIND = "context-pruner";
+
+		/**
+		 * Cordis SERVICE names this plugin waits for before activating.
+		 *
+		 * These are service names, not package names. Declaring package names
+		 * here (an earlier mistake) leaves the entry permanently `pending`,
+		 * because Cordis waits for services under exactly these strings:
+		 *
+		 *   dsh-context-pruner: pending (waiting for services:
+		 *     @deepseek-ai/dsh-client-ui-slots, ...)
+		 *
+		 * `sidebarRight` is the controller that renders the column, and every
+		 * shipped tab provider injects it (`dsh-client-ui-sidebar-files` lists
+		 * `slots, locale, sidebarRightTabs, sidebarRight, ...`). Omitting it
+		 * registers the body successfully while the pane never resolves it —
+		 * the tab chip appears and the panel stays blank, which is exactly the
+		 * symptom this list was corrected for.
+		 */
+		const inject = ["slots", "sidebarRightTabs", "sidebarRight", "sessions", "conversation"];
+
+		/** Opening tag of a framed compaction checkpoint body. */
+		const SUMMARY_OPEN_TAG = "<compacted-summary>";
+
+		/** Closing tag of a framed compaction checkpoint body. */
+		const SUMMARY_CLOSE_TAG = "</compacted-summary>";
+
+		/**
+		 * `source.kind` values that never represent a human turn.
+		 *
+		 * Verified in the DSH checkout: every harness injection is built with
+		 * `createUserMessage({ ..., source: { kind, form } })` and delivered
+		 * through the same `user/message` surface type as real conversation.
+		 */
+		const MACHINE_SOURCE_KINDS = new Set([
+			"tool-jobs",
+			"runtime-context",
+			"agent-instructions",
+			"agent-message",
+			"session-reference",
+			"skill-invocation",
+			"model-selection"
+		]);
+
+		/** `source.form` values that mark an injected rather than typed message. */
+		const MACHINE_SOURCE_FORMS = new Set(["notice", "snapshot", "instructions"]);
+
+		/**
+		 * Command names dispatched as commands rather than chat.
+		 *
+		 * Mirrors `KNOWN_COMMANDS` in `lib/rounds.js`, so the two sides classify
+		 * a slash-leading line identically. Used only when no `source` marker is
+		 * available.
+		 */
+		const KNOWN_COMMANDS = new Set([
+			"prune",
+			"compact",
+			"clear",
+			"help",
+			"init",
+			"model",
+			"new",
+			"resume",
+			"review",
+			"status",
+			"quit",
+			"exit"
+		]);
+
+		/**
+		 * Opening sentences of the fixed checkpoint boilerplate.
+		 *
+		 * Both framings ship: "This is an automatically generated checkpoint…"
+		 * from the stock backend and "This is a correction checkpoint…" from this
+		 * plugin's. The two real openings are named rather than matching a bare
+		 * "This is ", which would strip ordinary prose starting that way.
+		 *
+		 * Kept in sync with `CHECKPOINT_OPENINGS` in `lib/inspect.js`; the parity
+		 * is asserted by `test/rounds.mjs`, which executes these functions out of
+		 * the shipped bundle against the host's output.
+		 */
+		const CHECKPOINT_OPENINGS = [
+			"This is an automatically generated checkpoint",
+			"This is a correction checkpoint"
+		];
+
+		/**
+		 * Remove checkpoint boilerplate from the head of a block.
+		 *
+		 * The boilerplate is fixed English text. It is usually its own block, but
+		 * a producer may emit it in the SAME block as the framed body — with or
+		 * without a paragraph break. Dropping the whole block on a prefix match
+		 * would then discard the summary along with it, so only the boilerplate's
+		 * own span is removed and whatever follows is kept.
+		 *
+		 * @param text - one text block's content.
+		 * @returns the text after the boilerplate, or `text` when there is none.
+		 */
+		function stripCheckpointPreamble(text) {
+			for (const opening of CHECKPOINT_OPENINGS) {
+				if (!text.startsWith(opening)) continue;
+				const end = text.indexOf("\n\n", opening.length);
+				if (end !== -1) return text.slice(end + 2);
+				const tag = text.indexOf(SUMMARY_OPEN_TAG, opening.length);
+				return tag === -1 ? "" : text.slice(tag);
+			}
+			return text;
+		}
+
+		/**
+		 * Whether a block is nothing but checkpoint boilerplate.
+		 *
+		 * @param text - one text block's content.
+		 * @returns true when the block carries no content beyond the preamble.
+		 */
+		function isCheckpointPreamble(text) {
+			return stripCheckpointPreamble(text).trim().length === 0 && text.trim().length > 0;
+		}
+
+		/**
+		 * Whether a `source` marker identifies a harness injection.
+		 *
+		 * Mirrors `isMachineSource` in `lib/rounds.js`. The panel cannot import
+		 * the host module, so the rule is restated here — and
+		 * `test/rounds.mjs` extracts this function from the shipped bundle and
+		 * runs it against the same table the host module is tested with, so the
+		 * two copies cannot drift apart silently.
+		 *
+		 * The structured marker is preferred over text matching: it survives
+		 * reworded notices, which the prefix list would not.
+		 *
+		 * @param source - a message's `source` field, when present.
+		 * @returns true when the marker names a machine delivery.
+		 */
+		function isMachineSource(source) {
+			if (source === null || source === undefined || typeof source !== "object") return false;
+			if (
+				typeof source.kind === "string" &&
+				MACHINE_SOURCE_KINDS.has(source.kind)
+			) {
+				return true;
+			}
+			if (typeof source.form === "string" && MACHINE_SOURCE_FORMS.has(source.form)) return true;
+			return false;
+		}
+
+		/**
+		 * Group a session's model-visible surface into conversation rounds.
+		 *
+		 * A round opens at each user message and absorbs everything until the
+		 * next one — the unit a reader actually reasons about ("that round
+		 * where we tried the wrong fix").
+		 *
+		 * The client has no session surface object; it has the event window.
+		 * Surface membership is therefore derived from each event's own
+		 * `surfaceOp` marker: `append` enters the tail, and a `replace` shadow
+		 * retires the range it names. Compaction events carry no marker and are
+		 * log-only, so they are skipped naturally.
+		 *
+		 * @param entries - event-window entries from the binding's eventSource.
+		 * @param hasMore - whether older events remain outside the window.
+		 * @returns `{ rounds, hasMore }` in surface order.
+		 */
+		function readRounds(entries, hasMore = false) {
+			const shadowed = new Set();
+			const nodes = [];
+
+			for (const entry of entries ?? []) {
+				if (entry?.type !== "event") continue;
+				const event = entry.event;
+				if (event === undefined || event === null) continue;
+
+				const op = event.surfaceOp;
+				if (op === undefined || op === null) continue;
+
+				if (typeof op === "object" && op.op === "replace") {
+					// A replacement retires its named range and takes that
+					// position; record the shadowed seqs so they are skipped.
+					//
+					// Fall back to the replace op's own endpoints when the entry
+					// omits `sourceEventSeqs`: without that, a replacement would
+					// shadow nothing and already-retired rounds would reappear.
+					const cited =
+						Array.isArray(event.sourceEventSeqs) && event.sourceEventSeqs.length > 0
+							? event.sourceEventSeqs
+							: [op.startSeq, op.endSeq];
+					for (const seq of cited) shadowed.add(seq);
+					nodes.push(event);
+					continue;
+				}
+				nodes.push(event);
+			}
+
+			const live = nodes.filter((event) => !shadowed.has(event.seq));
+
+			const rounds = [];
+			let current = null;
+			// Nodes seen before the first human turn. This MUST mirror
+			// `groupRounds` in `lib/inspect.js`, or the two sides disagree on
+			// every real session: the shipped `SystemPromptProjection` commits
+			// the rendered system prompt as surface node 0, so without the
+			// hold-over the panel opens a bogus round 0 on the system prompt and
+			// every later index is off by one. That is precisely the wrong-span
+			// symptom this panel was fixed for.
+			let leading = [];
+
+			/**
+			 * Start a round at `descriptor`, absorbing any held-over nodes.
+			 *
+			 * @param descriptor - the node opening the round.
+			 * @param held - nodes to prepend, in order.
+			 */
+			const openRound = (descriptor, held) => {
+				const first = held.length > 0 ? held[0] : descriptor;
+				const absorbed = held.reduce((sum, node) => sum + node.tokens, 0);
+				const notices = [...held, descriptor].filter(
+					(node) => node.role === "user" && !node.opensRound
+				).length;
+				current = {
+					index: rounds.length,
+					tokens: descriptor.tokens + absorbed,
+					position: first.position,
+					// The span the UI needs: the first and last surface node seq
+					// of this round. `startSeq` is what a drop range resolves
+					// against, so both ends are tracked.
+					startSeq: first.seq,
+					endSeq: descriptor.seq,
+					// The heading shown for this round. A round may open with
+					// injected context, so the human message supplies the title
+					// rather than the first node.
+					title: descriptor.opensRound ? descriptor.preview : null,
+					preview: descriptor.preview,
+					injected: notices
+				};
+				rounds.push(current);
+			};
+
+			for (let position = 0; position < live.length; position += 1) {
+				const event = live[position];
+				const descriptor = describeEvent(event);
+				descriptor.position = position;
+
+				if (current === null) {
+					if (descriptor.opensRound) {
+						openRound(descriptor, leading);
+						leading = [];
+					} else {
+						// Hold it: whether it deserves its own round is not known
+						// until a human turn decides.
+						leading.push(descriptor);
+					}
+					continue;
+				}
+
+				// Only a REAL human message opens a round. The harness injects
+				// background-job reports, runtime context, system reminders and
+				// model-change notices as `user/message` too; treating those as
+				// round openers both showed meaningless rows and fragmented the
+				// conversation (16 human turns arrived as 30 "rounds").
+				if (descriptor.opensRound) {
+					openRound(descriptor, []);
+					continue;
+				}
+
+				current.tokens += descriptor.tokens;
+				current.endSeq = event.seq;
+				if (descriptor.role === "user" && !descriptor.opensRound) current.injected += 1;
+			}
+
+			// A session with no human turn at all must still render one round.
+			if (current === null && leading.length > 0) {
+				openRound(leading[leading.length - 1], leading.slice(0, -1));
+			}
+
+			return { rounds, hasMore };
+		}
+
+		/**
+		 * Whether a user message came from the human rather than the harness.
+		 *
+		 * The harness delivers several machine notices through the same
+		 * `user/message` surface type. They are not conversation turns, and
+		 * treating them as such is what made the panel show rows reading
+		 * `background job pwsh-20 (pwsh: Start-Sleep ...)`.
+		 *
+		 * The structured `source` marker is checked first — it is what the
+		 * harness itself attaches, so it survives a reworded notice. The text
+		 * prefixes remain as a fallback for entries whose `source` is absent
+		 * from the loaded event window.
+		 *
+		 * @param text - the message's flattened text.
+		 * @param source - the message's optional structured `source` marker.
+		 * @returns true when this is a genuine human turn.
+		 */
+		function isHumanTurn(text, source) {
+			if (isMachineSource(source)) return false;
+			const head = String(text ?? "").trimStart().slice(0, 120);
+			// An empty message is not a turn.
+			if (head.length === 0) return false;
+			if (/^background job /i.test(head)) return false;
+			if (/^<system-reminder>/.test(head)) return false;
+			if (/^\[model changed:/.test(head)) return false;
+			if (/^Current runtime context\./.test(head)) return false;
+			if (/^This session is being continued from/.test(head)) return false;
+			// A slash COMMAND echo is an action, not a turn. Deliberately narrow:
+			// matching a bare leading "/" swallowed real prompts that begin with
+			// a path ("/tmp cleanup needed"), silently folding them into the
+			// previous round and shifting every later index.
+			//
+			// Mirrors `isHumanTurn` in `lib/rounds.js`; the parity is asserted by
+			// `test/rounds.mjs`, which executes this function out of the bundle.
+			const commandish = /^\/([a-z][\w-]*)(?::([\w-]+))?(\s|$)/i.exec(head);
+			if (commandish !== null) {
+				const rest = head.slice(commandish[0].length).trim();
+				if (rest.length === 0) return false;
+				if (KNOWN_COMMANDS.has(commandish[1].toLowerCase())) return false;
+			}
+			return true;
+		}
+
+		/**
+		 * Extract the message a surface event carries.
+		 *
+		 * Three of the five surface event types nest the message under
+		 * `data.message` — `assistant/message`, `tool/result`, and
+		 * `system/message` — while `user/message` carries it directly in
+		 * `data`. Treating `tool/result` as a flat payload is what made every
+		 * tool row preview as raw scaffolding text instead of its output.
+		 *
+		 * @param event - a surface event.
+		 * @returns the message payload, or undefined.
+		 */
+		function messageOf(event) {
+			if (event?.type === "user/message") return event.data;
+			return event?.data?.message;
+		}
+
+		/**
+		 * Derive a role, preview and token estimate for one surface event.
+		 *
+		 * @param event - a surface event carrying `surfaceOp`.
+		 * @returns `{ role, preview, tokens, opensRound }`.
+		 */
+		function describeEvent(event) {
+			const role =
+				event.type === "user/message"
+					? "user"
+					: event.type === "assistant/message"
+						? "assistant"
+						: event.type === "tool/result"
+							? "tool"
+							: "system";
+
+			const message = messageOf(event);
+
+			// The content array is stripped as a WHOLE, because checkpoint
+			// framing spans blocks: the preamble is one block, the opening tag
+			// leads the next, and the closing tag is a third. A per-block API is
+			// what let the host and this panel drift into two different rules
+			// that each handled only its own layout.
+			const stripped = stripCheckpointFraming(message?.content ?? []);
+
+			let text = flattened(stripped);
+
+			// A tool result with no text (or an assistant turn that only called
+			// tools) still deserves a label: an empty preview tells the reader
+			// nothing about why the row exists.
+			if (text.length === 0) {
+				if (role === "tool") text = message?.isError ? "(tool error)" : "(tool output)";
+				else if (role === "assistant") text = "(assistant called a tool)";
+				else text = `(${event.type})`;
+			}
+			if (text.length > 140) text = `${text.slice(0, 140)}…`;
+
+			// The message's own text, untruncated, so classification sees the
+			// real prefix rather than the 140-character preview.
+			const humanText = role === "user" ? flattened(stripped) : "";
+
+			return {
+				role,
+				// The event's own seq, so a round can name its span without the
+				// caller having to re-associate descriptors with events.
+				seq: event.seq,
+				preview: text,
+				tokens: Math.ceil(totalCharacters(stripped) / 4),
+				// Only a genuine human user message starts a conversation round.
+				// The structured `source` marker is preferred over the text
+				// prefixes, so a reworded notice is still classified correctly.
+				opensRound: role === "user" && isHumanTurn(humanText, message?.source)
+			};
+		}
+
+		/**
+		 * Collapse stripped blocks into one whitespace-normalised string.
+		 *
+		 * @param blocks - blocks from {@link stripCheckpointFraming}.
+		 * @returns the flattened text.
+		 */
+		function flattened(blocks) {
+			return blocks
+				.map((block) => block.text)
+				.join(" ")
+				.replace(/\s+/g, " ")
+				.trim();
+		}
+
+		/**
+		 * Sum the character weight of stripped blocks, for token estimation.
+		 *
+		 * @param blocks - blocks from {@link stripCheckpointFraming}.
+		 * @returns the total character count.
+		 */
+		function totalCharacters(blocks) {
+			return blocks.reduce((sum, block) => sum + block.characters, 0);
+		}
+
+		/**
+		 * Summarize one tool call as `tool:name (first arg)`.
+		 *
+		 * @param block - a `tool-call` content block.
+		 * @returns a short label.
+		 */
+		function describeToolCall(block) {
+			const name = block.name ?? "?";
+			let hint = "";
+			try {
+				const args = typeof block.arguments === "string" ? JSON.parse(block.arguments) : block.arguments;
+				if (args && typeof args === "object") {
+					// The first string-valued field usually names the target:
+					// a path, a pattern, a command.
+					for (const key of ["command", "file_path", "path", "pattern", "query", "url"]) {
+						if (typeof args[key] === "string" && args[key].length > 0) {
+							hint = args[key].replace(/\s+/g, " ").slice(0, 70);
+							break;
+						}
+					}
+				}
+			} catch {
+				/* arguments may be a partial JSON string while streaming */
+			}
+			return hint.length > 0 ? `[${name}: ${hint}]` : `[${name}]`;
+		}
+
+		/**
+		 * Strip compaction framing from a whole content array.
+		 *
+		 * A checkpoint message is three text blocks:
+		 *
+		 *   [0] "<boilerplate preamble>"
+		 *   [1] "<compacted-summary>\n\n...the actual summary..."
+		 *   [2] "</compacted-summary>"
+		 *
+		 * The opening tag leads block 1, NOT the tail of block 0 — which is why
+		 * scanning for the tag inside the boilerplate block found nothing and
+		 * every checkpoint previewed as the same fixed English sentence.
+		 *
+		 * Taking the ARRAY rather than one block is what makes the rule exact:
+		 * the preamble is dropped by its own opening words, a block carrying the
+		 * opening tag keeps only the body, the closing tag is removed inline,
+		 * and a block that is left empty is discarded entirely. The host's
+		 * `previewMessage` in `lib/inspect.js` applies the same union of rules,
+		 * and `test/rounds.mjs` pins the two implementations together.
+		 *
+		 * @param content - a message's content blocks.
+		 * @returns `{ type, text, characters }` entries, text-bearing only.
+		 */
+		function stripCheckpointFraming(content) {
+			const out = [];
+
+			for (const block of content ?? []) {
+				if (block === null || block === undefined) continue;
+
+				if (block.type === "tool-call") {
+					// Name the tool and its first meaningful argument, so a call
+					// row reads as "what was asked" rather than "[tool:?]".
+					out.push({
+						type: "tool-call",
+						label: describeToolCall(block),
+						text: describeToolCall(block),
+						characters: JSON.stringify(block.arguments ?? "").length
+					});
+					continue;
+				}
+
+				if (block.type === "image") {
+					out.push({ type: "image", text: "[image]", characters: 1024 });
+					continue;
+				}
+
+				if (block.type !== "text" || typeof block.text !== "string") continue;
+
+				// The fixed preamble carries no summary content, but the block
+				// may also carry the framed body, so only the preamble's own span
+				// is removed.
+				const withoutPreamble = stripCheckpointPreamble(block.text);
+
+				const open = withoutPreamble.indexOf(SUMMARY_OPEN_TAG);
+				let body =
+					open === -1
+						? withoutPreamble
+						: withoutPreamble.slice(open + SUMMARY_OPEN_TAG.length);
+				body = body.split(SUMMARY_CLOSE_TAG).join("");
+				if (body.trim().length === 0) continue;
+
+				out.push({ type: "text", text: body, characters: block.text.length });
+			}
+
+			return out;
+		}
+
+		/**
+		 * Render a compact token figure.
+		 *
+		 * @param tokens - estimated tokens.
+		 * @returns a short label such as `3.4k`.
+		 */
+		function formatTokens(tokens) {
+			if (tokens >= 1000) {
+				const thousands = tokens / 1000;
+				return `${thousands >= 10 ? Math.round(thousands) : thousands.toFixed(1)}k`;
+			}
+			return String(tokens);
+		}
+
+		/**
+		 * Read the live event window for a session.
+		 *
+		 * The binding is created by retaining the session; `eventSource` is an
+		 * observable snapshot of the contiguous window.
+		 *
+		 * `revision` is the field that matters for freshness: it advances on
+		 * every accepted window mutation, including a COMPACTION. `openState` in
+		 * the session snapshot does not, which is why a panel keyed only on it
+		 * kept showing rounds that had already been compacted away.
+		 *
+		 * @param ctx - client root context.
+		 * @param sessionId - the session to inspect.
+		 * @returns `{ entries, hasMore, revision }`, or an empty window when unavailable.
+		 */
+		function readWindow(ctx, sessionId) {
+			const empty = { entries: [], hasMore: false, revision: -1 };
+			if (sessionId === undefined || sessionId === null) return empty;
+			const sessions = ctx.sessions ?? ctx.get("sessions");
+			if (sessions === undefined || sessions === null) return empty;
+			if (typeof sessions.binding !== "function") return empty;
+			const binding = sessions.binding(sessionId);
+			const source = binding?.eventSource;
+			if (source === undefined || source === null) return empty;
+			const window = typeof source.getSnapshot === "function" ? source.getSnapshot() : undefined;
+			return {
+				entries: window?.entries ?? [],
+				hasMore: window?.hasMore === true,
+				revision: typeof window?.revision === "number" ? window.revision : -1
+			};
+		}
+
+		/**
+		 * The session's event source, when it is retained and observable.
+		 *
+		 * @param ctx - client root context.
+		 * @param sessionId - the session to inspect.
+		 * @returns the observable snapshot source, or undefined.
+		 */
+		function eventSource(ctx, sessionId) {
+			if (sessionId === undefined || sessionId === null) return undefined;
+			const sessions = ctx.sessions ?? ctx.get("sessions");
+			if (sessions === undefined || sessions === null) return undefined;
+			if (typeof sessions.binding !== "function") return undefined;
+			return sessions.binding(sessionId)?.eventSource;
+		}
+
+		/**
+		 * The session face that owns paging, when the session is retained.
+		 *
+		 * @param ctx - client root context.
+		 * @param sessionId - the session to inspect.
+		 * @returns the session face, or undefined.
+		 */
+		function sessionFace(ctx, sessionId) {
+			const sessions = ctx.sessions ?? ctx.get("sessions");
+			if (sessions === undefined || sessions === null) return undefined;
+			if (typeof sessions.binding !== "function") return undefined;
+			return sessions.binding(sessionId)?.session;
+		}
+
+		/**
+		 * Page history backwards until the whole log is loaded.
+		 *
+		 * `eventSource` is a *contiguous window*, not the complete log: a long
+		 * session opens with only its tail, and `hasMore` reports that older
+		 * events exist. Listing just that window is what made a 28-round
+		 * session show only 4 rounds. `loadOlder()` extends the window by at
+		 * least 50 messages per call, so this loops until `hasMore` clears.
+		 *
+		 * @param ctx - client root context.
+		 * @param sessionId - the session to load.
+		 * @param limit - maximum pages to fetch, guarding a runaway loop.
+		 * @returns a promise resolving when paging settles.
+		 */
+		async function loadFullHistory(ctx, sessionId, limit = 40) {
+			const session = sessionFace(ctx, sessionId);
+			if (session === undefined || typeof session.loadOlder !== "function") return;
+			for (let page = 0; page < limit; page += 1) {
+				const { hasMore } = readWindow(ctx, sessionId);
+				if (!hasMore) return;
+				try {
+					await session.loadOlder();
+				} catch {
+					// Paging can fail while a session is still opening; the
+					// window already loaded stays usable.
+					return;
+				}
+			}
+		}
+
+		/**
+		 * The Context tab body.
+		 *
+		 * The slot framework supplies the session standard kit (`sessionId`,
+		 * `useSession`) and whatever the registration declared under `inject` —
+		 * here the plugin's own `readRounds` face, so the component stays free
+		 * of service lookups and testable on its own.
+		 *
+		 * @param props - slot props.
+		 * @returns the rendered panel.
+		 */
+		function ContextPrunerBody(props) {
+			const sessionId = props.sessionId;
+			const read = props.readRounds;
+			const prune = props.pruneRounds;
+			// The composer's own draft/submit actions: the only path that turns
+			// a slash line into a command rather than a chat message.
+			const inputActions = props.inputActions;
+
+			// Hooks run unconditionally and in a stable order: the session
+			// snapshot is also what re-renders the list as history changes.
+			const sessionSnapshot =
+				typeof props.useSession === "function" ? props.useSession((s) => s) : undefined;
+
+			const [selected, setSelected] = React.useState(() => new Set());
+			const [busy, setBusy] = React.useState(false);
+			const [outcome, setOutcome] = React.useState(null);
+			// Bumped when a history page lands, so the listing re-reads a window
+			// that has grown.
+			const [pages, setPages] = React.useState(0);
+			const [loading, setLoading] = React.useState(false);
+			// Bumped by the event source on every accepted window mutation, so
+			// the list follows compactions and new turns. `openState` alone does
+			// NOT change when history is rewritten.
+			const [revision, setRevision] = React.useState(0);
+
+			// `openState` is the observable signal that history arrived or a turn
+			// settled, so the list refreshes with it.
+			const rowsKey = sessionSnapshot ? String(sessionSnapshot.openState) : "none";
+
+			// Subscribe to the event window itself. A compaction appends
+			// surface-replacing events without touching `openState`, so a panel
+			// keyed only on that kept listing rounds that no longer exist — the
+			// "compacted but still shown" report.
+			React.useEffect(() => {
+				if (typeof props.subscribeEvents !== "function") return undefined;
+				if (sessionId === undefined || sessionId === null) return undefined;
+				return props.subscribeEvents(sessionId, () => setRevision((value) => value + 1));
+			}, [props.subscribeEvents, sessionId]);
+
+			// A long session opens with only the TAIL of its log: `eventSource`
+			// is a contiguous window and `hasMore` reports older events. Without
+			// paging, a 28-round session lists 4 rounds — the window, not the
+			// whole conversation. This effect pulls every page in.
+			React.useEffect(() => {
+				if (typeof props.loadFullHistory !== "function") return undefined;
+				if (sessionId === undefined || sessionId === null) return undefined;
+				let cancelled = false;
+				setLoading(true);
+				props
+					.loadFullHistory(sessionId)
+					.then(() => {
+						if (!cancelled) setPages((value) => value + 1);
+					})
+					.catch(() => {})
+					.then(() => {
+						if (!cancelled) setLoading(false);
+					});
+				return () => {
+					cancelled = true;
+				};
+			}, [props.loadFullHistory, sessionId]);
+
+			const window = React.useMemo(
+				() => (typeof read === "function" ? read(sessionId) : { rounds: [], hasMore: false }),
+				[read, sessionId, rowsKey, pages, revision]
+			);
+
+			const rounds = window.rounds;
+			const hasMore = window.hasMore === true;
+
+			const total = rounds.reduce((sum, round) => sum + round.tokens, 0);
+
+			// Selection is keyed by the round's START SEQ, never by its index.
+			// An index is a position in the currently loaded list, and that list
+			// re-numbers whenever older pages arrive or a compaction lands: a
+			// selection made against the previous list would then name a
+			// different round, and the panel would seed a command for the wrong
+			// span (observed: row "#15 seq 9426" produced `drop seq 8055-8310`).
+			// Seqs are durable identities, so a selection survives re-numbering.
+			const selectedRounds = rounds.filter((round) => selected.has(round.startSeq));
+			const selectedTokens = selectedRounds.reduce((sum, round) => sum + round.tokens, 0);
+
+			const toggle = (startSeq) => {
+				setOutcome(null);
+				setSelected((previous) => {
+					const next = new Set(previous);
+					if (next.has(startSeq)) next.delete(startSeq);
+					else next.add(startSeq);
+					return next;
+				});
+			};
+
+			const clear = () => {
+				setSelected(new Set());
+				setOutcome(null);
+			};
+
+			const runPrune = async () => {
+				if (selectedRounds.length === 0 || busy) return;
+				setBusy(true);
+				setOutcome(null);
+				try {
+					const result = await prune(sessionId, selectedRounds, inputActions);
+					if (result?.kind === "error") {
+						setOutcome({ kind: "error", text: result.text });
+					} else {
+						setSelected(new Set());
+						setOutcome({ kind: "ok", text: result?.text ?? "Pruned." });
+					}
+				} catch (error) {
+					setOutcome({ kind: "error", text: String(error?.message ?? error) });
+				}
+				setBusy(false);
+			};
+
+			if (sessionId === undefined || sessionId === null) {
+				return h(Notice, { children: "Select a session to inspect its context." });
+			}
+			if (rounds.length === 0) {
+				// Distinguish "still loading" from "genuinely empty": the same
+				// branch covers a window that has not arrived yet, and telling
+				// the user a session has no history while it is still paging in
+				// is a wrong diagnosis.
+				return h(Notice, {
+					children:
+						hasMore || loading
+							? "Still loading this session's history…"
+							: "This session has no conversation history yet."
+				});
+			}
+
+			return jsxs("div", {
+				style: { display: "flex", flexDirection: "column", height: "100%", minHeight: 0, fontSize: "13px" },
+				key: "pruner-root",
+				children: [
+					// Header: totals plus the selection summary.
+					jsxs("div", {
+						style: {
+							padding: "10px 12px",
+							borderBottom: "1px solid rgba(128,128,128,0.25)",
+							display: "flex",
+							flexDirection: "column",
+							gap: "6px",
+							flex: "none"
+						},
+						key: "header",
+						children: [
+							jsxs("div", {
+								style: { display: "flex", justifyContent: "space-between", gap: "8px", opacity: 0.75 },
+								key: "totals",
+								children: [
+									h("span", {
+										key: "count",
+										children: `${rounds.length} round${rounds.length === 1 ? "" : "s"}${hasMore || loading ? " (loading older…)" : ""}`
+									}),
+									h("span", { children: `~${formatTokens(total)} tok total`, key: "tokens" })
+								]
+							}),
+							// Never present a partial window as the whole
+							// conversation: if older pages are still outstanding the
+							// listing is silently under-reporting, and a reader
+							// choosing what to prune would be working from a
+							// truncated view.
+							hasMore
+								? h("div", {
+										key: "partial",
+										style: { fontSize: "12px", opacity: 0.75, lineHeight: "1.4" },
+										children:
+											"Showing the newest part of this session only; older history is still loading. Rounds below are numbered from the loaded window."
+									})
+								: null,
+							jsxs("div", {
+								style: { display: "flex", gap: "8px", alignItems: "center", flexWrap: "wrap" },
+								key: "actions",
+								children: [
+									h("button", {
+										key: "prune",
+										type: "button",
+										disabled: busy || selectedRounds.length === 0,
+										onClick: runPrune,
+										style: {
+											padding: "5px 12px",
+											borderRadius: "6px",
+											border: "1px solid rgba(128,128,128,0.35)",
+											background: selectedRounds.length === 0 ? "transparent" : "var(--dsw-alias-bg-accent, #3b6fe0)",
+											color: selectedRounds.length === 0 ? "inherit" : "#fff",
+											cursor: busy || selectedRounds.length === 0 ? "default" : "pointer",
+											opacity: busy || selectedRounds.length === 0 ? 0.5 : 1,
+											fontSize: "12px"
+										},
+										children: busy
+											? "Preparing…"
+											: selectedRounds.length === 0
+												? "Prepare prune"
+												: `Prepare prune (${selectedRounds.length})`
+									}),
+									h("button", {
+										key: "clear",
+										type: "button",
+										disabled: busy || selectedRounds.length === 0,
+										onClick: clear,
+										style: {
+											background: "none",
+											border: "none",
+											cursor: selectedRounds.length === 0 ? "default" : "pointer",
+											opacity: selectedRounds.length === 0 ? 0.35 : 0.75,
+											fontSize: "12px",
+											color: "inherit",
+											padding: 0
+										},
+										children: "Clear"
+									}),
+									selectedRounds.length > 0
+										? h("span", {
+												key: "frees",
+												style: { opacity: 0.65, fontSize: "12px" },
+												children: `frees ~${formatTokens(selectedTokens)} tok`
+											})
+										: null
+								]
+							}),
+							outcome !== null
+								? h("div", {
+										key: "outcome",
+										// Announced to assistive tech: without a live
+										// region a screen-reader user gets no signal
+										// that the composer was seeded, because the
+										// change happens in a different widget.
+										role: "status",
+										"aria-live": "polite",
+										style: {
+											fontSize: "12px",
+											lineHeight: "1.4",
+											color: outcome.kind === "error" ? "var(--dsw-alias-danger, #d9534f)" : "inherit",
+											opacity: outcome.kind === "error" ? 1 : 0.9
+										},
+										children: outcome.text
+									})
+								: null
+						]
+					}),
+					// The scrollable round list, one checkbox per round.
+					h("div", {
+						key: "list",
+						style: { overflowY: "auto", flex: "1 1 auto", padding: "4px" },
+						children: rounds.map((round) => {
+							const isSelected = selected.has(round.startSeq);
+							return h("label", {
+								key: `round-${round.startSeq}`,
+								style: {
+									display: "flex",
+									gap: "8px",
+									alignItems: "flex-start",
+									padding: "6px 8px",
+									borderRadius: "6px",
+									cursor: "pointer",
+									background: isSelected ? "rgba(80,140,255,0.12)" : "transparent"
+								},
+								children: [
+									h("input", {
+										key: "box",
+										type: "checkbox",
+										checked: isSelected,
+										onChange: () => toggle(round.startSeq),
+										// The visible text is the preview alone, which
+										// omits the index/tokens/seq the meta row shows.
+										"aria-label": `Round ${round.index}, ${formatTokens(round.tokens)} tokens, seq ${round.startSeq}`,
+										style: { marginTop: "2px", flex: "none" }
+									}),
+									jsxs("span", {
+										key: "text",
+										style: { display: "flex", flexDirection: "column", gap: "2px", minWidth: 0 },
+										children: [
+											jsxs("span", {
+												key: "meta",
+												style: {
+													display: "flex",
+													gap: "8px",
+													fontSize: "11px",
+													opacity: 0.65,
+													fontVariantNumeric: "tabular-nums"
+												},
+												children: [
+													h("span", { children: `#${round.index}`, key: "idx" }),
+													h("span", { children: `${formatTokens(round.tokens)} tok`, key: "tok" }),
+													h("span", { children: `seq ${round.startSeq}`, key: "seq" }),
+													// How much of this round is harness
+													// scaffolding rather than conversation.
+													// Without it a round that is mostly job
+													// reports is indistinguishable from one
+													// that is mostly discussion.
+													round.injected > 0
+														? h("span", {
+																key: "notices",
+																children: `+${round.injected} notice${round.injected === 1 ? "" : "s"}`
+															})
+														: null
+												]
+											}),
+											h("span", {
+												key: "preview",
+												style: { fontSize: "12px", lineHeight: "1.4", wordBreak: "break-word" },
+												// The HUMAN message heads the round; a round
+												// that opens with injected context would
+												// otherwise be titled by scaffolding.
+												children: round.title ?? round.preview
+											})
+										]
+									})
+								]
+							});
+						})
+					})
+				]
+			});
+		}
+
+		/**
+		 * A muted single-line message used for empty states.
+		 *
+		 * `children` must live in the props object: the automatic JSX runtime's
+		 * `jsx(type, props)` takes two arguments, so a third positional child is
+		 * silently dropped and the component renders an empty element.
+		 *
+		 * @param props - `{ children }`.
+		 * @returns the rendered notice.
+		 */
+		function Notice(props) {
+			return h("div", {
+				style: { padding: "16px 12px", opacity: 0.6, fontSize: "13px" },
+				children: props.children
+			});
+		}
+
+		/**
+		 * The tab chip's label.
+		 *
+		 * @returns the rendered title.
+		 */
+		function ContextPrunerTitle() {
+			return h("span", { children: "Context" });
+		}
+
+		/**
+		 * Seed the composer with the prune command for the selected rounds.
+		 *
+		 * ## Why the command carries SEQS, not round indices
+		 *
+		 * A round index is only meaningful relative to whoever numbered the
+		 * rounds. The panel numbers by "genuine human turn"; the host command
+		 * numbers every user-role surface event, so its count runs higher (69
+		 * vs 66 on one real session) and the two disagree from early on —
+		 * `#9` named seq 742 to the panel and seq 608 to the host.
+		 *
+		 * Sending those indices compacted a DIFFERENT span than the one the user
+		 * selected, with nothing in the UI revealing it. Surface seqs are durable
+		 * identifiers both sides agree on, so the panel sends
+		 * `/prune drop seq <start>-<end> --yes`.
+		 *
+		 * @param ctx - client root context.
+		 * @param sessionId - session to act on.
+		 * @param rounds - the selected round objects (they carry startSeq/endSeq).
+		 * @param inputActions - the composer's own draft/submit actions.
+		 * @returns `{ kind: 'ok' | 'error', text }`.
+		 */
+		async function pruneRounds(ctx, sessionId, rounds, inputActions) {
+			if (!Array.isArray(rounds) || rounds.length === 0) {
+				return { kind: "ok", text: "Nothing selected." };
+			}
+
+			// The manual fallback deliberately names the SEQ form. The round-index
+			// form (`drop 3-7`) is the one the host and this panel used to number
+			// differently, and it is not what any row in this list displays, so
+			// instructing the user to type it would send them back into the
+			// wrong-span bug this panel was fixed for.
+			const fallback =
+				"This panel cannot reach the composer, so it cannot seed the command. " +
+				"Either retry Prepare prune, or type it yourself using the seq shown on each row: " +
+				"/prune drop seq <startSeq>-<endSeq> --yes";
+
+			// A slash command is NOT a chat message: `conversation.sendSession`
+			// would deliver it as an ordinary prompt, and the model would answer
+			// that it has no such tool. Only the composer's own draft/submit path
+			// participates in the command transaction.
+			const actions = inputActions;
+			if (
+				actions === undefined ||
+				actions === null ||
+				typeof actions.setDraft !== "function"
+			) {
+				return { kind: "error", text: fallback };
+			}
+
+			// Contiguous runs of SELECTED rounds become one seq span each, so a
+			// scattered selection never swallows the unselected rounds between
+			// them. Selecting 6, 9, 10, 11 yields two spans: `6-6` and `9-11`.
+			const sorted = [...rounds].sort((a, b) => a.index - b.index);
+			const ranges = [];
+			let current = null;
+			for (const round of sorted) {
+				if (current === null) {
+					current = { first: round, last: round };
+					continue;
+				}
+				// Contiguous only when the round indices are adjacent; their seqs
+				// are not required to be.
+				if (round.index === current.last.index + 1) {
+					current.last = round;
+				} else {
+					ranges.push(current);
+					current = { first: round, last: round };
+				}
+			}
+			if (current !== null) ranges.push(current);
+
+			// EVERY span rides one command: the host accepts a comma-separated
+			// list, so a scattered selection is one Enter rather than one per
+			// range. Seeding only the first (an earlier limitation) left the
+			// user to run the rest by hand.
+			const spec = ranges
+				.map((range) => `seq ${range.first.startSeq}-${range.last.endSeq}`)
+				.join(", ");
+			const line = `/prune drop ${spec} --yes`;
+
+			try {
+				actions.setDraft(line);
+			} catch (error) {
+				return { kind: "error", text: `Could not seed the composer: ${String(error?.message ?? error)}` };
+			}
+
+			// We deliberately do NOT call submit(): a programmatic submit does
+			// not execute a slash command (verified: no `command/run` event is
+			// produced), and delivering the text as a prompt instead would cost
+			// a model turn and answer nonsense. Command dispatch belongs to the
+			// composer's own Enter transaction, so the panel seeds the line and
+			// hands the trigger to the user.
+			//
+			// The message names the action's destructiveness and states that
+			// nothing has happened yet. An earlier wording ("Ready: <line> —
+			// press Enter") read as a completed step, and the line itself ends
+			// in `--yes`, so a user skimming it could commit an irreversible
+			// replacement without a second look.
+			return {
+				kind: "ok",
+				text: [
+					`Nothing has changed yet. ${ranges.length === 1 ? "A command is" : `${ranges.length} spans are`} ready in the input box:`,
+					line,
+					"Press Enter there to run it. This REPLACES those rounds with one summary and cannot be undone."
+				].join("\n")
+			};
+		}
+
+		/**
+		 * Register the tab type and its body/title seats.
+		 *
+		 * Stage one declares the type; stage two supplies the body and chip
+		 * under the definition's `id` in the keyed seats.
+		 *
+		 * The `inject` face is the pattern the shipped sidebar tabs use: the
+		 * registration hands the component its data-reading closure instead of
+		 * letting the component reach for services, so the component stays pure
+		 * and the service dependency is declared where it is resolved.
+		 *
+		 * @param ctx - client root context.
+		 */
+		function apply(ctx) {
+			// `inject` must be a FACTORY, not a plain object: the slot framework
+			// calls it as `inject(sessionId, actions)` and spreads the returned
+			// object onto the component's props. Passing an object throws
+			// `TypeError: inject is not a function` inside the renderer, which
+			// leaves the pane blank — the exact failure this shape fixes.
+			// The shipped tab providers do the same (`filesFace(...)` returns a
+			// `(sessionId, actions) => ({...})` closure).
+			const injectFace = (sessionId) => ({
+				// `readRounds` reports `hasMore` alongside the rounds, so the
+				// panel can tell "this is the whole conversation" from "this is
+				// the window we happen to have loaded".
+				readRounds: (id) => {
+					const target = id ?? sessionId;
+					const window = readWindow(ctx, target);
+					return readRounds(window.entries, window.hasMore);
+				},
+				loadFullHistory: (id) => loadFullHistory(ctx, id ?? sessionId),
+				// `ObservableSnapshot.subscribe` publishes on every accepted
+				// window mutation, which is what makes the list follow a
+				// compaction instead of freezing on stale rounds.
+				subscribeEvents: (id, listener) => {
+					const source = eventSource(ctx, id ?? sessionId);
+					if (source === undefined || typeof source.subscribe !== "function") return undefined;
+					return source.subscribe(listener);
+				},
+				pruneRounds: (id, rounds, actions) => pruneRounds(ctx, id ?? sessionId, rounds, actions)
+			});
+
+			ctx.effect(
+				() =>
+					ctx.slots.inject("sidebar.right.pane.tab", () =>
+						ctx.slots.register(
+							{ name: "sidebar.right.pane.tab", key: TAB_ID, inject: injectFace },
+							ContextPrunerBody
+						)
+					),
+				"context-pruner: tab body"
+			);
+
+			ctx.effect(
+				() =>
+					ctx.slots.inject("sidebar.right.pane.tab.title", () =>
+						ctx.slots.register(
+							{ name: "sidebar.right.pane.tab.title", key: TAB_ID },
+							ContextPrunerTitle
+						)
+					),
+				"context-pruner: tab title"
+			);
+
+			ctx.effect(
+				() =>
+					ctx.sidebarRightTabs.register({
+						id: TAB_ID,
+						kind: TAB_KIND,
+						// The shipped tab types declare a band; the default is
+						// `extension`, which is the band that takes over another
+						// type's kind. Declaring `builtin` keeps this row's
+						// conflict semantics identical to a shipped tab.
+						priority: "builtin",
+						title: () => "Context",
+						// Registering a type does NOT open a tab: the strip stays
+						// empty until something calls `openTab(kind)`. The guide
+						// is the sidebar's own "open a page" surface, so an entry
+						// here is what makes the tab reachable without a command
+						// or a rebuilt shell.
+						guide: [
+							{
+								// Distinct from TAB_ID, matching the shipped
+								// pattern (`sidebar-files` uses id "workspace"
+								// with type id `FILES_ID`). Sharing the two made
+								// the guide card and the tab type collide on one
+								// identity, which the registry reports as a
+								// duplicate id.
+								id: "context-pruner-guide",
+								order: 60,
+								title: () => "Context",
+								description: () => "Inspect conversation rounds and prune the ones you choose"
+							}
+						]
+					}),
+				"context-pruner: tab type"
+			);
+		}
+
+		exports.apply = apply;
+		exports.inject = inject;
+		return module.exports;
+	}
+});