@huseynsnmz/pi-suite 0.1.0 → 0.2.0

package/packages/frame/src/index.ts

@@ -17,7 +17,7 @@ import {
 	type SessionSource,
 	skillNames,
 	sourceFor,
-} from "@adeildo/pi-kit";
+} from "./kit/index.ts";
 import type {
 	ExtensionAPI,
 	ExtensionContext,
@@ -28,7 +28,7 @@ import { Key, type KeyId, type TUI } from "@earendil-works/pi-tui";
 
 import { type GitState, readGit } from "./data/git.ts";
 import { cmdAsKey, SETTINGS_SHORTCUT, watchCmdKey } from "./render/keys.ts";
-import { frameColorOf } from "./data/mode.ts";
+import { frameColorOf, type Mode, modeOf, SENT_IN_ENTRY, sentInFromEntries } from "./data/mode.ts";
 import { type GithubState, readGithub } from "./data/github.ts";
 import { emptySnapshot, type LiveInputs, type Snapshot, SnapshotReader } from "./data/snapshot.ts";
 import type { LastVisit } from "./data/start-notes.ts";
@@ -126,6 +126,8 @@ export const frameFeature = defineFeature({
 		registerToolFrames(scope);
 		registerEffort(scope);
 		registerTodos(scope, () => glyphs().set);
+		const sentLive = new Map<string, Mode>();
+		let sentSaved = { length: -1, modes: new Map<string, Mode>() };
 		framePiEntries(() => {
 			if (live.ctx === undefined) return undefined;
 			return {
@@ -133,6 +135,12 @@ export const frameFeature = defineFeature({
 				set: glyphs().set,
 				you: userFrame.get(scope),
 				from: (text: string) => PROMPT_FROM.current(scope, text)?.name,
+				sentIn: (id: string | undefined, text: string) => {
+					if (id === undefined) return sentLive.get(text);
+					const entries = live.ctx?.sessionManager.getEntries() ?? [];
+					if (entries.length !== sentSaved.length) sentSaved = { length: entries.length, modes: sentInFromEntries(entries) };
+					return sentSaved.modes.get(id);
+				},
 			};
 		});
 		showTimings((message, width) => {
@@ -215,6 +223,7 @@ export const frameFeature = defineFeature({
 			live.ctx = ctx;
 			telemetry.reset();
 			telemetry.restore(ctx.sessionManager.getEntries());
+			sentLive.clear();
 			void probeGit(live);
 			if (ctx.mode !== "tui") return;
 
@@ -242,6 +251,17 @@ export const frameFeature = defineFeature({
 			showHeader(ctx);
 		});
 
+		scope.on("message_start", (event) => {
+			if (event.message.role !== "user") return;
+			const mode = modeOf(live.footerData?.getExtensionStatuses() ?? new Map());
+			if (mode === undefined) return;
+			const { content, timestamp } = event.message;
+			const text = typeof content === "string" ? content : content.flatMap((part) => (part.type === "text" ? [part.text] : [])).join("");
+			sentLive.set(text, mode);
+			// Normal draws as a plain message, so a resumed session needs nothing saved for it.
+			if (mode !== "normal") scope.appendEntry(SENT_IN_ENTRY, { at: timestamp, mode });
+		});
+
 		scope.onShutdown(() => {
 			stopCmdKeys?.();
 			stopCmdKeys = undefined;

package/packages/frame/src/kit/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 adeildo
+
+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/packages/frame/src/kit/app/attribution.ts

@@ -0,0 +1,30 @@
+// In the harness every feature runs inside one extension, so pi reports every failure under the
+// same name. These put the app and the feature in front of it instead.
+
+export function describe(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}
+
+// A sync function stays sync, because pi treats some handler results differently when they are
+// promises.
+export function attributed<A extends unknown[], R>(
+	label: string,
+	run: (...args: A) => R,
+): (...args: A) => R {
+	return (...args: A): R => {
+		let result: R;
+		try {
+			result = run(...args);
+		} catch (error) {
+			throw relabel(label, error);
+		}
+		if (!(result instanceof Promise)) return result;
+		return result.catch((error: unknown) => {
+			throw relabel(label, error);
+		}) as R;
+	};
+}
+
+function relabel(label: string, error: unknown): Error {
+	return new Error(`${label}: ${describe(error)}`, { cause: error });
+}

package/packages/frame/src/kit/app/builder.ts

@@ -0,0 +1,186 @@
+// `createApp(pi, ...).use(feature).build()`. Registration happens only in the factory, session work
+// from `session_start`, cleanup once per session, and a feature that fails to set up is a warning.
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+import { CHANGED } from "../contracts/screen.ts";
+import { boolean, isObject } from "../decode.ts";
+import { settingsScreen } from "../screen/feature.ts";
+import { globalSettingsPath, projectSettingsPath } from "../settings/files.ts";
+import { type Setting, type SettingsScope, setting } from "../settings/setting.ts";
+import { SettingsStore } from "../settings/store.ts";
+import { describe } from "./attribution.ts";
+import { answerClaims, ownerOf } from "./claim.ts";
+import type { Feature } from "./feature.ts";
+import { serveScreen } from "./host.ts";
+import { type AppState, createScope, type Hook } from "./scope.ts";
+
+export interface App extends SettingsScope {
+	readonly name: string;
+	readonly settings: SettingsStore;
+	has(featureId: string): boolean;
+}
+
+export interface AppOptions {
+	name: string;
+	settingsPath?: string;
+}
+
+export interface AppBuilder {
+	use(feature: Feature): AppBuilder;
+	build(): App;
+}
+
+export function createApp(pi: ExtensionAPI, options: AppOptions): AppBuilder {
+	const features: Feature[] = [];
+	const builder: AppBuilder = {
+		use(feature) {
+			features.push(feature);
+			return builder;
+		},
+		build: () => mount(pi, options, features),
+	};
+	return builder;
+}
+
+export function enabledSetting(feature: Feature): Setting<boolean> {
+	return setting({
+		id: `features.${feature.id}.enabled`,
+		default: true,
+		decoder: boolean,
+	});
+}
+
+function mount(pi: ExtensionAPI, options: AppOptions, features: readonly Feature[]): App {
+	const settings = new SettingsStore(options.settingsPath ?? globalSettingsPath());
+	const mounted = new Set<string>();
+	const queued: string[] = [];
+	let session: ExtensionContext | undefined;
+	let live = true;
+
+	function deliver(line: string): void {
+		if (session === undefined) queued.push(line);
+		else if (session.hasUI) session.ui.notify(line, "warning");
+		else console.error(line);
+	}
+
+	const state: AppState = {
+		name: options.name,
+		pi,
+		settings,
+		mounted,
+		commands: new Map(),
+		starts: [],
+		shutdowns: [],
+		screen: new Map(),
+		screenGroups: new Map(),
+		live: () => live,
+		stop: () => {
+			live = false;
+		},
+		report: (source, message) => deliver(`${options.name}: ${source}: ${message}`),
+	};
+	const app: App = { name: options.name, settings, has: (id) => mounted.has(id) };
+	const running: Feature[] = [];
+
+	answerClaims(pi, options.name, mounted, () => live);
+	serveScreen({
+		pi,
+		settings,
+		features: () => running,
+		screen: state.screen,
+		screenGroups: state.screenGroups,
+		session: () => session,
+		isLive: () => live,
+	});
+
+	// Every app writes the same files, so a write by one is read again by the others.
+	const store = crypto.randomUUID();
+	settings.onWrite(() => pi.events.emit(CHANGED, { source: store }));
+	pi.events.on(CHANGED, (data) => {
+		if (!live || !isObject(data) || data.source === store) return;
+		for (const line of settings.load(settings.projectPath)) state.report("settings", line);
+	});
+
+	// Registered first, so these run ahead of the features' own handlers.
+	pi.on("session_start", async (_event, ctx) => {
+		live = true;
+		session = ctx;
+		for (const line of queued.splice(0)) deliver(line);
+		const project = ctx.isProjectTrusted() ? projectSettingsPath(ctx.cwd) : undefined;
+		for (const line of settings.load(project)) state.report("settings", line);
+		await runInOrder(
+			state.starts,
+			(run) => run(ctx),
+			(source, error) => {
+				state.report(source, `failed to start the session: ${describe(error)}`);
+			},
+		);
+	});
+
+	pi.on("session_shutdown", async () => {
+		if (!live) return;
+		// Before the hooks: a hook stops a service, and a timer left running would read it after.
+		state.stop();
+		await runInOrder(
+			state.shutdowns.toReversed(),
+			(run) => run(),
+			(source, error) => {
+				state.report(source, `failed to shut down: ${describe(error)}`);
+			},
+		);
+		session = undefined;
+	});
+
+	// All the switches first, so one read of the file decides what is on.
+	const candidates: { feature: Feature; enabled: Setting<boolean> }[] = [];
+	for (const feature of [settingsScreen, ...features]) {
+		if (candidates.some((candidate) => candidate.feature.id === feature.id)) {
+			state.report(feature.id, "was added to this app twice; keeping the first");
+			continue;
+		}
+		const enabled = enabledSetting(feature);
+		try {
+			settings.register([enabled, ...(feature.settings ?? [])]);
+			candidates.push({ feature, enabled });
+		} catch (error) {
+			state.report(feature.id, `failed to set up: ${describe(error)}`);
+		}
+	}
+
+	for (const { feature, enabled } of candidates) {
+		if (!enabled.get(app)) continue;
+
+		const owner = ownerOf(pi, feature.id);
+		if (owner !== undefined) {
+			// Every app brings the screen, and one is enough.
+			if (feature !== settingsScreen)
+				state.report(feature.id, `already loaded by ${owner}, so this copy stays off`);
+			continue;
+		}
+
+		try {
+			feature.setup(createScope(state, feature.id));
+			mounted.add(feature.id);
+			running.push(feature);
+		} catch (error) {
+			state.report(feature.id, `failed to set up: ${describe(error)}`);
+		}
+	}
+
+	return app;
+}
+
+async function runInOrder<T>(
+	hooks: readonly Hook<T>[],
+	call: (run: T) => void | Promise<void>,
+	failed: (source: string, error: unknown) => void,
+): Promise<void> {
+	for (const hook of hooks) {
+		try {
+			// oxlint-disable-next-line no-await-in-loop -- the order is the point
+			await call(hook.run);
+		} catch (error) {
+			failed(hook.source, error);
+		}
+	}
+}

package/packages/frame/src/kit/app/claim.ts

@@ -0,0 +1,27 @@
+// An app asks the others on pi.events whether one already runs a feature, so the harness and a
+// standalone copy never run it twice. The bus is synchronous, so the answer is written on the payload.
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+import { isObject, object, string } from "../decode.ts";
+
+const CHANNEL = "harness:kit:claim";
+const claimShape = object({ feature: string });
+
+export function answerClaims(
+	pi: ExtensionAPI,
+	appName: string,
+	mounted: ReadonlySet<string>,
+	isLive: () => boolean,
+): void {
+	pi.events.on(CHANNEL, (data) => {
+		const claim = claimShape.decode(data, "");
+		if (!isLive() || !claim.ok || !isObject(data) || data.owner !== undefined) return;
+		if (mounted.has(claim.value.feature)) data.owner = appName;
+	});
+}
+
+export function ownerOf(pi: ExtensionAPI, featureId: string): string | undefined {
+	const claim: { feature: string; owner?: unknown } = { feature: featureId };
+	pi.events.emit(CHANNEL, claim);
+	return typeof claim.owner === "string" ? claim.owner : undefined;
+}

package/packages/frame/src/kit/app/feature.ts

@@ -0,0 +1,91 @@
+import type {
+	ExtensionAPI,
+	ExtensionContext,
+	RegisteredCommand,
+} from "@earendil-works/pi-coding-agent";
+
+import type { Control, Json } from "../control.ts";
+import type { Setting, SettingsScope } from "../settings/setting.ts";
+import type { SettingsStore } from "../settings/store.ts";
+
+export type SessionHook = (ctx: ExtensionContext) => void | Promise<void>;
+export type ShutdownHook = () => void | Promise<void>;
+export type CommandOptions = Omit<RegisteredCommand, "name" | "sourceInfo">;
+
+export interface Feature {
+	/** Unique across every package, like `subscription`. It names the feature's settings too. */
+	id: string;
+	description: string;
+	/** The settings tab. Features with the same tab share it. Defaults to the id. */
+	tab?: string;
+	/** Section order on the tab. Sections not listed come after. A function runs when the screen opens. */
+	sections?: readonly string[] | ((ctx: ExtensionContext | undefined) => readonly string[]);
+	settings?: readonly Setting<unknown>[];
+	setup(scope: FeatureScope): void;
+}
+
+/** Extends `ExtensionAPI`, since reading it through another type collapses pi's per-event overloads. */
+export interface FeatureScope extends ExtensionAPI, SettingsScope {
+	readonly id: string;
+	readonly settings: SettingsStore;
+	onSessionStart(hook: SessionHook): void;
+	/** Runs once per session, newest first. */
+	onShutdown(hook: ShutdownHook): void;
+	/** Runs once after `ms`, never after the session ends; cancelled before any shutdown hook runs. */
+	defer(run: () => void, ms?: number): void;
+	/** Shown as `<app>: <feature>: <message>`. */
+	warn(message: string): void;
+	has(featureId: string): boolean;
+	readonly screen: ScreenRows;
+}
+
+interface ScreenRow {
+	id: string;
+	section: string;
+	label: string;
+	description: string;
+	/** How deep the row sits under its section. Each step indents two columns. */
+	indent?: number;
+}
+
+export interface ScreenValue extends ScreenRow {
+	control: Control | ((ctx: ExtensionContext) => Control);
+	get(ctx: ExtensionContext): Json;
+	/** Returns why the value was refused. */
+	set(value: Json, ctx: ExtensionContext): string | undefined;
+	/** Where the value applies, when that is not this session. */
+	meta?: string;
+	/** What the row shows in place of the value, like a count for a list. Undefined shows the value. */
+	text?(ctx: ExtensionContext): string | undefined;
+}
+
+export interface ScreenAction extends ScreenRow {
+	text?(ctx: ExtensionContext): string;
+	confirm?: string;
+	/** Returned text opens in the screen. A throw shows as an error. */
+	run(ctx: ExtensionContext): string | undefined | Promise<string | undefined>;
+}
+
+export interface ScreenInfo extends ScreenRow {
+	text(ctx: ExtensionContext): string;
+}
+
+export type ScreenEntry =
+	| ({ kind: "value" } & ScreenValue)
+	| ({ kind: "action" } & ScreenAction)
+	| ({ kind: "info" } & ScreenInfo);
+
+/** Rows a feature builds when the screen opens, for what is only known then. */
+export type ScreenGroup = (ctx: ExtensionContext) => ScreenEntry[];
+
+export interface ScreenRows {
+	value(row: ScreenValue): void;
+	action(row: ScreenAction): void;
+	info(row: ScreenInfo): void;
+	/** One call, many rows: the provider runs every time the screen opens. */
+	rows(provider: ScreenGroup): void;
+}
+
+export function defineFeature(feature: Feature): Feature {
+	return feature;
+}

package/packages/frame/src/kit/app/host.ts

@@ -0,0 +1,214 @@
+// Each app answers the screen for the features it runs. A change goes through the setting's own
+// decoder, like a value read from the file.
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+import {
+	APPLY,
+	type ApplyRequest,
+	DONE,
+	LIST,
+	type RowView,
+	RUN,
+	type RunDone,
+	type RunRequest,
+	type TabView,
+} from "../contracts/screen.ts";
+import type { Json } from "../control.ts";
+import { formatProblems, isObject } from "../decode.ts";
+import { controlOf, type Setting } from "../settings/setting.ts";
+import type { SettingsStore } from "../settings/store.ts";
+import type { Feature, ScreenEntry, ScreenGroup } from "./feature.ts";
+
+export interface Host {
+	pi: ExtensionAPI;
+	settings: SettingsStore;
+	features: () => readonly Feature[];
+	screen: ReadonlyMap<string, ScreenEntry[]>;
+	screenGroups: ReadonlyMap<string, ScreenGroup[]>;
+	session: () => ExtensionContext | undefined;
+	isLive: () => boolean;
+}
+
+export function serveScreen(host: Host): void {
+	host.pi.events.on(LIST, (data) => {
+		if (!host.isLive() || !isObject(data) || !Array.isArray(data.tabs)) return;
+		const ctx = host.session();
+		for (const feature of host.features()) data.tabs.push(tabOf(host, feature, ctx));
+	});
+
+	host.pi.events.on(APPLY, (data) => {
+		const request = asApply(data);
+		if (request === undefined || !host.isLive()) return;
+		const feature = host.features().find((entry) => entry.id === request.feature);
+		if (feature === undefined) return;
+		request.answer = { error: apply(host, feature, request) };
+	});
+
+	host.pi.events.on(RUN, (data) => {
+		const request = asRun(data);
+		if (request === undefined || !host.isLive()) return;
+		if (!host.features().some((entry) => entry.id === request.feature)) return;
+		const ctx = host.session();
+		const row = findRow(host, request.feature, request.id, ctx);
+		if (row === undefined) return;
+
+		if (row.kind !== "action" || ctx === undefined) {
+			request.answer = { error: "nothing to run" };
+			return;
+		}
+		request.answer = {};
+		const id = request.request;
+		void runAction(row, ctx).then((done) => host.pi.events.emit(DONE, { request: id, ...done }));
+	});
+}
+
+function tabOf(host: Host, feature: Feature, ctx: ExtensionContext | undefined): TabView {
+	const rows: RowView[] = [];
+	for (const entry of feature.settings ?? []) {
+		const row = settingRow(host.settings, feature, entry, ctx);
+		if (row !== undefined) rows.push(row);
+	}
+	if (ctx !== undefined) {
+		for (const entry of entriesOf(host, feature.id, ctx)) rows.push(screenRow(feature, entry, ctx));
+	}
+
+	const listed = typeof feature.sections === "function" ? feature.sections(ctx) : feature.sections;
+	const sections = [...(listed ?? [])];
+	for (const row of rows) if (!sections.includes(row.section)) sections.push(row.section);
+	return { title: feature.tab ?? capitalize(feature.id), sections, rows };
+}
+
+function settingRow(
+	settings: SettingsStore,
+	feature: Feature,
+	entry: Setting<unknown>,
+	ctx: ExtensionContext | undefined,
+): RowView | undefined {
+	const ui = entry.ui;
+	if (ui === undefined) return undefined;
+
+	const control = controlOf(entry, ctx);
+	const value = toJson(settings.get(entry));
+	const layer = settings.layer(entry);
+	const row: RowView = {
+		feature: feature.id,
+		id: entry.id,
+		kind: control === undefined ? "info" : "setting",
+		section: ui.section,
+		label: ui.label,
+		description: ui.description,
+		value,
+		layer,
+		fallback: toJson(entry.default),
+	};
+	if (control === undefined) row.text = JSON.stringify(value);
+	else row.control = control;
+	if (layer === "project") row.hidden = toJson(settings.hidden(entry));
+	if (ui.restart === true) row.restart = true;
+	if (ui.preview !== undefined) row.preview = ui.preview;
+	return row;
+}
+
+function screenRow(feature: Feature, entry: ScreenEntry, ctx: ExtensionContext): RowView {
+	const row: RowView = {
+		feature: feature.id,
+		id: entry.id,
+		kind: entry.kind,
+		section: entry.section,
+		label: entry.label,
+		description: entry.description,
+	};
+	if (entry.indent !== undefined) row.indent = entry.indent;
+	switch (entry.kind) {
+		case "value":
+			row.control = typeof entry.control === "function" ? entry.control(ctx) : entry.control;
+			row.value = entry.get(ctx);
+			if (entry.meta !== undefined) row.meta = entry.meta;
+			const shown = entry.text?.(ctx);
+			if (shown !== undefined) row.text = shown;
+			break;
+		case "action": {
+			const text = entry.text?.(ctx);
+			if (text !== undefined) row.text = text;
+			if (entry.confirm !== undefined) row.confirm = entry.confirm;
+			break;
+		}
+		case "info":
+			row.text = entry.text(ctx);
+			break;
+	}
+	return row;
+}
+
+function apply(host: Host, feature: Feature, request: ApplyRequest): string | undefined {
+	const entry = feature.settings?.find((candidate) => candidate.id === request.id);
+	if (entry !== undefined) {
+		if (request.op === "unset") {
+			const layer = host.settings.layer(entry);
+			return layer === "default" ? undefined : host.settings.unset(entry, layer);
+		}
+		const decoded = entry.decoder.decode(request.value, entry.id);
+		if (!decoded.ok) return formatProblems(decoded.problems).join("; ");
+		return host.settings.set(entry, decoded.value);
+	}
+
+	const ctx = host.session();
+	const row = findRow(host, feature.id, request.id, ctx);
+	if (row?.kind !== "value" || ctx === undefined) return "this row cannot change";
+	if (request.op === "unset") return "this row has no default to go back to";
+	return row.set(request.value ?? null, ctx);
+}
+
+function entriesOf(host: Host, feature: string, ctx: ExtensionContext): ScreenEntry[] {
+	return [
+		...(host.screen.get(feature) ?? []),
+		...(host.screenGroups.get(feature) ?? []).flatMap((group) => group(ctx)),
+	];
+}
+
+/** An action can sit on a built row too, so the lookup walks the same two places. */
+function findRow(
+	host: Host,
+	feature: string,
+	id: string,
+	ctx: ExtensionContext | undefined,
+): ScreenEntry | undefined {
+	if (ctx === undefined) return host.screen.get(feature)?.find((candidate) => candidate.id === id);
+	return entriesOf(host, feature, ctx).find((candidate) => candidate.id === id);
+}
+
+async function runAction(
+	row: Extract<ScreenEntry, { kind: "action" }>,
+	ctx: ExtensionContext,
+): Promise<Omit<RunDone, "request">> {
+	try {
+		const text = await row.run(ctx);
+		return text === undefined ? {} : { text };
+	} catch (error) {
+		return { error: error instanceof Error ? error.message : String(error) };
+	}
+}
+
+function asApply(data: unknown): ApplyRequest | undefined {
+	if (!isObject(data) || data.answer !== undefined) return undefined;
+	const { feature, id, op } = data;
+	if (typeof feature !== "string" || typeof id !== "string") return undefined;
+	if (op !== "set" && op !== "unset") return undefined;
+	return data as unknown as ApplyRequest;
+}
+
+function asRun(data: unknown): RunRequest | undefined {
+	if (!isObject(data) || data.answer !== undefined) return undefined;
+	const { feature, id, request } = data;
+	if (typeof feature !== "string" || typeof id !== "string" || typeof request !== "string")
+		return undefined;
+	return data as unknown as RunRequest;
+}
+
+function toJson(value: unknown): Json {
+	return value === undefined ? null : (JSON.parse(JSON.stringify(value)) as Json);
+}
+
+function capitalize(text: string): string {
+	return text.charAt(0).toUpperCase() + text.slice(1);
+}

package/packages/frame/src/kit/app/renderers.ts

@@ -0,0 +1,62 @@
+// The renderers the harness's features register, kept so a view can draw another session's entries
+// the way pi draws this one's. Pi resolves its own chain but gives extensions no way to call it.
+import type {
+	MessageRenderer,
+	ToolRendererResolver,
+	ToolRenderers,
+} from "@earendil-works/pi-coding-agent";
+
+interface Registered {
+	tools: ToolRendererResolver[];
+	messages: Map<string, MessageRenderer>;
+}
+
+// By feature, in the order they mount, which is the order pi resolves them in. A feature mounted again
+// for the next session replaces what it registered for the last one.
+const byFeature = new Map<string, Registered>();
+
+export function forgetRenderers(feature: string): void {
+	byFeature.delete(feature);
+}
+
+export function keepToolRenderer(feature: string, resolver: ToolRendererResolver): void {
+	registered(feature).tools.push(resolver);
+}
+
+export function keepMessageRenderer(
+	feature: string,
+	customType: string,
+	renderer: MessageRenderer,
+): void {
+	registered(feature).messages.set(customType, renderer);
+}
+
+/** As pi resolves them: every feature's resolver over `base`. */
+export function resolveToolRenderers(
+	toolName: string,
+	base: () => ToolRenderers | undefined,
+): ToolRenderers | undefined {
+	const resolvers = [...byFeature.values()].flatMap((one) => one.tools);
+	function resolve(index: number): ToolRenderers | undefined {
+		const resolver = resolvers[index];
+		return resolver === undefined ? base() : resolver(toolName, () => resolve(index + 1));
+	}
+	return resolve(0);
+}
+
+export function messageRendererFor(customType: string): MessageRenderer | undefined {
+	for (const one of byFeature.values()) {
+		const renderer = one.messages.get(customType);
+		if (renderer !== undefined) return renderer;
+	}
+	return undefined;
+}
+
+function registered(feature: string): Registered {
+	let one = byFeature.get(feature);
+	if (one === undefined) {
+		one = { tools: [], messages: new Map() };
+		byFeature.set(feature, one);
+	}
+	return one;
+}