@vzlentin/harness 0.2.3 → 0.3.1

package/pi/attachment.ts

@@ -0,0 +1,303 @@
+/**
+ * The mirror of one Pi session: the frame of its entry in Pi's chat, which holds the transcript, the status above the
+ * editor, and an editor whose interrupt and follow-up keys act on the agent while it works. The connection to the host
+ * is the `Mirror`, and the model and thinking level of the session are the `ModelSync`.
+ */
+import type {
+	ExtensionAPI,
+	ExtensionContext,
+	KeybindingsManager,
+	Theme,
+	ThemeColor,
+} from "@earendil-works/pi-coding-agent";
+import * as coding from "@earendil-works/pi-coding-agent";
+import type { ConversationView } from "@earendil-works/pi-durable";
+import type { Component, EditorTheme, TUI } from "@earendil-works/pi-tui";
+import * as tui from "@earendil-works/pi-tui";
+import { type AgentReporter, agentReporter } from "../dist/herdr.js";
+import { Mirror, type MirrorStatus, type MirrorTarget, targetTitle } from "../dist/mirror.js";
+import { type ChildInfo, childLabel, childTitle, errorMessage } from "../dist/protocol.js";
+import { inboxOf, liveOf, queued, statusText } from "../dist/view-state.js";
+import { ChatView } from "./chat.ts";
+import { ModelSync } from "./model-sync.ts";
+import { ProgramStatusReport } from "./program-status.ts";
+import { usageLine } from "./usage-line.ts";
+
+/** The key of the status widget above the editor. */
+const WIDGET = "harness-mirror";
+
+export class Attachment {
+	readonly entryId: string;
+	readonly models: ModelSync;
+	// After a session switch, `#pi` and `#ctx` are stale and throw, so only code that checks `#closed` uses them. The
+	// components that Pi draws use `#theme` instead.
+	readonly #pi: ExtensionAPI;
+	readonly #ctx: ExtensionContext;
+	#theme: Theme;
+	readonly #frame: tui.Container;
+	readonly #status = new StatusArea();
+	readonly #mirror: Mirror;
+	#ui: TUI | undefined;
+	#chat: ChatView | undefined;
+	/** The state of the agent for Herdr, made when the agent is first known. */
+	#reporter: AgentReporter | undefined;
+	/** The state of the agent for the terminal, made with the TUI. */
+	#programStatus: ProgramStatusReport | undefined;
+	#expanded = false;
+	#closed = false;
+
+	constructor(pi: ExtensionAPI, ctx: ExtensionContext, entryId: string, target: MirrorTarget, frame: tui.Container) {
+		this.entryId = entryId;
+		this.#pi = pi;
+		this.#ctx = ctx;
+		this.#theme = ctx.ui.theme;
+		this.#frame = frame;
+		this.#frame.clear();
+		this.#frame.addChild(this.#line("muted", () => `Connecting to the ${targetTitle(target)}...`));
+		// Pi calls the factory at once, which gives the TUI that the tool cards need.
+		ctx.ui.setWidget(
+			WIDGET,
+			(ui, theme) => {
+				this.#ui = ui;
+				this.#theme = theme;
+				this.#programStatus ??= new ProgramStatusReport(ui.terminal);
+
+				return this.#status;
+			},
+			{ placement: "aboveEditor" },
+		);
+		ctx.ui.setEditorComponent((ui, theme, keybindings) => new MirrorEditor(ui, theme, keybindings, this));
+		this.#mirror = new Mirror(target, (previous) => this.#update(previous));
+		this.#programStatus?.update(this.#mirror);
+		this.models = new ModelSync(pi, ctx, this.#mirror, (cause) => this.#notify(cause));
+	}
+
+	get busy(): boolean {
+		return this.#mirror.busy;
+	}
+
+	/**
+	 * Sends `text` to the agent: a new turn when it is idle, else a steer, or a follow-up with `followUp`. A text that
+	 * does not reach the agent goes back to the editor, after the text there, so it is not lost.
+	 */
+	send(text: string, followUp: boolean): void {
+		this.#mirror.send(text, followUp).catch((cause: unknown) => {
+			if (this.#closed) return;
+			const editor = this.#ctx.ui.getEditorText();
+			this.#ctx.ui.setEditorText([editor, text].filter((part) => part.trim() !== "").join("\n\n"));
+			this.#ctx.ui.notify(`harness: not sent: ${errorMessage(cause)}`, "error");
+		});
+	}
+
+	/** Aborts the agent's turn. The queued messages that the host withdraws go back to `editor`, steers first. */
+	abort(editor: Pick<tui.Editor, "getText" | "setText">): void {
+		this.#mirror.abort().then(
+			(texts) => {
+				if (this.#closed) return;
+				const text = [...texts, editor.getText()].filter((part) => part.trim() !== "").join("\n\n");
+
+				if (text !== editor.getText()) editor.setText(text);
+			},
+			(cause: unknown) => this.#notify(cause),
+		);
+	}
+
+	/** Takes the theme and the expanded state of tool output that Pi gives when it draws the entry again. */
+	restyle(theme: Theme, expanded: boolean): void {
+		this.#theme = theme;
+		this.#expanded = expanded;
+		this.#chat?.setExpanded(expanded);
+		this.showThinkingSetting();
+	}
+
+	/** Shows or hides the thinking of the answers, as Pi's `hideThinkingBlock` setting says. */
+	showThinkingSetting(): void {
+		if (!this.#closed) this.#chat?.setHideThinking(this.#pi.getSettings().hideThinkingBlock ?? false);
+	}
+
+	/** Closes the connection and gives Pi back its editor. The agent keeps running in the host. */
+	close(): void {
+		if (this.#closed) return;
+		this.#closed = true;
+		this.models.close();
+		this.#mirror.close();
+		this.#chat?.stopTimers();
+		this.#status.dispose();
+		this.#ctx.ui.setWidget(WIDGET, undefined);
+		this.#ctx.ui.setEditorComponent(undefined);
+		void this.#reporter?.release();
+		this.#programStatus?.leave(this.#mirror);
+	}
+
+	/** Shows each change of the mirror, whose status was `previous` before it. */
+	#update(previous: MirrorStatus): void {
+		const ui = this.#ui;
+
+		if (ui === undefined || this.#closed) return;
+		const { status, view, child } = this.#mirror;
+
+		if (view !== undefined && child !== undefined) this.#showTranscript(ui, view, child, previous);
+		this.#showStatus(ui, view, child);
+
+		if (status.kind === "failed" && previous.kind !== "failed") this.#showFailure(status.reason);
+		this.#reporter?.report(this.#mirror.busy);
+		this.#programStatus?.update(this.#mirror);
+
+		if (child !== undefined) this.#followAgent(child);
+		ui.requestRender();
+	}
+
+	/**
+	 * Shows the transcript under its header, and makes the Herdr reporter at the first connection. It applies `view` only
+	 * on an open connection.
+	 */
+	#showTranscript(ui: TUI, view: ConversationView, child: ChildInfo, previous: MirrorStatus): void {
+		const chat = this.#chat ?? this.#startTranscript(ui, child);
+
+		if (this.#mirror.status.kind === "open") chat.apply(view);
+		// A running bash card keeps its timer until it gets a final result, and no connection gives one now.
+		else if (previous.kind === "open") chat.stopTimers();
+	}
+
+	#startTranscript(ui: TUI, first: ChildInfo): ChatView {
+		const chat = new ChatView(ui, first.cwd, (name, text) => this.#theme.fg(name, text));
+		this.#chat = chat;
+		chat.setExpanded(this.#expanded);
+		this.showThinkingSetting();
+		this.#frame.clear();
+		this.#frame.addChild(this.#line("muted", () => this.#header(this.#mirror.child ?? first)));
+		this.#frame.addChild(chat.transcript);
+		this.#reporter = agentReporter(process.env, childLabel(first), this.#mirror.target);
+
+		return chat;
+	}
+
+	/** Shows above the editor what the agent does, its queued messages and its usage line. */
+	#showStatus(ui: TUI, view: ConversationView | undefined, child: ChildInfo | undefined): void {
+		const { status, busy } = this.#mirror;
+		const lines: string[] = [];
+
+		if (view !== undefined && status.kind === "open") {
+			for (const { mode, text } of queued(inboxOf(view))) {
+				lines.push(this.#theme.fg("dim", `${mode === "steer" ? "Steer" : "Follow-up"}: ${text.split("\n")[0] ?? ""}`));
+			}
+		}
+
+		if (view !== undefined && child !== undefined) {
+			lines.push(usageLine(this.#theme, this.#ctx.modelRegistry, child, view));
+		}
+
+		const working =
+			status.kind === "reconnecting"
+				? "Connecting again to the harness host..."
+				: busy && view !== undefined
+					? statusText(liveOf(view)) || "Working..."
+					: "";
+
+		this.#status.show(ui, this.#theme, working, lines);
+	}
+
+	#showFailure(reason: string): void {
+		// Without a transcript, the error takes the place of the connecting line.
+		if (this.#chat === undefined) this.#frame.clear();
+		this.#frame.addChild(this.#line("error", () => reason));
+		this.#ctx.ui.notify(`harness: ${reason}`, "error");
+	}
+
+	/** Gives Pi the agent's title, and on an open connection its model and thinking level. */
+	#followAgent(child: ChildInfo): void {
+		if (this.#mirror.status.kind === "open") this.models.fromAgent(child);
+		const title = childTitle(child);
+
+		if (this.#pi.getSessionName() !== title) this.#pi.setSessionName(title);
+	}
+
+	#notify(cause: unknown): void {
+		if (!this.#closed) this.#ctx.ui.notify(`harness: ${errorMessage(cause)}`, "error");
+	}
+
+	#header(child: ChildInfo): string {
+		const theme = this.#theme;
+
+		return [theme.bold(theme.fg("accent", "harness")), theme.fg("text", childTitle(child)), child.cwd].join(" │ ");
+	}
+
+	/** One line in the theme color `name`, colored at each render so that it follows a change of theme. */
+	#line(name: ThemeColor, text: () => string): Component {
+		return {
+			render: (width) => [tui.truncateToWidth(` ${this.#theme.fg(name, text())}`, width)],
+			invalidate: () => {},
+		};
+	}
+}
+
+/**
+ * The editor of a mirror session. While the agent works, the interrupt key (Esc) aborts its turn and the follow-up key
+ * (Alt+Enter) queues the text as a follow-up. Pi's editor handles every other key. After the key that hides thinking
+ * (Ctrl+T), which Pi applies only to its own messages, the transcript of the agent follows the setting. After the key
+ * that cycles the thinking level (Shift+Tab), the agent gets the level of Pi.
+ */
+class MirrorEditor extends coding.CustomEditor {
+	readonly #keys: KeybindingsManager;
+	readonly #attachment: Attachment;
+
+	constructor(ui: TUI, theme: EditorTheme, keys: KeybindingsManager, attachment: Attachment) {
+		super(ui, theme, keys);
+		this.#keys = keys;
+		this.#attachment = attachment;
+	}
+
+	handleInput(data: string): void {
+		if (this.#attachment.busy && this.#keys.matches(data, "app.interrupt") && !this.isShowingAutocomplete()) {
+			this.#attachment.abort(this);
+
+			return;
+		}
+
+		if (this.#attachment.busy && this.#keys.matches(data, "app.message.followUp")) {
+			const text = this.getExpandedText().trim();
+
+			if (text !== "") {
+				this.addToHistory(text);
+				this.setText("");
+				this.#attachment.send(text, true);
+			}
+
+			return;
+		}
+
+		super.handleInput(data);
+
+		if (this.#keys.matches(data, "app.thinking.toggle")) this.#attachment.showThinkingSetting();
+
+		if (this.#keys.matches(data, "app.thinking.cycle")) this.#attachment.models.piCycled();
+	}
+}
+
+/** The status of the agent above the editor: Pi's working indicator while it works, then some lines. */
+class StatusArea extends tui.Container {
+	#loader: tui.Loader | undefined;
+
+	/** Shows `status` with a spinner, or nothing when it is empty, then each of `lines`, cut to the width. */
+	show(ui: TUI, theme: Theme, status: string, lines: readonly string[]): void {
+		if (status === "") {
+			this.dispose();
+		} else if (this.#loader === undefined) {
+			const spinner = (text: string) => theme.fg("accent", text);
+			this.#loader = new tui.Loader(ui, spinner, (text) => theme.fg("muted", text), status);
+		} else {
+			this.#loader.setMessage(status);
+		}
+
+		this.clear();
+
+		if (this.#loader !== undefined) this.addChild(this.#loader);
+
+		for (const line of lines) this.addChild(new tui.TruncatedText(line, 1, 0));
+	}
+
+	dispose(): void {
+		this.#loader?.stop();
+		this.#loader = undefined;
+	}
+}

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");
 			}
 		},