gentle-pi 3.4.0 → 3.5.0

package/extensions/ask-user-question.ts

@@ -1,14 +1,15 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { DynamicBorder } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 import { createNativeFullscreenInteraction } from "../lib/native-fullscreen-interaction.ts";
-import { type QuestionParams, QuestionParamsSchema } from "../lib/questionnaire/schema.ts";
+import { type QuestionData, type QuestionParams, QuestionParamsSchema } from "../lib/questionnaire/schema.ts";
 import {
 	QuestionnaireView,
 	type AnswerRow,
 	type QuestionnaireResult,
 } from "../lib/questionnaire/questionnaire-view.ts";
 import { validateQuestionnaire, type QuestionnaireError } from "../lib/questionnaire/validate.ts";
+import { isInteractiveRpcHost } from "../lib/rpc-host.ts";
 
 const QUESTION_TOOL_NAME = "ask_user_question";
 const ASK_USER_QUESTION_BLOCKED_EVENT = "gentle-pi:ask-user-question:blocked";
@@ -51,6 +52,124 @@ function unavailableResult(): QuestionnaireToolResult {
 	};
 }
 
+/** Same cancellation shape the TUI questionnaire returns for its Escape key. */
+function cancelledResult(): QuestionnaireToolResult {
+	return {
+		content: [{ type: "text", text: "User cancelled the questionnaire" }],
+		details: { cancelled: true },
+	};
+}
+
+/** Label for the trailing "finish this question" entry in a multiSelect round. */
+const MULTI_SELECT_DONE_LABEL = "Done";
+
+/** One toggle round's select prompt: `[x] label` / `[ ] label` plus Done. */
+function multiSelectRoundOptions(question: QuestionData, toggled: readonly boolean[]): string[] {
+	return [
+		...question.options.map((choiceOption, index) => `${toggled[index] ? "[x]" : "[ ]"} ${choiceOption.label}`),
+		MULTI_SELECT_DONE_LABEL,
+	];
+}
+
+/**
+ * Floor for the toggle-round safety cap so a misbehaving or chatty host
+ * cannot spin this loop forever, and every question -- however few options
+ * it has -- still gets room to toggle, untoggle, and retoggle before Done.
+ */
+const MULTI_SELECT_ROUND_CAP_FLOOR = 32;
+
+/**
+ * Hard bound on toggle rounds for one question: every option must be
+ * toggleable at least once, plus one round for the explicit Done and one
+ * spare round for a single correction (an un-toggle), so the cap scales
+ * with the option count (`options.length + 2`), floored at
+ * `MULTI_SELECT_ROUND_CAP_FLOOR` for small questions.
+ */
+function multiSelectRoundCap(optionsLength: number): number {
+	return Math.max(MULTI_SELECT_ROUND_CAP_FLOOR, optionsLength + 2);
+}
+
+/** Committed multiSelect answer from the current toggle state (explicit Done, or every option toggled on). */
+function finishMultiSelect(question: QuestionData, toggled: readonly boolean[]): AnswerRow {
+	return {
+		questionIndex: -1, // overwritten by the caller with the question's position
+		question: question.question,
+		kind: "multi",
+		answer: null,
+		selected: question.options.filter((_choiceOption, index) => toggled[index]).map((choiceOption) => choiceOption.label),
+	};
+}
+
+/**
+ * Resolves one multiSelect question by looping `ctx.ui.select` over toggle
+ * rounds, bounded by `multiSelectRoundCap`. Returns `undefined` on
+ * cancellation, when the cap is hit without an explicit Done, and when the
+ * host returns an answer that matches none of the current round's options:
+ * a partial toggle state must never commit silently in either case.
+ */
+export async function askMultiSelect(
+	ctx: Pick<ExtensionContext, "ui">,
+	question: QuestionData,
+): Promise<AnswerRow | undefined> {
+	const toggled = question.options.map(() => false);
+	const roundCap = multiSelectRoundCap(question.options.length);
+	for (let round = 0; round < roundCap; round++) {
+		const roundOptions = multiSelectRoundOptions(question, toggled);
+		const picked = await ctx.ui.select(`${question.header}: ${question.question}`, roundOptions);
+		if (picked === undefined) return undefined;
+		const pickedIndex = roundOptions.indexOf(picked);
+		if (pickedIndex === question.options.length) return finishMultiSelect(question, toggled); // explicit Done
+		if (pickedIndex === -1) return undefined; // unrecognised answer: never commit a partial state
+		toggled[pickedIndex] = !toggled[pickedIndex];
+		if (toggled.every(Boolean)) return finishMultiSelect(question, toggled);
+	}
+	// The safety cap was spent without an explicit Done: refuse to commit a
+	// partial selection silently and cancel instead.
+	return undefined;
+}
+
+/** Resolves one single-select question through `ctx.ui.select`. Returns `undefined` on cancellation. */
+async function askSingleSelect(
+	ctx: Pick<ExtensionContext, "ui">,
+	question: QuestionData,
+): Promise<AnswerRow | undefined> {
+	const labels = question.options.map((choiceOption) => choiceOption.label);
+	const picked = await ctx.ui.select(`${question.header}: ${question.question}`, labels);
+	if (picked === undefined) return undefined;
+	const chosen = question.options.find((choiceOption) => choiceOption.label === picked);
+	return {
+		questionIndex: -1, // overwritten by the caller with the question's position
+		question: question.question,
+		kind: "option",
+		answer: picked,
+		...(chosen?.preview !== undefined ? { preview: chosen.preview } : {}),
+	};
+}
+
+/**
+ * Interactive-RPC-host fallback for the TUI questionnaire: one
+ * `ctx.ui.select` dialog per question (looped for multiSelect), keeping the
+ * exact TUI result shapes. A cancel on any question cancels the whole
+ * questionnaire, matching the TUI Escape key. There is no schema-declared
+ * free-text option (`lib/questionnaire/schema.ts` has none), so the
+ * always-available "Type something." row has no RPC-dialog equivalent here.
+ */
+async function askThroughDialogs(
+	ctx: Pick<ExtensionContext, "ui">,
+	params: QuestionParams,
+): Promise<QuestionnaireToolResult> {
+	const answers: AnswerRow[] = [];
+	for (let questionIndex = 0; questionIndex < params.questions.length; questionIndex++) {
+		const question = params.questions[questionIndex]!;
+		const answer = question.multiSelect
+			? await askMultiSelect(ctx, question)
+			: await askSingleSelect(ctx, question);
+		if (answer === undefined) return cancelledResult();
+		answers.push({ ...answer, questionIndex });
+	}
+	return { content: [{ type: "text", text: answersText(answers) }], details: { answers } };
+}
+
 /**
  * Human-readable body for one answer. A custom answer on a multiSelect
  * question keeps the toggled options, so the text must name them explicitly:
@@ -145,7 +264,16 @@ export default function askUserQuestion(pi: ExtensionAPI): void {
 		): Promise<QuestionnaireToolResult> {
 			const error = validateQuestionnaire(params);
 			if (error) return invalidQuestionnaireResult(error);
-			if (ctx.mode !== "tui") return unavailableResult();
+			if (ctx.mode !== "tui") {
+				if (!isInteractiveRpcHost(ctx.mode, process.env)) return unavailableResult();
+				try {
+					pi.events.emit(ASK_USER_QUESTION_BLOCKED_EVENT, { active: true });
+					return await askThroughDialogs(ctx, params);
+				}
+				finally {
+					pi.events.emit(ASK_USER_QUESTION_BLOCKED_EVENT, { active: false });
+				}
+			}
 
 			let selection: QuestionnaireResult | undefined;
 			try {

package/extensions/gentle-agents.ts

@@ -28,6 +28,8 @@ import { historyDir, loadHistory, loadStoredTask, pruneHistory, saveTask } from
 import { sessionToMarkdown } from "../lib/agents-transcript.ts";
 import { AgentsView } from "../lib/agents-view.ts";
 import { PresencePublisher } from "../lib/orchestrator-presence.ts";
+import { createRpcActivityPublisher, type RpcActivityPublisher } from "../lib/agents-rpc-publisher.ts";
+import { isInteractiveRpcHost } from "../lib/rpc-host.ts";
 import { createNativeFullscreenInteraction } from "../lib/native-fullscreen-interaction.ts";
 import { AGENTS_GLYPH, renderAgentsCard, widgetExpiryMs, widgetRows } from "../lib/agents-widget.ts";
 import { CARD_TONE, renderCard } from "../lib/shell-card.ts";
@@ -476,6 +478,12 @@ export default function gentleAgents(pi: ExtensionAPI, env: NodeJS.ProcessEnv =
 	let sidebarTui: TUI | undefined;
 	let sessions: ExtensionContext["sessionManager"] | undefined;
 	let presence: PresencePublisher | undefined;
+	let rpcActivityPublisher: RpcActivityPublisher | undefined;
+	// Messages already surfaced to the user this session through the RPC
+	// activity publisher's `onError`, so a recurring push failure (the
+	// coalescing window retries every burst) notifies at most once per
+	// session instead of flooding the UI. Reset on every `session_start`.
+	let notifiedRpcActivityErrors: Set<string> | undefined;
 	const overlays = new Set<AgentsView>();
 	const publishActivity = () => {
 		if (!sessions) return;
@@ -1450,12 +1458,37 @@ export default function gentleAgents(pi: ExtensionAPI, env: NodeJS.ProcessEnv =
 			publishActivity();
 		} catch { presence = undefined; }
 		void startSessionTransport(ctx);
+		// The desktop app's own pi process: publish live subagent state through
+		// setWidget's RPC-mode string[] path. Plain headless RPC (no variable) and
+		// TUI are untouched -- the TUI card above the editor is showWidget's own
+		// factory push, ignored by pi's RPC transport since it is not an array.
+		rpcActivityPublisher?.stop();
+		rpcActivityPublisher = undefined;
+		notifiedRpcActivityErrors = new Set();
+		if (ctx.hasUI && isInteractiveRpcHost(ctx.mode, deps.env)) {
+			rpcActivityPublisher = createRpcActivityPublisher({
+				store,
+				ui: { setWidget: (key, lines) => ctx.ui.setWidget(key, lines) },
+				now: deps.now,
+				schedule: deps.schedule,
+				parentSessionId: activeSessionId(),
+				onError: (error) => {
+					const message = `Gentle Agents activity push failed: ${error instanceof Error ? error.message : String(error)}`;
+					if (notifiedRpcActivityErrors?.has(message)) return;
+					notifiedRpcActivityErrors?.add(message);
+					ctx.ui.notify(message, "warning");
+				},
+			});
+			rpcActivityPublisher.start();
+		}
 	});
 	pi.on("session_shutdown", async () => {
 		completions.dropAll();
 		activeAgentRuns = 0;
 		presence?.dispose();
 		presence = undefined;
+		rpcActivityPublisher?.stop();
+		rpcActivityPublisher = undefined;
 		cancelClock?.();
 		for (const view of overlays) { view.handleInput("q"); view.dispose(); }
 		overlays.clear();

package/lib/agents-rpc-publisher.ts

@@ -0,0 +1,342 @@
+import { isFinished, THREAD_ITEM, TASK_STATUS, type TaskRecord, type TaskStatus, type TaskStore, type TaskSummary, type ThreadItem } from "./agents-protocol.ts";
+
+// Publishes live Gentle Agents subagent state to an interactive RPC host
+// (the desktop app), the RPC equivalent of the above-editor TUI card. Pi's
+// only fire-and-forget, structured-enough RPC push is `setWidget(key, string[])`
+// (component factories are ignored in RPC mode), so this module projects the
+// TaskStore through the same field-whitelist discipline as
+// `lib/orchestrator-presence.ts`, bounds the payload, and coalesces bursts of
+// task events into one `setWidget` call per window.
+
+/** Schema tag carried on every published line so a client can version the payload shape. */
+export const ACTIVITY_SCHEMA = "gentle-agents.activity/v1";
+/** Same widget key the TUI card uses. RPC's `setWidget` only accepts a component
+ * factory (ignored) or a `string[]` (sent), so the two publications never collide
+ * on the wire even though they share a key. */
+export const ACTIVITY_WIDGET_KEY = "gentle-agents";
+
+/** Prompts are the field most likely to carry a long user request; keep only a preview. */
+const PROMPT_LIMIT = 200;
+/** Tool args/output can be arbitrarily large; bound each independently. */
+const TOOL_ARGS_LIMIT = 500;
+const TOOL_OUTPUT_LIMIT = 500;
+/** Text/thinking/note thread item text can be arbitrarily large (a whole streamed reply); bound it too. */
+const TEXT_ITEM_LIMIT = 2000;
+/** Summary fields that can carry a long, freeform diagnostic or step name. */
+const SUMMARY_FIELD_LIMIT = 500;
+/** Thread items kept per task in one push, most recent last. */
+const DEFAULT_THREAD_ITEMS = 40;
+/** Total payload bound before shrinking kicks in. */
+export const DEFAULT_MAX_BYTES = 256 * 1024;
+/** How long a burst of task/summary changes is coalesced before one push. */
+const DEFAULT_COALESCE_MS = 150;
+
+export interface RpcTaskSummary {
+	id: string;
+	agent: string;
+	label: string;
+	prompt: string;
+	status: TaskStatus;
+	createdAt: number;
+	startedAt: number | null;
+	endedAt: number | null;
+	lastStep: string;
+	lastActivityAt: number;
+	turns: number;
+	toolCalls: number;
+	error: string | null;
+}
+
+export interface RpcThreadTextItem {
+	kind: typeof THREAD_ITEM.TEXT | typeof THREAD_ITEM.THINKING | typeof THREAD_ITEM.NOTE;
+	text: string;
+}
+
+export interface RpcThreadToolItem {
+	kind: typeof THREAD_ITEM.TOOL;
+	name: string;
+	/** JSON-stringified and truncated; never the raw args object. */
+	args: string;
+	running: boolean;
+	isError: boolean;
+	output: string;
+}
+
+export type RpcThreadItem = RpcThreadTextItem | RpcThreadToolItem;
+
+export interface RpcThread {
+	version: number;
+	dropped: number;
+	items: RpcThreadItem[];
+}
+
+export interface RpcTask {
+	summary: RpcTaskSummary;
+	thread: RpcThread;
+}
+
+export interface RpcActivity {
+	schema: typeof ACTIVITY_SCHEMA;
+	summary: TaskSummary;
+	tasks: RpcTask[];
+}
+
+function truncate(text: string, limit: number): string {
+	return text.length <= limit ? text : `${text.slice(0, Math.max(0, limit - 1))}…`;
+}
+
+function safeStringify(value: unknown): string {
+	try {
+		return JSON.stringify(value) ?? "null";
+	} catch {
+		return "[unserializable]";
+	}
+}
+
+function projectThreadItem(item: ThreadItem): RpcThreadItem {
+	if (item.kind === THREAD_ITEM.TOOL) {
+		return {
+			kind: item.kind,
+			name: item.name,
+			args: truncate(safeStringify(item.args), TOOL_ARGS_LIMIT),
+			running: item.running,
+			isError: item.isError,
+			output: truncate(item.output, TOOL_OUTPUT_LIMIT),
+		};
+	}
+	return { kind: item.kind, text: truncate(item.text, TEXT_ITEM_LIMIT) };
+}
+
+function projectTaskSummary(task: TaskRecord): RpcTaskSummary {
+	return {
+		id: task.id,
+		agent: task.agent,
+		label: truncate(task.label, SUMMARY_FIELD_LIMIT),
+		prompt: truncate(task.prompt, PROMPT_LIMIT),
+		status: task.status,
+		createdAt: task.createdAt,
+		startedAt: task.startedAt,
+		endedAt: task.endedAt,
+		lastStep: truncate(task.lastStep, SUMMARY_FIELD_LIMIT),
+		lastActivityAt: task.lastActivityAt,
+		turns: task.turns,
+		toolCalls: task.toolCalls,
+		error: task.error === null ? null : truncate(task.error, SUMMARY_FIELD_LIMIT),
+	};
+}
+
+/** Ordering rank: running, then waiting, then queued, ahead of every finished status. */
+const STATUS_RANK: Partial<Record<TaskStatus, number>> = {
+	[TASK_STATUS.RUNNING]: 0,
+	[TASK_STATUS.WAITING]: 1,
+	[TASK_STATUS.QUEUED]: 2,
+};
+const FINISHED_RANK = 3;
+
+function orderTasks(tasks: readonly TaskRecord[]): TaskRecord[] {
+	return [...tasks].sort((a, b) => {
+		const rankA = STATUS_RANK[a.status] ?? FINISHED_RANK;
+		const rankB = STATUS_RANK[b.status] ?? FINISHED_RANK;
+		if (rankA !== rankB) return rankA - rankB;
+		// Within the active ranks, TaskStore#list's own recency order is kept
+		// (Array#sort is stable). Finished tasks sort by endedAt desc.
+		return rankA === FINISHED_RANK ? (b.endedAt ?? 0) - (a.endedAt ?? 0) : 0;
+	});
+}
+
+export interface ProjectRpcActivityOptions {
+	/** Restrict to one parent session's tasks, matching `TaskStore#list`/`#summary`. */
+	parentSessionId?: string;
+	/** Thread items kept per task, most recent last. */
+	maxThreadItems?: number;
+}
+
+/** Whitelisted, ordered, size-bounded projection of `store` for one RPC push. Pure: reads the store, never mutates it. */
+export function projectRpcActivity(store: TaskStore, opts: ProjectRpcActivityOptions = {}): RpcActivity {
+	const { parentSessionId, maxThreadItems = DEFAULT_THREAD_ITEMS } = opts;
+	const tasks = orderTasks(store.list(parentSessionId));
+	return {
+		schema: ACTIVITY_SCHEMA,
+		summary: store.summary(parentSessionId),
+		tasks: tasks.map((task) => {
+			const thread = store.thread(task.id);
+			const kept = maxThreadItems >= thread.items.length ? thread.items : thread.items.slice(thread.items.length - maxThreadItems);
+			return { summary: projectTaskSummary(task), thread: { version: thread.version, dropped: thread.dropped, items: kept.map(projectThreadItem) } };
+		}),
+	};
+}
+
+function byteLength(value: string): number {
+	return Buffer.byteLength(value, "utf8");
+}
+
+function halveThreadItems(task: RpcTask): RpcTask {
+	if (task.thread.items.length <= 1) return task;
+	const nextLength = Math.max(1, Math.floor(task.thread.items.length / 2));
+	return { ...task, thread: { ...task.thread, items: task.thread.items.slice(task.thread.items.length - nextLength) } };
+}
+
+function emptyFinishedThread(task: RpcTask): RpcTask {
+	return isFinished(task.summary.status) ? { ...task, thread: { ...task.thread, items: [] } } : task;
+}
+
+function lastFinishedIndex(tasks: readonly RpcTask[]): number {
+	for (let index = tasks.length - 1; index >= 0; index -= 1) {
+		if (isFinished(tasks[index]!.summary.status)) return index;
+	}
+	return -1;
+}
+
+/**
+ * Serializes `activity` as one JSON line, shrinking it under `maxBytes` when
+ * needed, in order: first halve every task's kept thread items (repeatedly,
+ * down to one item each), then empty finished tasks' threads, then drop
+ * whole finished tasks (oldest-finished first, by `endedAt`), and finally --
+ * once only active (running/waiting/queued) tasks with one item each
+ * remain -- empty every remaining task's thread too, emitting a
+ * summary-only payload. Never throws; a payload nothing can shrink further
+ * is returned as-is, oversized.
+ */
+export function encodeActivityLines(activity: RpcActivity, maxBytes: number = DEFAULT_MAX_BYTES): string[] {
+	let working = activity;
+	let line = JSON.stringify(working);
+	if (byteLength(line) <= maxBytes) return [line];
+
+	while (byteLength(line) > maxBytes && working.tasks.some((task) => task.thread.items.length > 1)) {
+		working = { ...working, tasks: working.tasks.map(halveThreadItems) };
+		line = JSON.stringify(working);
+	}
+
+	while (byteLength(line) > maxBytes && working.tasks.some((task) => isFinished(task.summary.status) && task.thread.items.length > 0)) {
+		working = { ...working, tasks: working.tasks.map(emptyFinishedThread) };
+		line = JSON.stringify(working);
+	}
+
+	while (byteLength(line) > maxBytes) {
+		const dropIndex = lastFinishedIndex(working.tasks);
+		if (dropIndex === -1) break;
+		working = { ...working, tasks: working.tasks.filter((_task, index) => index !== dropIndex) };
+		line = JSON.stringify(working);
+	}
+
+	// Last resort: every finished task is already dropped, but the
+	// remaining active tasks' single-item threads still don't fit. No
+	// summary itself is ever dropped -- only its thread.
+	while (byteLength(line) > maxBytes && working.tasks.some((task) => task.thread.items.length > 0)) {
+		working = { ...working, tasks: working.tasks.map((task) => ({ ...task, thread: { ...task.thread, items: [] } })) };
+		line = JSON.stringify(working);
+	}
+
+	return [line];
+}
+
+export interface RpcActivityPublisherUi {
+	setWidget(key: string, lines: string[]): void;
+}
+
+export interface RpcActivityPublisherDeps {
+	store: TaskStore;
+	ui: RpcActivityPublisherUi;
+	/** Unused by the publisher itself; accepted for symmetry with the rest of `AgentsDeps`. */
+	now?: () => number;
+	/** Same convention as `AgentsDeps.schedule`: returns a cancel function. */
+	schedule?: (fn: () => void, ms: number) => () => void;
+	coalesceMs?: number;
+	maxBytes?: number;
+	maxThreadItems?: number;
+	parentSessionId?: string;
+	/** Never let a `setWidget` failure escape the publisher; logs go here instead. */
+	onError?: (error: unknown) => void;
+}
+
+export interface RpcActivityPublisher {
+	start(): void;
+	stop(): void;
+	/** Publish immediately, cancelling any pending coalescing timer. */
+	flush(): void;
+}
+
+function defaultSchedule(fn: () => void, ms: number): () => void {
+	const timer = setTimeout(fn, ms);
+	(timer as unknown as { unref?: () => void }).unref?.();
+	return () => clearTimeout(timer);
+}
+
+/**
+ * Subscribes to `store.subscribeSummary` (task add/remove/status changes)
+ * and to `store.subscribe(id)` for every known task, coalescing bursts into
+ * one bounded `setWidget(ACTIVITY_WIDGET_KEY, lines)` push per window.
+ */
+export function createRpcActivityPublisher(deps: RpcActivityPublisherDeps): RpcActivityPublisher {
+	const {
+		store,
+		ui,
+		schedule = defaultSchedule,
+		coalesceMs = DEFAULT_COALESCE_MS,
+		maxBytes = DEFAULT_MAX_BYTES,
+		maxThreadItems = DEFAULT_THREAD_ITEMS,
+		parentSessionId,
+		onError = () => {},
+	} = deps;
+
+	let cancelTimer: (() => void) | undefined;
+	const taskUnsubscribes = new Map<string, () => void>();
+	let summaryUnsubscribe: (() => void) | undefined;
+	let started = false;
+
+	const publish = () => {
+		try {
+			const activity = projectRpcActivity(store, { parentSessionId, maxThreadItems });
+			const lines = encodeActivityLines(activity, maxBytes);
+			ui.setWidget(ACTIVITY_WIDGET_KEY, lines);
+		} catch (error) {
+			onError(error);
+		}
+	};
+
+	const scheduleFlush = () => {
+		if (cancelTimer) return;
+		cancelTimer = schedule(() => {
+			cancelTimer = undefined;
+			publish();
+		}, coalesceMs);
+	};
+
+	const trackTask = (id: string) => {
+		if (taskUnsubscribes.has(id)) return;
+		taskUnsubscribes.set(id, store.subscribe(id, scheduleFlush));
+	};
+
+	const syncTasks = () => {
+		for (const task of store.list(parentSessionId)) trackTask(task.id);
+	};
+
+	return {
+		start() {
+			if (started) return;
+			started = true;
+			syncTasks();
+			summaryUnsubscribe = store.subscribeSummary(() => {
+				syncTasks();
+				scheduleFlush();
+			});
+			scheduleFlush();
+		},
+		stop() {
+			if (!started) return;
+			started = false;
+			cancelTimer?.();
+			cancelTimer = undefined;
+			summaryUnsubscribe?.();
+			summaryUnsubscribe = undefined;
+			for (const unsubscribe of taskUnsubscribes.values()) unsubscribe();
+			taskUnsubscribes.clear();
+			publish();
+		},
+		flush() {
+			cancelTimer?.();
+			cancelTimer = undefined;
+			publish();
+		},
+	};
+}

package/lib/agents-runner.ts

@@ -2,6 +2,7 @@ import { isSessionChangeEvidence, type SessionChangeEvidence } from "./session-c
 import type { Duplex, Readable, Writable } from "node:stream";
 import { stripVTControlCharacters } from "node:util";
 import { RESEARCH_SELECTION_ENV } from "./sdd-research-capabilities.ts";
+import { withoutInteractiveHost } from "./rpc-host.ts";
 import { AGENT_MODE, formatModelRef, type AgentDefinition, type AgentMode, type ModelRef } from "./agents-config.ts";
 import { CHILD_QUERY_MAX_INFLIGHT, CHILD_QUERY_TIMEOUT_MS, parseChildFrame, validChildMessage, validChildQueryId } from "./agents-messaging.ts";
 import { ParentStandingReviewPermissionBroker } from "./review-session-standing-permission-ipc.ts";
@@ -491,13 +492,17 @@ export class AgentRunner {
 		const detached = this.processControl.platform !== "win32";
 		const hasParentPermissionChannel = request.authorizeParentStandingReviewPermission !== undefined;
 		const permissionChannelStdio = this.processControl.platform === "win32" ? "overlapped" : "pipe";
-		const env = {
+		// Subagent children are always headless: strip the desktop app's
+		// interactive-host signal even if it leaked into `request.env`, so a
+		// child spawned from an interactive RPC host never mistakes itself for
+		// one (`lib/rpc-host.ts`).
+		const env = withoutInteractiveHost({
 			...request.env,
 			...(request.extensionPaths ? { [RESEARCH_SELECTION_ENV]: JSON.stringify(request.researchSelection ?? null) } : {}),
 			[CHILD_MARKER]: "1",
 			[IPC_MARKER]: `${this.deps.now()}-${Math.random().toString(36).slice(2)}`,
 			...(hasParentPermissionChannel ? { GENTLE_PI_AGENTS_PARENT_PERMISSION_FD: "3" } : {}),
-		};
+		});
 		delete env[REMEDIATION_PLAN_ENV];
 		if (request.sddRemediation) env[REMEDIATION_PLAN_ENV] = JSON.stringify({ plan: request.sddRemediation.plan, scope: request.sddRemediation.scope, selection: request.sddChange });
 		let child: ChildLike;