pi-context-view 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dmitry Makarov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,47 @@
+# pi-context-view
+
+![Context usage map](doc/images/pi-context-view.png)
+
+A pi extension that visualizes what fills the model's context and lets
+you inspect the parts you normally can't see: the base prompt, tool
+definitions, and instructions injected by other extensions.
+
+## Features
+
+- **Context usage map** - visualize used and free context space, grouped by
+  category (tools, skills, messages, and more).
+
+- **Context injections** - explore the hidden pieces of the context: the
+  initial prompt, tool definitions, and extension injections.
+
+## Commands
+
+- `/context` - shorthand for `/context usage`.
+- `/context usage` - open the context usage visualization.
+- `/context injections` - show the hidden content of the context at session
+  start or resume.
+
+## Install
+
+```bash
+pi install npm:pi-context-view
+```
+
+### Usage Examples
+
+- Inspect context composition after compaction:
+
+  ![Context usage view and category preview](doc/images/context-usage.png)
+
+- Inspect hidden parts of the context, such as tool definitions:
+
+  ![Context injections view and item preview](doc/images/context-injections.png)
+
+## Context
+
+`pi-context-view` does not add any instructions or messages to the model
+context.
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,53 @@
+{
+	"name": "pi-context-view",
+	"version": "0.2.0",
+	"description": "Pi extension to visualize context token usage and inspect hidden prompt, tool, and extension injections via /context",
+	"type": "module",
+	"license": "MIT",
+	"author": "Dmitry Makarov",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/dimk90/pi-context-view.git"
+	},
+	"homepage": "https://github.com/dimk90/pi-context-view#readme",
+	"bugs": {
+		"url": "https://github.com/dimk90/pi-context-view/issues"
+	},
+	"keywords": [
+		"pi",
+		"pi-extension",
+		"pi-package",
+		"coding-agent",
+		"context",
+		"tokens",
+		"tui"
+	],
+	"engines": {
+		"node": ">=22.19.0"
+	},
+	"files": [
+		"src",
+		"doc/images",
+		"README.md"
+	],
+	"scripts": {
+		"test": "node --test test/*.test.ts",
+		"check": "tsc --noEmit && npm test"
+	},
+	"pi": {
+		"extensions": [
+			"./src/index.ts"
+		],
+		"image": "https://media.githubusercontent.com/media/dimk90/pi-context-view/c1ff8949d340d94d6c9b40819ad4ff78aa2114cc/doc/images/pi-context-view.png"
+	},
+	"peerDependencies": {
+		"@earendil-works/pi-coding-agent": "*",
+		"@earendil-works/pi-tui": "*"
+	},
+	"devDependencies": {
+		"@earendil-works/pi-coding-agent": "0.80.6",
+		"@earendil-works/pi-tui": "0.80.6",
+		"@types/node": "^22.20.1",
+		"typescript": "^7.0.2"
+	}
+}

package/src/capture.ts

@@ -0,0 +1,396 @@
+/**
+ * Initial capture state and conversion from pi event data to the semantic
+ * model. Event registration remains in index.ts; this module is independently
+ * unit-testable.
+ */
+import {
+	type BuildSystemPromptOptions,
+	type ContextEvent,
+	estimateTokens,
+	type InputSource,
+	type ToolInfo,
+} from "@earendil-works/pi-coding-agent";
+
+import { analyzeSystemPrompt, type PromptOptionsSlice, type ToolSlice } from "./measure.ts";
+import {
+	AGGREGATE_SOURCE_ID,
+	buildSnapshot,
+	type CaptureOrigin,
+	type InitialSnapshot,
+	type InjectionItem,
+	type InjectionSource,
+} from "./model.ts";
+
+const DEFAULT_PROBE_TIMEOUT_MS = 5_000;
+const AGGREGATE_SOURCE: InjectionSource = {
+	id: AGGREGATE_SOURCE_ID,
+	label: "extensions (aggregate)",
+	native: false,
+};
+
+/** Everything available when the first context event finalizes a snapshot. */
+export interface CaptureFinalization {
+	systemPrompt: string;
+	messages: ContextEvent["messages"];
+	baselineMessages: ContextEvent["messages"];
+	allTools: readonly ToolInfo[];
+	activeToolNames: readonly string[];
+	origin: CaptureOrigin;
+	capturedAt?: Date;
+}
+
+/** Inputs for an on-demand pi-native prompt/tool snapshot. */
+export interface NativeSnapshotInput {
+	systemPrompt: string;
+	options: BuildSystemPromptOptions;
+	allTools: readonly ToolInfo[];
+	activeToolNames: readonly string[];
+	capturedAt?: Date;
+}
+
+/** Result of the one allowed silent-probe attempt. */
+export type ProbeOutcome =
+	| { readonly status: "captured" }
+	| { readonly status: "failed"; readonly reason: string };
+
+/** A probe start request; concurrent callers share `completion`. */
+export interface ProbeAttempt {
+	readonly started: boolean;
+	readonly completion: Promise<ProbeOutcome>;
+}
+
+/** Exact identity used to remove only synthetic probe messages. */
+export interface SyntheticMessageIdentity {
+	readonly role: "user" | "assistant";
+	readonly timestamp: number;
+}
+
+/** Owned structured inputs prepared before later extension handlers can mutate shared event data. */
+interface CapturePreparation {
+	readonly promptOptions: PromptOptionsSlice;
+	readonly toolSnippets?: Readonly<Record<string, string>>;
+}
+
+/** Lifecycle of the single probe attempt, including ownership retained after its completion times out. */
+type ProbePhase =
+	| "idle"
+	| "waiting"
+	| "waiting-after-timeout"
+	| "running"
+	| "running-after-timeout"
+	| "failed"
+	| "settled";
+
+/**
+ * Capture-once state machine. `prepare()` refreshes the structured options on
+ * every run until `finalize()` succeeds; subsequent finalizations return the
+ * original snapshot unchanged.
+ */
+export class InitialCaptureState {
+	private pendingPreparation: CapturePreparation | undefined;
+	private initialSnapshot: InitialSnapshot | undefined;
+
+	/** The frozen Initial snapshot, or undefined until `finalize()` succeeds. */
+	public get snapshot(): InitialSnapshot | undefined {
+		return this.initialSnapshot;
+	}
+
+	/** Own the structured prompt inputs from `before_agent_start`; no-op once frozen. */
+	public prepare(options: BuildSystemPromptOptions): void {
+		if (this.initialSnapshot !== undefined) return;
+		this.pendingPreparation = {
+			promptOptions: copyPromptOptions(options),
+			toolSnippets: options.toolSnippets === undefined ? undefined : { ...options.toolSnippets },
+		};
+	}
+
+	/**
+	 * Freeze the Initial snapshot from the first context event. Returns the
+	 * existing snapshot on repeat calls, or undefined when `prepare()` never ran.
+	 */
+	public finalize(input: CaptureFinalization): InitialSnapshot | undefined {
+		if (this.initialSnapshot !== undefined) return this.initialSnapshot;
+		if (this.pendingPreparation === undefined) return undefined;
+
+		const preparation = this.pendingPreparation;
+		const tools = captureActiveTools(input.allTools, input.activeToolNames, {
+			toolSnippets: preparation.toolSnippets,
+		});
+		const items = [
+			...analyzeSystemPrompt(input.systemPrompt, preparation.promptOptions, tools),
+			...measureInjectedMessages(input.messages, input.baselineMessages),
+		];
+		this.initialSnapshot = buildSnapshot(items, input.origin, input.capturedAt ?? new Date());
+		this.pendingPreparation = undefined;
+		return this.initialSnapshot;
+	}
+}
+
+/**
+ * State for one on-demand silent probe. It owns the timeout and exact synthetic
+ * message identities, but leaves pi API calls and UI restoration to index.ts.
+ */
+export class SilentProbeState {
+	private phase: ProbePhase = "idle";
+	private inputObserved = false;
+	private readonly identities = new Map<string, SyntheticMessageIdentity>();
+	private completion: Promise<ProbeOutcome> | undefined;
+	private resolveCompletion: ((outcome: ProbeOutcome) => void) | undefined;
+	private outcome: ProbeOutcome | undefined;
+	private timeout: NodeJS.Timeout | undefined;
+
+	/** True while the probe owns the in-flight agent run (including after a timeout). */
+	public get isCurrentRun(): boolean {
+		return this.phase === "running" || this.phase === "running-after-timeout";
+	}
+
+	/** Defensive copies of the recorded probe message identities. */
+	public get syntheticMessages(): readonly SyntheticMessageIdentity[] {
+		return [...this.identities.values()].map((identity) => ({ ...identity }));
+	}
+
+	/**
+	 * Begin the one allowed probe attempt with a failure timeout. Repeat calls
+	 * return the original attempt's completion with `started: false`.
+	 */
+	public start(timeoutMs = DEFAULT_PROBE_TIMEOUT_MS): ProbeAttempt {
+		if (this.completion !== undefined) {
+			return { started: false, completion: this.completion };
+		}
+
+		this.phase = "waiting";
+		this.completion = new Promise<ProbeOutcome>((resolve) => {
+			this.resolveCompletion = resolve;
+		});
+		this.timeout = setTimeout(() => {
+			if (this.phase === "waiting") {
+				this.phase = "waiting-after-timeout";
+			} else if (this.phase === "running") {
+				this.phase = "running-after-timeout";
+			}
+			this.resolve({ status: "failed", reason: "Silent probe timed out." });
+		}, timeoutMs);
+		return { started: true, completion: this.completion };
+	}
+
+	/** Mark the exact extension-originated empty input that starts the probe. */
+	public observeInput(source: InputSource, text: string): void {
+		const awaitingInput = this.phase === "waiting" || this.phase === "waiting-after-timeout";
+		if (awaitingInput && source === "extension" && text === "") this.inputObserved = true;
+	}
+
+	/** Associate the next matching lifecycle with the probe, not a real turn. */
+	public beginRun(prompt: string): boolean {
+		const ownsPendingInput = this.phase === "waiting" || this.phase === "waiting-after-timeout";
+		if (!ownsPendingInput || !this.inputObserved || prompt !== "") return false;
+		this.phase = this.phase === "waiting-after-timeout" ? "running-after-timeout" : "running";
+		return true;
+	}
+
+	/** Record probe user/assistant identities as their message events arrive. */
+	public recordMessage(message: ContextEvent["messages"][number]): void {
+		if (!this.isCurrentRun || (message.role !== "user" && message.role !== "assistant")) return;
+		const identity = { role: message.role, timestamp: message.timestamp } satisfies SyntheticMessageIdentity;
+		this.identities.set(identityKey(identity), identity);
+	}
+
+	/**
+	 * Replace only the probe's aborted assistant with an empty successful message
+	 * so pi does not render an "Operation aborted" transcript row.
+	 */
+	public sanitizeAssistant(
+		message: ContextEvent["messages"][number],
+	): ContextEvent["messages"][number] | undefined {
+		if (!this.isCurrentRun || message.role !== "assistant" || message.stopReason !== "aborted") {
+			return undefined;
+		}
+		this.recordMessage(message);
+		const identity = { role: "assistant", timestamp: message.timestamp } satisfies SyntheticMessageIdentity;
+		if (!this.identities.has(identityKey(identity))) return undefined;
+		return { ...message, content: [], stopReason: "stop", errorMessage: undefined };
+	}
+
+	/** Remove only messages whose exact role+timestamp identity belongs to the probe. */
+	public filterMessages(messages: ContextEvent["messages"]): ContextEvent["messages"] {
+		if (this.identities.size === 0) return messages;
+		return messages.filter((message) => {
+			if (message.role !== "user" && message.role !== "assistant") return true;
+			return !this.identities.has(identityKey(message));
+		});
+	}
+
+	/** Resolve a running attempt from `agent_settled`. */
+	public settle(captured: boolean): boolean {
+		if (!this.isCurrentRun) return false;
+		this.phase = "settled";
+		if (this.outcome === undefined) {
+			this.resolve(
+				captured
+					? { status: "captured" }
+					: { status: "failed", reason: "Silent probe settled without a context snapshot." },
+			);
+		}
+		return true;
+	}
+
+	/** End a pending attempt during shutdown or a synchronous startup failure. */
+	public fail(reason: string): void {
+		if (this.completion === undefined || this.phase === "failed" || this.phase === "settled") return;
+		this.phase = "failed";
+		if (this.outcome === undefined) this.resolve({ status: "failed", reason });
+	}
+
+	/** Settle the completion promise exactly once and clear the timeout. */
+	private resolve(outcome: ProbeOutcome): void {
+		if (this.outcome !== undefined) return;
+		if (this.timeout !== undefined) clearTimeout(this.timeout);
+		this.timeout = undefined;
+		this.outcome = outcome;
+		const resolve = this.resolveCompletion;
+		this.resolveCompletion = undefined;
+		resolve?.(outcome);
+	}
+}
+
+/** Build a view-local pi-native snapshot without freezing the main capture state. */
+export function buildNativeSnapshot(input: NativeSnapshotInput): InitialSnapshot {
+	const options = copyPromptOptions(input.options);
+	const tools = captureActiveTools(input.allTools, input.activeToolNames, input.options);
+	const items = analyzeSystemPrompt(input.systemPrompt, options, tools);
+	return buildSnapshot(items, "synthetic-probe", input.capturedAt ?? new Date());
+}
+
+/** Add frozen context-only messages to a current prompt/tool snapshot for Usage. */
+export function mergeContextOnlyMessages(
+	snapshot: InitialSnapshot,
+	initial: InitialSnapshot,
+): InitialSnapshot {
+	const contextOnly = initial.groups.flatMap((group) =>
+		group.items.filter((item) => item.kind === "message" && item.contextOnly === true)
+	);
+	if (contextOnly.length === 0) return snapshot;
+	const items = [
+		...snapshot.groups.flatMap((group) => group.items),
+		...contextOnly,
+	];
+	return buildSnapshot(items, snapshot.origin, snapshot.capturedAt);
+}
+
+/** Copy the prompt-options slice used by measurement, without shared nested references. */
+export function copyPromptOptions(options: BuildSystemPromptOptions): PromptOptionsSlice {
+	return {
+		cwd: options.cwd,
+		homeDir: process.env.HOME,
+		customPrompt: options.customPrompt,
+		appendSystemPrompt: options.appendSystemPrompt,
+		contextFilePaths: options.contextFiles?.map((file) => file.path),
+		skills: options.skills
+			?.filter((skill) => !skill.disableModelInvocation)
+			.map((skill) => ({
+				name: skill.name,
+				description: skill.description,
+				filePath: skill.filePath,
+			})),
+	};
+}
+
+/** Snapshot the final active tool set with provenance and payload definitions. */
+export function captureActiveTools(
+	allTools: readonly ToolInfo[],
+	activeToolNames: readonly string[],
+	options: { readonly toolSnippets?: Readonly<Record<string, string>> },
+): ToolSlice[] {
+	const active = new Set(activeToolNames);
+	return allTools
+		.filter((tool) => active.has(tool.name))
+		.map((tool) => ({
+			name: tool.name,
+			description: tool.description,
+			parametersJson: JSON.stringify(tool.parameters ?? {}),
+			snippet: options.toolSnippets?.[tool.name],
+			guidelines: normalizeGuidelines(tool.promptGuidelines),
+			source: tool.sourceInfo.source,
+		}));
+}
+
+/**
+ * Measure extension messages while excluding ordinary session history. Custom
+ * messages remain attributable by customType; other roles are captured only
+ * when they differ from the session-branch baseline.
+ */
+export function measureInjectedMessages(
+	messages: ContextEvent["messages"],
+	baselineMessages: ContextEvent["messages"],
+): InjectionItem[] {
+	const baseline = messageSignatureCounts(baselineMessages);
+	const occurrences = new Map<string, number>();
+	const items: InjectionItem[] = [];
+	for (const message of messages) {
+		const contextOnly = !consumeMessageSignature(baseline, message);
+		if (message.role !== "custom" && !contextOnly) continue;
+
+		const identity = message.role === "custom" ? message.customType : message.role;
+		const occurrence = occurrences.get(identity) ?? 0;
+		occurrences.set(identity, occurrence + 1);
+		const text = messageText(message);
+		items.push({
+			id: message.role === "custom"
+				? `message:${message.customType}:${occurrence}`
+				: `message:context:${message.role}:${occurrence}`,
+			phase: "initial",
+			kind: "message",
+			source: message.role === "custom" ? messageSource(message.customType) : AGGREGATE_SOURCE,
+			label: message.role === "custom" ? "message" : `${message.role} message`,
+			chars: text.length,
+			tokens: estimateTokens(message),
+			text,
+			contextOnly: contextOnly || undefined,
+		});
+	}
+	return items;
+}
+
+/** Count structurally identical baseline messages for order-independent diffing. */
+function messageSignatureCounts(messages: ContextEvent["messages"]): Map<string, number> {
+	const counts = new Map<string, number>();
+	for (const message of messages) {
+		const signature = JSON.stringify(message);
+		counts.set(signature, (counts.get(signature) ?? 0) + 1);
+	}
+	return counts;
+}
+
+/** Consume one matching baseline occurrence, returning false for a context-only message. */
+function consumeMessageSignature(
+	counts: Map<string, number>,
+	message: ContextEvent["messages"][number],
+): boolean {
+	const signature = JSON.stringify(message);
+	const count = counts.get(signature) ?? 0;
+	if (count === 0) return false;
+	if (count === 1) counts.delete(signature);
+	else counts.set(signature, count - 1);
+	return true;
+}
+
+/** Extract provider-bound message content for raw preview. */
+function messageText(message: ContextEvent["messages"][number]): string {
+	if (!("content" in message)) return JSON.stringify(message);
+	return typeof message.content === "string" ? message.content : JSON.stringify(message.content);
+}
+
+/** Map key uniquely identifying one probe message by role and timestamp. */
+function identityKey(identity: SyntheticMessageIdentity): string {
+	return `${identity.role}:${identity.timestamp}`;
+}
+
+/** Attribute a custom-role message to its customType; the actual injector is unknowable. */
+function messageSource(customType: string): InjectionSource {
+	return { id: `message-type:${customType}`, label: customType, native: false };
+}
+
+/** Normalize the string-or-array promptGuidelines field to an owned array. */
+function normalizeGuidelines(guidelines: string | string[] | undefined): string[] {
+	if (guidelines === undefined) return [];
+	return Array.isArray(guidelines) ? [...guidelines] : [guidelines];
+}

package/src/command.ts

@@ -0,0 +1,134 @@
+/**
+ * `/context` command grammar, argument completions, and Initial capture
+ * resolution shared by the Usage and Injections views.
+ */
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import type { AutocompleteItem } from "@earendil-works/pi-tui";
+
+import {
+	buildNativeSnapshot,
+	type InitialCaptureState,
+	type SilentProbeState,
+} from "./capture.ts";
+import type { InitialSnapshot } from "./model.ts";
+
+const COMMAND_USAGE = "Usage: /context [usage|injections]";
+const DEFAULT_VIEW: ContextView = "usage";
+const ARGUMENT_OPTIONS = [
+	{ value: "usage", label: "usage", description: "Show estimated context usage" },
+	{ value: "injections", label: "injections", description: "Explore initial context injections" },
+] satisfies AutocompleteItem[];
+
+/** The focused view a `/context` invocation requests. */
+export type ContextView = "usage" | "injections";
+
+/** Parsed `/context` argument grammar. */
+export type ContextCommand =
+	| { readonly type: "view"; readonly view: ContextView }
+	| { readonly type: "invalid"; readonly message: string };
+
+/** Resolved Initial capture, possibly degraded to the pi-native fallback. */
+export interface InitialCaptureResult {
+	readonly snapshot: InitialSnapshot;
+	readonly degradedReason?: string;
+}
+
+/** Parse the complete, intentionally small `/context` argument grammar. */
+export function parseContextCommand(argumentsText: string): ContextCommand {
+	const words = argumentsText.trim().toLowerCase().split(/\s+/).filter(Boolean);
+	if (words.length === 0) {
+		return { type: "view", view: DEFAULT_VIEW };
+	}
+	if (words.length === 1 && words[0] === "usage") {
+		return { type: "view", view: "usage" };
+	}
+	if (words.length === 1 && words[0] === "injections") {
+		return { type: "view", view: "injections" };
+	}
+	return { type: "invalid", message: COMMAND_USAGE };
+}
+
+/** Complete full argument values for the supported `/context` grammar. */
+export function getContextArgumentCompletions(argumentPrefix: string): AutocompleteItem[] | null {
+	const normalizedPrefix = argumentPrefix.trimStart().toLowerCase();
+	const matches = ARGUMENT_OPTIONS.filter((option) => option.value.startsWith(normalizedPrefix));
+	return matches.length > 0 ? matches.map((option) => ({ ...option })) : null;
+}
+
+/** Obtain Initial through passive capture, one silent probe, or a pi-native fallback. */
+export async function resolveInitialCapture(
+	pi: ExtensionAPI,
+	capture: InitialCaptureState,
+	probe: SilentProbeState,
+	context: ExtensionCommandContext,
+): Promise<InitialCaptureResult> {
+	if (capture.snapshot !== undefined) return { snapshot: capture.snapshot };
+
+	await context.waitForIdle();
+	if (capture.snapshot !== undefined) return { snapshot: capture.snapshot };
+
+	const unavailableReason = getProbeUnavailableReason(context);
+	if (unavailableReason !== undefined) {
+		return createFallback(pi, context, unavailableReason);
+	}
+
+	const attempt = probe.start();
+	if (attempt.started) {
+		context.ui.setWorkingVisible(false);
+		try {
+			pi.sendUserMessage("");
+		} catch (error) {
+			probe.fail(error instanceof Error ? error.message : String(error));
+		}
+	}
+
+	try {
+		const outcome = await attempt.completion;
+		if (outcome.status === "captured" && capture.snapshot !== undefined) {
+			return { snapshot: capture.snapshot };
+		}
+		const reason = outcome.status === "failed" ? outcome.reason : "Silent probe did not capture Initial.";
+		return createFallback(pi, context, reason);
+	} finally {
+		if (attempt.started) context.ui.setWorkingVisible(true);
+	}
+}
+
+/** Report command errors in both interactive and headless modes. */
+export function reportCommandMessage(
+	context: ExtensionCommandContext,
+	message: string,
+	type: "info" | "warning" | "error",
+): void {
+	if (context.hasUI) {
+		context.ui.notify(message, type);
+		return;
+	}
+	process.stderr.write(`${message}\n`);
+}
+
+/** Explain why a silent probe cannot run now, or undefined when it can. */
+function getProbeUnavailableReason(context: ExtensionCommandContext): string | undefined {
+	if (context.model === undefined) return "Silent probe unavailable: no model is selected.";
+	if (!context.modelRegistry.hasConfiguredAuth(context.model)) {
+		return `Silent probe unavailable: ${context.model.provider} has no configured authentication.`;
+	}
+	return undefined;
+}
+
+/** Build a degraded pi-native snapshot when passive capture and probing both failed. */
+function createFallback(
+	pi: ExtensionAPI,
+	context: ExtensionCommandContext,
+	reason: string,
+): InitialCaptureResult {
+	return {
+		snapshot: buildNativeSnapshot({
+			systemPrompt: context.getSystemPrompt(),
+			options: context.getSystemPromptOptions(),
+			allTools: pi.getAllTools(),
+			activeToolNames: pi.getActiveTools(),
+		}),
+		degradedReason: `${reason} Extension additions were not observed.`,
+	};
+}