@vzlentin/harness 0.2.3 → 0.3.0

package/pi/chat.ts

@@ -0,0 +1,286 @@
+/**
+ * A durable conversation drawn with Pi's own message and tool components.
+ *
+ * Adapted from `ChatView` in mavam/pi-agents, src/ui/attach.ts. MIT License, Copyright (c) 2026 Matthias Vallentin.
+ */
+import type { AssistantMessage, JsonObject, ToolResultMessage } from "@earendil-works/pi-ai";
+import {
+	AssistantMessageComponent,
+	createBashToolDefinition,
+	createEditToolDefinition,
+	createFindToolDefinition,
+	createGrepToolDefinition,
+	createLsToolDefinition,
+	createReadToolDefinition,
+	createWriteToolDefinition,
+	getMarkdownTheme,
+	type ThemeColor,
+	type ToolDefinition,
+	ToolExecutionComponent,
+	UserMessageComponent,
+} from "@earendil-works/pi-coding-agent";
+import type { ConversationView, EntryRecord } from "@earendil-works/pi-durable";
+import { Container, Spacer, Text, type TUI } from "@earendil-works/pi-tui";
+import { liveOf, userText } from "../dist/view-state.js";
+
+// Pi's tool definitions differ in their schemas.
+type AnyDefinition = ToolDefinition<any, any>;
+
+/** Pi's renderers of the tools that children have under the same names. */
+const RENDERERS = new Map<string, (cwd: string) => AnyDefinition>([
+	["read", createReadToolDefinition],
+	["bash", createBashToolDefinition],
+	["edit", createEditToolDefinition],
+	["write", createWriteToolDefinition],
+	["grep", createGrepToolDefinition],
+	["find", createFindToolDefinition],
+	["ls", createLsToolDefinition],
+]);
+
+const DIAGNOSTICS = /^<harness>\n([\s\S]*)\n<\/harness>$/;
+
+/**
+ * A tool result as Pi shows its own. pi-durable adds the diagnostics of a call for the model as a `<harness>` block, such
+ * as `Command exited with code 3`, and the card shows them as plain lines.
+ */
+export function displayedResult(result: ToolResultMessage): ToolResultMessage {
+	let changed = false;
+
+	const content = result.content.map((block) => {
+		const match = block.type === "text" ? DIAGNOSTICS.exec(block.text) : null;
+
+		if (!match) return block;
+		changed = true;
+		const lines = (match[1] ?? "").split("\n").map((line) => line.replace(/^\[(error|warning|info)\] /, ""));
+
+		return { type: "text" as const, text: `\n${lines.join("\n")}` };
+	});
+
+	return changed ? { ...result, content } : result;
+}
+
+/** The transcript of one conversation view, updated in place as the view changes. */
+export class ChatView {
+	readonly transcript = new Container();
+	/** The newest card for each call ID: providers can use a call ID again in a later turn. */
+	private readonly tools = new Map<string, ToolExecutionComponent>();
+	/** Every card shown, also the older ones whose call ID a later turn used again. */
+	private readonly cards: ToolExecutionComponent[] = [];
+	/** The cards that have no final result yet. */
+	private readonly running = new Set<ToolExecutionComponent>();
+	/** The call IDs whose cards the streamed answer made; its entry takes them over. */
+	private readonly streamingCalls = new Set<string>();
+	private readonly renderers = new Map<string, AnyDefinition>();
+	private renderedEntryIds: EntryRecord["id"][] = [];
+	private streaming: AssistantMessageComponent | undefined;
+	/** Ctrl+O shows tool output in full, as in Pi. */
+	private expanded = false;
+	/** Pi's `hideThinkingBlock` setting: the answers show a label in place of their thinking. */
+	private hideThinking = false;
+	private readonly ui: TUI;
+	private readonly cwd: string;
+	/** Colors the lines that the transcript adds itself, such as `[compaction]`, in Pi's current theme. */
+	private readonly color: (name: ThemeColor, text: string) => string;
+
+	constructor(ui: TUI, cwd: string, color: (name: ThemeColor, text: string) => string) {
+		this.ui = ui;
+		this.cwd = cwd;
+		this.color = color;
+	}
+
+	apply(view: ConversationView): void {
+		const live = liveOf(view);
+		this.syncTranscript(view.entries);
+		const message = live.generation?.message;
+
+		// A streamed answer without its entry was dropped, for example by a retry.
+		if (message === undefined && this.streaming !== undefined) this.rebuild(view.entries);
+
+		if (message !== undefined) this.syncStreaming(message);
+
+		for (const slot of live.tools ?? []) {
+			if (slot.status === "pending") continue;
+			const component = this.card(slot.name, slot.callId);
+			component.setArgsComplete();
+
+			if (slot.status !== "running") continue;
+			component.markExecutionStarted();
+
+			if (slot.output !== undefined || slot.details !== undefined) {
+				component.updateResult(
+					{ content: [{ type: "text", text: slot.output ?? "" }], details: slot.details, isError: false },
+					true,
+				);
+			}
+		}
+
+		this.transcript.invalidate();
+	}
+
+	/** Shows tool output in full when `expanded` is true, else collapsed. */
+	setExpanded(expanded: boolean): void {
+		this.expanded = expanded;
+
+		for (const card of this.cards) card.setExpanded(expanded);
+		this.transcript.invalidate();
+	}
+
+	/** Hides the thinking of the answers when `hide` is true, else shows it. */
+	setHideThinking(hide: boolean): void {
+		this.hideThinking = hide;
+
+		for (const child of this.transcript.children) {
+			if (child instanceof AssistantMessageComponent) child.setHideThinkingBlock(hide);
+		}
+
+		this.transcript.invalidate();
+	}
+
+	/** Finishes the running cards: a running bash card keeps a timer until it gets a final result. */
+	stopTimers(): void {
+		for (const component of this.running) component.updateResult({ content: [], isError: false }, false);
+		this.running.clear();
+	}
+
+	private syncTranscript(entries: readonly EntryRecord[]): void {
+		// A compaction or a reset replaces the head of the active transcript.
+		if (this.renderedEntryIds.some((id, index) => entries[index]?.id !== id)) this.rebuild(entries);
+
+		for (const entry of entries.slice(this.renderedEntryIds.length)) {
+			this.addEntry(entry);
+			this.renderedEntryIds.push(entry.id);
+		}
+	}
+
+	private rebuild(entries: readonly EntryRecord[]): void {
+		this.stopTimers();
+		this.transcript.clear();
+		this.cards.length = 0;
+		this.tools.clear();
+		this.streamingCalls.clear();
+		this.renderedEntryIds = [];
+		this.streaming = undefined;
+
+		for (const entry of entries) {
+			this.addEntry(entry);
+			this.renderedEntryIds.push(entry.id);
+		}
+	}
+
+	private addEntry(entry: EntryRecord): void {
+		const message = entry.model?.[0];
+
+		if (entry.kind === "pi.user" && message?.role === "user") {
+			this.transcript.addChild(new Spacer(1));
+			this.transcript.addChild(new UserMessageComponent(userText(message.content), getMarkdownTheme()));
+		} else if (entry.kind === "pi.assistant" && message?.role === "assistant") {
+			const component =
+				this.streaming ?? new AssistantMessageComponent(undefined, this.hideThinking, getMarkdownTheme());
+
+			if (this.streaming === undefined) this.transcript.addChild(component);
+			this.streaming = undefined;
+			component.updateContent(message, false);
+			// Only an answer that asks for tools runs its calls; an aborted, failed or cut answer never does.
+			const ran = message.stopReason === "toolUse";
+
+			for (const content of message.content) {
+				if (content.type !== "toolCall") continue;
+				const streamed = this.streamingCalls.has(content.id);
+
+				if (!ran && !streamed) continue;
+
+				const card = streamed
+					? this.card(content.name, content.id, content.arguments)
+					: this.newCard(content.name, content.id, content.arguments);
+
+				card.setArgsComplete();
+
+				if (!ran) {
+					const text = "Not run: the answer was interrupted.";
+					card.updateResult({ content: [{ type: "text", text }], isError: true }, false);
+					this.running.delete(card);
+				}
+			}
+
+			this.streamingCalls.clear();
+		} else if (entry.kind === "pi.tool-result" && message?.role === "toolResult") {
+			const card = this.card(message.toolName, message.toolCallId);
+			card.updateResult(displayedResult(message));
+			this.running.delete(card);
+		} else if (entry.kind === "pi.compaction") {
+			this.addText(this.color("muted", "[compaction]"));
+
+			if (message?.role === "user") this.addText(userText(message.content));
+		} else if (entry.kind === "pi.reset") {
+			this.addText(this.color("muted", "[new context]"));
+		}
+	}
+
+	private syncStreaming(message: AssistantMessage): void {
+		if (this.streaming === undefined) {
+			this.streaming = new AssistantMessageComponent(undefined, this.hideThinking, getMarkdownTheme());
+			this.transcript.addChild(this.streaming);
+		}
+
+		this.streaming.updateContent(message, true);
+
+		for (const content of message.content) {
+			if (content.type !== "toolCall") continue;
+
+			if (this.streamingCalls.has(content.id)) this.card(content.name, content.id, content.arguments);
+			else this.newCard(content.name, content.id, content.arguments);
+			this.streamingCalls.add(content.id);
+		}
+	}
+
+	private renderer(toolName: string): AnyDefinition | undefined {
+		let definition = this.renderers.get(toolName);
+
+		if (definition === undefined) {
+			const create = RENDERERS.get(toolName);
+
+			if (create === undefined) return undefined;
+			definition = create(this.cwd);
+			this.renderers.set(toolName, definition);
+		}
+
+		return definition;
+	}
+
+	/** The newest card of a call, or a new card when the call has none. */
+	private card(toolName: string, toolCallId: string, args?: JsonObject): ToolExecutionComponent {
+		const existing = this.tools.get(toolCallId);
+
+		if (existing === undefined) return this.newCard(toolName, toolCallId, args ?? {});
+
+		if (args !== undefined) existing.updateArgs(args);
+
+		return existing;
+	}
+
+	/** A new card of a call, also for a call ID that an earlier turn used. */
+	private newCard(toolName: string, toolCallId: string, args: JsonObject): ToolExecutionComponent {
+		const component = new ToolExecutionComponent(
+			toolName,
+			toolCallId,
+			args,
+			{},
+			this.renderer(toolName),
+			this.ui,
+			this.cwd,
+		);
+
+		component.setExpanded(this.expanded);
+		this.transcript.addChild(component);
+		this.cards.push(component);
+		this.running.add(component);
+		this.tools.set(toolCallId, component);
+
+		return component;
+	}
+
+	private addText(text: string): void {
+		this.transcript.addChild(new Spacer(1));
+		this.transcript.addChild(new Text(text, 1, 0));
+	}
+}

package/pi/index.ts

@@ -1,6 +1,6 @@
 /**
- * The `subagent` tool, `/subagent` and the subagents widget. They use the client of the harness package that holds
- * this folder, from its built `dist/`, and start the host of that package.
+ * The `subagent` tool, `/subagent`, the subagents widget and the mirror sessions of `/harness`. They use the client of
+ * the harness package that holds this folder, from its built `dist/`, and start the host of that package.
  */
 import { resolve } from "node:path";
 import { Type } from "@earendil-works/pi-ai";
@@ -13,14 +13,16 @@ import {
 	SettingsManager,
 } from "@earendil-works/pi-coding-agent";
 import { request } from "../dist/client.js";
-import { openViewerTab } from "../dist/herdr.js";
-import { childLine, runDisplayName } from "../dist/protocol.js";
+import { inHerdr, openChildTab } from "../dist/herdr.js";
+import { childLine, errorMessage, runDisplayName } from "../dist/protocol.js";
 import * as tool from "../dist/tool.js";
+import { registerMirror } from "./mirror.ts";
 
 const SESSION_TRUST_HINT =
 	"The child gets no project skills (.pi/skills, .agents/skills): this project is trusted for this Pi session only, and children see only the trust saved for future sessions. To give children project skills, run /trust and choose Trust.";
 
 export default function subagentExtension(pi: ExtensionAPI) {
+	registerMirror(pi);
 	const { parameters, output } = tool.toolSchemas(Type);
 	pi.registerTool({
 		name: "subagent",
@@ -55,7 +57,7 @@ export default function subagentExtension(pi: ExtensionAPI) {
 	});
 
 	pi.registerCommand("subagent", {
-		description: "Open the viewer of a subagent spawned by this session",
+		description: "Open a subagent spawned by this session in Pi, in a new Herdr tab",
 		handler: async (_args, ctx) => {
 			const children = await request({ type: "list", caller: ctx.sessionManager.getSessionId() }, { start: true });
 
@@ -78,16 +80,16 @@ export default function subagentExtension(pi: ExtensionAPI) {
 			if (child === undefined) return;
 			const command = `harness attach ${child.handle}`;
 
-			if (!process.env.HERDR_ENV) {
+			if (!inHerdr(process.env)) {
 				ctx.ui.notify(`Run in another terminal: ${command}`, "info");
 
 				return;
 			}
 
 			try {
-				await openViewerTab(child, process.env);
+				await openChildTab(child, process.env);
 			} catch (error) {
-				const message = error instanceof Error ? error.message : String(error);
+				const message = errorMessage(error);
 				ctx.ui.notify(`Could not open a Herdr tab: ${message}. Run in another terminal: ${command}`, "error");
 			}
 		},

package/pi/mirror.ts

@@ -0,0 +1,206 @@
+/**
+ * Mirror sessions: a Pi session that shows a child or the agent of a harness project in Pi's own chat, and sends what
+ * the user types to it. The agent runs in the host of the project; the session keeps only its target, in one custom
+ * entry. `/harness [project]` opens one in a new session, and `pi --harness <project> [--harness-child <handle>]` in the
+ * session that Pi starts with.
+ */
+
+import { homedir } from "node:os";
+import type {
+	ExtensionAPI,
+	ExtensionCommandContext,
+	ExtensionContext,
+	SessionEntry,
+} from "@earendil-works/pi-coding-agent";
+import type { AutocompleteItem } from "@earendil-works/pi-tui";
+import * as tui from "@earendil-works/pi-tui";
+import { isMirrorTarget, MIRROR_ENTRY, type MirrorTarget, PI_FLAGS } from "../dist/mirror.js";
+import { checkProject, MAIN_PROJECT, projectDir, readProjects, resolveProject } from "../dist/projects.js";
+import { AGENT_HANDLE, errorMessage } from "../dist/protocol.js";
+import { Attachment } from "./attachment.ts";
+
+/** The mirror entry of a session: its ID and its target. */
+type MirrorEntry = { readonly id: string; readonly target: MirrorTarget };
+
+/** Registers `/harness`, `--harness` and the handlers that turn a session with a mirror entry into a mirror session. */
+export function registerMirror(pi: ExtensionAPI): void {
+	// The frame of each mirror entry in Pi's chat. Pi can draw the entry before or after `session_start`.
+	const frames = new Map<string, tui.Container>();
+	let attached: Attachment | undefined;
+
+	const frameOf = (entryId: string): tui.Container => {
+		const frame = frames.get(entryId) ?? new tui.Container();
+		frames.set(entryId, frame);
+
+		return frame;
+	};
+
+	pi.registerFlag(PI_FLAGS.project, {
+		type: "string",
+		description: "Show the agent of this harness project (main or a project name) in the new session",
+	});
+
+	pi.registerFlag(PI_FLAGS.child, {
+		type: "string",
+		description: "Show this subagent of the harness project in the new session, in place of the project agent",
+	});
+
+	pi.registerEntryRenderer(MIRROR_ENTRY, (entry, options, theme) => {
+		if (attached?.entryId === entry.id) attached.restyle(theme, options.expanded);
+
+		return frameOf(entry.id);
+	});
+
+	pi.registerCommand("harness", {
+		description: "Show the agent of a harness project in a new session: /harness [project]",
+		getArgumentCompletions: projectItems,
+		handler: async (args, ctx) => {
+			let project: string | undefined;
+
+			try {
+				project = args.trim() === "" ? await pickProject(ctx) : checkProject(args.trim());
+			} catch (error) {
+				ctx.ui.notify(`harness: ${errorMessage(error)}`, "error");
+
+				return;
+			}
+
+			if (project === undefined) return;
+			const target: MirrorTarget = { project, handle: AGENT_HANDLE };
+			await ctx.newSession({
+				setup: async (sessionManager) => {
+					sessionManager.appendCustomEntry(MIRROR_ENTRY, target);
+				},
+			});
+		},
+	});
+
+	pi.on("session_start", (event, ctx) => {
+		if (ctx.mode !== "tui") return;
+		const branch = ctx.sessionManager.getBranch();
+
+		// Pi draws only the entries of this branch from now on. A /reload keeps the session, and its frames.
+		for (const id of frames.keys()) {
+			if (!branch.some((entry) => entry.id === id)) frames.delete(id);
+		}
+
+		const entry = mirrorEntry(branch) ?? (event.reason === "startup" ? flagEntry(pi, ctx) : undefined);
+
+		if (entry !== undefined) attached = new Attachment(pi, ctx, entry.id, entry.target, frameOf(entry.id));
+	});
+
+	pi.on("session_shutdown", () => {
+		attached?.close();
+		attached = undefined;
+	});
+
+	// The agent of the host answers in a mirror session, so the input goes there and not to Pi's own agent.
+	pi.on("input", (event, ctx) => {
+		if (attached === undefined) return undefined;
+
+		if (event.images !== undefined && event.images.length > 0) {
+			ctx.ui.notify("harness: the images are not sent; the agent gets only the text", "warning");
+		}
+
+		attached.send(event.text, false);
+
+		return { action: "handled" };
+	});
+
+	// A restored model is the one of the Pi session, not a choice of the user.
+	pi.on("model_select", (event) => {
+		if (event.source !== "restore") attached?.models.piSelected(event.model.provider, event.model.id);
+	});
+}
+
+/** The newest mirror entry of `entries` with a valid target. */
+function mirrorEntry(entries: readonly SessionEntry[]): MirrorEntry | undefined {
+	for (const entry of entries.toReversed()) {
+		if (entry.type === "custom" && entry.customType === MIRROR_ENTRY && isMirrorTarget(entry.data)) {
+			return { id: entry.id, target: entry.data };
+		}
+	}
+
+	return undefined;
+}
+
+/**
+ * The mirror entry for `--harness <project>` and `--harness-child <handle>`, written in the session that Pi starts
+ * with. Without a project, it is the project of `HARNESS_PROJECT` and Pi's working directory; without a child, the
+ * project agent. It refuses a session with messages, such as one of `--continue`, because Pi's own agent answered there.
+ */
+function flagEntry(pi: ExtensionAPI, ctx: ExtensionContext): MirrorEntry | undefined {
+	const project = stringFlag(pi, PI_FLAGS.project);
+	const child = stringFlag(pi, PI_FLAGS.child);
+
+	if (project === undefined && child === undefined) return undefined;
+
+	if (ctx.sessionManager.getBranch().some((entry) => entry.type === "message")) {
+		ctx.ui.notify("harness: --harness needs a new session, not one with messages", "error");
+
+		return undefined;
+	}
+
+	let target: MirrorTarget;
+
+	try {
+		target = {
+			project: project ? checkProject(project) : resolveProject(process.env, ctx.cwd),
+			handle: child || AGENT_HANDLE,
+		};
+	} catch (error) {
+		ctx.ui.notify(`harness: ${errorMessage(error)}`, "error");
+
+		return undefined;
+	}
+
+	// `appendEntry` gives no entry ID, so the entry comes back from the branch.
+	pi.appendEntry(MIRROR_ENTRY, target);
+
+	return mirrorEntry(ctx.sessionManager.getBranch());
+}
+
+/** The value of the string flag `name`, or undefined when it is not given. */
+function stringFlag(pi: ExtensionAPI, name: string): string | undefined {
+	const flag = pi.getFlag(name);
+
+	return flag === undefined || flag === true || flag === false ? undefined : flag;
+}
+
+/**
+ * The project that the user selects for `/harness` without a project: the project of Pi's working directory first,
+ * then the other projects and `main`. It is undefined when the user cancels.
+ */
+async function pickProject(ctx: ExtensionCommandContext): Promise<string | undefined> {
+	const projects = readProjects();
+	const current = resolveProject(process.env, ctx.cwd, projects);
+	const names = [current, ...[...Object.keys(projects), MAIN_PROJECT].filter((name) => name !== current)];
+
+	if (names.length === 1) return current;
+	const labels = names.map((name) => `${name}  ${tildePath(projectDir(name, projects))}`);
+	const label = await ctx.ui.select("Harness project", labels);
+
+	return label === undefined ? undefined : names[labels.indexOf(label)];
+}
+
+/** `path` with the home directory as `~`. */
+function tildePath(path: string): string {
+	const home = homedir();
+
+	return home !== "" && (path === home || path.startsWith(`${home}/`)) ? `~${path.slice(home.length)}` : path;
+}
+
+/** The projects whose names start with `prefix`, for the argument of `/harness`. */
+function projectItems(prefix: string): AutocompleteItem[] | null {
+	let names: string[];
+
+	try {
+		names = [...Object.keys(readProjects()), MAIN_PROJECT];
+	} catch {
+		return null;
+	}
+
+	const items = names.flatMap((name) => (name.startsWith(prefix) ? [{ value: name, label: name }] : []));
+
+	return items.length > 0 ? items : null;
+}

package/pi/model-sync.ts

@@ -0,0 +1,102 @@
+/**
+ * The model and the thinking level of a mirror session. The agent in the host is the truth: the Pi session shows the
+ * agent's model and level, so Pi's footer and `/model` show them, and a change that the user makes in Pi is a request
+ * to the host. When the host refuses it, Pi goes back to the agent's model and level.
+ */
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { Mirror, MirrorConfigure } from "../dist/mirror.js";
+import type { ChildInfo } from "../dist/protocol.js";
+
+/** What the sync uses of Pi's extension API. */
+export type PiModels = Pick<ExtensionAPI, "setModel" | "getThinkingLevel" | "setThinkingLevel">;
+
+/** What the sync uses of the context of the Pi session. */
+export type PiSession = Pick<ExtensionContext, "model"> & {
+	readonly modelRegistry: Pick<ExtensionContext["modelRegistry"], "find">;
+};
+
+/** What the sync uses of the mirror: the agent, and the requests that change it. */
+export type MirroredAgent = Pick<Mirror, "child" | "configure">;
+
+export class ModelSync {
+	// After a session switch, `#pi` and `#ctx` are stale and throw, so nothing uses them after `close()`.
+	readonly #pi: PiModels;
+	readonly #ctx: PiSession;
+	readonly #mirror: MirroredAgent;
+	readonly #notify: (cause: unknown) => void;
+	/** True while Pi sets the agent's model: `setModel` is async, and the agent changes often while it works. */
+	#settingModel = false;
+	#closed = false;
+
+	constructor(pi: PiModels, ctx: PiSession, mirror: MirroredAgent, notify: (cause: unknown) => void) {
+		this.#pi = pi;
+		this.#ctx = ctx;
+		this.#mirror = mirror;
+		this.#notify = notify;
+	}
+
+	/** Gives the Pi session the model and the thinking level of `child`, the agent as the host gives it. */
+	fromAgent(child: ChildInfo): void {
+		if (this.#closed) return;
+		const model = this.#ctx.modelRegistry.find(child.provider, child.model);
+
+		if (model !== undefined && !this.#piHasModel(child) && !this.#settingModel) {
+			this.#settingModel = true;
+			// Pi sets its own thinking level when it takes a model, so the agent's level follows once Pi has the model.
+			void this.#pi.setModel(model).finally(() => {
+				this.#settingModel = false;
+				const current = this.#mirror.child;
+
+				if (current !== undefined) this.#thinkingFromAgent(current);
+			});
+		}
+
+		this.#thinkingFromAgent(child);
+	}
+
+	/** Asks the host for the model that the user selected in Pi. */
+	piSelected(provider: string, model: string): void {
+		const child = this.#mirror.child;
+
+		if (child === undefined || (child.provider === provider && child.model === model)) return;
+		this.#configure({ provider, model });
+	}
+
+	/**
+	 * Asks the host for the thinking level that the user cycled to in Pi, once Pi has the agent's model. Pi also changes
+	 * its level when it takes a model, so only the cycle key calls this, not each change of Pi's level.
+	 */
+	piCycled(): void {
+		const child = this.#mirror.child;
+
+		if (this.#closed || child === undefined || !this.#piHasModel(child)) return;
+		const thinking = this.#pi.getThinkingLevel();
+
+		if (child.thinking !== thinking) this.#configure({ thinking });
+	}
+
+	close(): void {
+		this.#closed = true;
+	}
+
+	#configure(change: MirrorConfigure): void {
+		this.#mirror.configure(change).catch((cause: unknown) => {
+			this.#notify(cause);
+			const child = this.#mirror.child;
+
+			if (child !== undefined) this.fromAgent(child);
+		});
+	}
+
+	#thinkingFromAgent(child: ChildInfo): void {
+		if (!this.#closed && this.#piHasModel(child) && this.#pi.getThinkingLevel() !== child.thinking) {
+			this.#pi.setThinkingLevel(child.thinking);
+		}
+	}
+
+	#piHasModel(child: ChildInfo): boolean {
+		const model = this.#ctx.model;
+
+		return model?.provider === child.provider && model.id === child.model;
+	}
+}

package/pi/package.json

@@ -1,6 +1,6 @@
 {
 	"private": true,
-	"description": "The Pi extension of harness: the subagent tool, the /subagent command and the subagents widget",
+	"description": "The Pi extension of harness: the subagent tool, the /subagent command, the subagents widget and the /harness mirror sessions",
 	"type": "module",
 	"pi": {
 		"extensions": [
@@ -9,6 +9,7 @@
 	},
 	"peerDependencies": {
 		"@earendil-works/pi-ai": "*",
-		"@earendil-works/pi-coding-agent": "*"
+		"@earendil-works/pi-coding-agent": "*",
+		"@earendil-works/pi-tui": "*"
 	}
 }