gentle-pi 3.4.0 → 3.5.1

package/tests/ask-user-choice.test.ts

@@ -133,6 +133,47 @@ const options = [
 	{ label: "Preserve requested hash", description: "Keep the hash from the original request.", value: "preserve_requested_hash" },
 ];
 
+const INTERACTIVE_HOST_ENV = "GENTLE_SHELL_INTERACTIVE_HOST";
+
+function withInteractiveHostEnv(t: { after(fn: () => void): void }): void {
+	const previous = process.env[INTERACTIVE_HOST_ENV];
+	process.env[INTERACTIVE_HOST_ENV] = "1";
+	t.after(() => {
+		if (previous === undefined) delete process.env[INTERACTIVE_HOST_ENV];
+		else process.env[INTERACTIVE_HOST_ENV] = previous;
+	});
+}
+
+/** Fake interactive-RPC-host ctx: scripted `select`/`input` answers, one per call. */
+function rpcHostContext(selectAnswers: readonly (string | undefined)[], inputAnswers: readonly (string | undefined)[] = []) {
+	const selectCalls: Array<{ title: string; options: string[] }> = [];
+	const inputCalls: Array<{ title: string; placeholder?: string }> = [];
+	let selectIndex = 0;
+	let inputIndex = 0;
+	return {
+		ctx: {
+			mode: "rpc",
+			hasUI: true,
+			ui: {
+				select: async (title: string, opts: string[]) => {
+					selectCalls.push({ title, options: opts });
+					const answer = selectAnswers[selectIndex];
+					selectIndex += 1;
+					return answer;
+				},
+				input: async (title: string, placeholder?: string) => {
+					inputCalls.push({ title, placeholder });
+					const answer = inputAnswers[inputIndex];
+					inputIndex += 1;
+					return answer;
+				},
+			},
+		},
+		selectCalls,
+		inputCalls,
+	};
+}
+
 function tuiContext(inputs: readonly string[], rendered: { value: string }) {
 	return {
 		mode: "tui",
@@ -483,6 +524,80 @@ test("ask_user_choice cancels without a value and remains unavailable outside th
 	);
 });
 
+test("ask_user_choice stays unavailable on a plain rpc host without the interactive-host variable", async (t) => {
+	const { tool } = registerChoiceTool();
+	t.after(() => { delete process.env[INTERACTIVE_HOST_ENV]; });
+	delete process.env[INTERACTIVE_HOST_ENV];
+
+	await assert.rejects(
+		() => tool.execute("call", { question: "Proceed?", options }, new AbortController().signal, undefined, { mode: "rpc", hasUI: true, ui: { select: async () => undefined } }),
+		/unavailable outside the interactive TUI/,
+	);
+});
+
+/** Expected `gentle-pi:ask-user-choice:blocked` sequence around one RPC-dialog turn. */
+const RPC_BLOCKED_SEQUENCE = [
+	{ channel: "gentle-pi:ask-user-choice:blocked", data: { active: true } },
+	{ channel: "gentle-pi:ask-user-choice:blocked", data: { active: false } },
+];
+
+test("ask_user_choice resolves a selection through RPC dialogs on an interactive host", async (t) => {
+	withInteractiveHostEnv(t);
+	const registration = registerChoiceTool();
+	const { tool } = registration;
+	const { ctx, selectCalls } = rpcHostContext([options[1]!.label]);
+
+	const result = await tool.execute("call", { question: "Proceed?", options }, new AbortController().signal, undefined, ctx);
+
+	assert.equal(selectCalls.length, 1);
+	assert.equal(selectCalls[0]?.title, "Proceed?");
+	assert.deepEqual(selectCalls[0]?.options, [options[0]!.label, options[1]!.label]);
+	assert.deepEqual(result.details.selection, { value: options[1]!.value, label: options[1]!.label, index: 2 });
+	assert.equal(result.content[0]?.text, `User selected: 2. ${options[1]!.label} (value: ${options[1]!.value})`);
+	assert.deepEqual(registration.emittedEvents(), RPC_BLOCKED_SEQUENCE);
+});
+
+test("ask_user_choice resolves an Other… custom response through ctx.ui.input on an interactive host", async (t) => {
+	withInteractiveHostEnv(t);
+	const registration = registerChoiceTool();
+	const { tool } = registration;
+	const { ctx, selectCalls, inputCalls } = rpcHostContext(["Other…"], ["a free-form reply"]);
+
+	const result = await tool.execute("call", { question: "Explain?", options, allowCustomResponse: true }, new AbortController().signal, undefined, ctx);
+
+	assert.deepEqual(selectCalls[0]?.options, [options[0]!.label, options[1]!.label, "Other…"]);
+	assert.equal(inputCalls.length, 1);
+	assert.equal(inputCalls[0]?.title, "Explain?");
+	assert.deepEqual(result.details, { question: "Explain?", options, customResponse: "a free-form reply" });
+	assert.equal(result.content[0]?.text, "User responded: a free-form reply");
+	assert.deepEqual(registration.emittedEvents(), RPC_BLOCKED_SEQUENCE);
+});
+
+test("ask_user_choice cancels through RPC dialogs like the TUI path when select returns undefined", async (t) => {
+	withInteractiveHostEnv(t);
+	const registration = registerChoiceTool();
+	const { tool } = registration;
+	const { ctx } = rpcHostContext([undefined]);
+
+	const result = await tool.execute("call", { question: "Proceed?", options }, new AbortController().signal, undefined, ctx);
+
+	assert.deepEqual(result.details, { question: "Proceed?", options, cancelled: true });
+	assert.equal(result.content[0]?.text, "User cancelled the choice");
+	assert.deepEqual(registration.emittedEvents(), RPC_BLOCKED_SEQUENCE, "the blocked lifecycle must still balance on a cancel");
+});
+
+test("ask_user_choice cancels through RPC dialogs when the Other… input is cancelled", async (t) => {
+	withInteractiveHostEnv(t);
+	const registration = registerChoiceTool();
+	const { tool } = registration;
+	const { ctx } = rpcHostContext(["Other…"], [undefined]);
+
+	const result = await tool.execute("call", { question: "Explain?", options, allowCustomResponse: true }, new AbortController().signal, undefined, ctx);
+
+	assert.deepEqual(result.details, { question: "Explain?", options, cancelled: true });
+	assert.deepEqual(registration.emittedEvents(), RPC_BLOCKED_SEQUENCE, "the blocked lifecycle must still balance on a cancel");
+});
+
 test("ask_user_choice emits a private balanced lifecycle around selection and cancellation", async () => {
 	const sequence: string[] = [];
 	const selectedRegistration = registerChoiceTool([], ({ data }) => {
@@ -582,3 +697,17 @@ test("ask_user_choice is offered only for interactive TUI turns and preserves th
 	for (const hook of registration.hooks) await hook({}, { mode: "print" });
 	assert.deepEqual(registration.activeTools(), ["read", "ask_user_question"]);
 });
+
+test("ask_user_choice is offered on an interactive rpc host and withdrawn once the variable is gone", async (t) => {
+	const registration = registerChoiceTool(["read"]);
+	registration.allowRuntimeActions();
+	t.after(() => { delete process.env[INTERACTIVE_HOST_ENV]; });
+
+	process.env[INTERACTIVE_HOST_ENV] = "1";
+	for (const hook of registration.hooks) await hook({}, { mode: "rpc" });
+	assert.deepEqual(registration.activeTools(), ["read", "ask_user_choice"]);
+
+	delete process.env[INTERACTIVE_HOST_ENV];
+	for (const hook of registration.hooks) await hook({}, { mode: "rpc" });
+	assert.deepEqual(registration.activeTools(), ["read"]);
+});

package/tests/ask-user-question.test.ts

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import askUserQuestion from "../extensions/ask-user-question.ts";
+import askUserQuestion, { askMultiSelect } from "../extensions/ask-user-question.ts";
 
 /** Plain theme fake: identity styling keeps rendered assertions readable. */
 interface Theme {
@@ -107,6 +107,38 @@ function run(tool: RegisteredTool, params: unknown, ctx: unknown): Promise<ToolR
 	return tool.execute("call", params, new AbortController().signal, undefined, ctx);
 }
 
+const INTERACTIVE_HOST_ENV = "GENTLE_SHELL_INTERACTIVE_HOST";
+
+/** Fake interactive-RPC-host ctx: scripted `select` answers, one per call. */
+function rpcHostContext(selectAnswers: readonly (string | undefined)[]) {
+	const selectCalls: Array<{ title: string; options: string[] }> = [];
+	let index = 0;
+	return {
+		ctx: {
+			mode: "rpc",
+			hasUI: true,
+			ui: {
+				select: async (title: string, options: string[]) => {
+					selectCalls.push({ title, options });
+					const answer = selectAnswers[index];
+					index += 1;
+					return answer;
+				},
+			},
+		},
+		selectCalls,
+	};
+}
+
+function withInteractiveHostEnv(t: { after(fn: () => void): void }): void {
+	const previous = process.env[INTERACTIVE_HOST_ENV];
+	process.env[INTERACTIVE_HOST_ENV] = "1";
+	t.after(() => {
+		if (previous === undefined) delete process.env[INTERACTIVE_HOST_ENV];
+		else process.env[INTERACTIVE_HOST_ENV] = previous;
+	});
+}
+
 const option = (label: string, description = `${label} description`, preview?: string) =>
 	preview === undefined ? { label, description } : { label, description, preview };
 
@@ -185,6 +217,200 @@ test("ask_user_question stays unavailable outside the interactive TUI", async ()
 	assert.deepEqual(emitted, []);
 });
 
+test("ask_user_question stays unavailable on a plain rpc host without the interactive-host variable", async (t) => {
+	const { tool, emitted } = registerQuestionTool();
+	let selectCalls = 0;
+	const ctx = {
+		mode: "rpc",
+		hasUI: true,
+		ui: { select: async () => { selectCalls++; return undefined; } },
+	};
+	t.after(() => { delete process.env[INTERACTIVE_HOST_ENV]; });
+	delete process.env[INTERACTIVE_HOST_ENV];
+
+	const result = await run(tool, { questions: single() }, ctx);
+
+	assert.match(result.content[0]?.text ?? "", /unavailable outside the interactive TUI/);
+	assert.equal(result.details.errorKind, "unavailable_outside_tui");
+	assert.equal(selectCalls, 0);
+	assert.deepEqual(emitted, []);
+});
+
+test("ask_user_question resolves a single-select answer through RPC dialogs on an interactive host", async (t) => {
+	withInteractiveHostEnv(t);
+	const { tool, emitted } = registerQuestionTool();
+	const { ctx, selectCalls } = rpcHostContext(["Alpha"]);
+
+	const result = await run(tool, { questions: single() }, ctx);
+
+	assert.equal(selectCalls.length, 1);
+	assert.equal(selectCalls[0]?.title, "Proceed: Proceed?");
+	assert.deepEqual(selectCalls[0]?.options, ["Alpha", "Beta"]);
+	assert.equal(result.content[0]?.text, "1. Proceed? — Alpha");
+	assert.deepEqual(result.details.answers, [
+		{ questionIndex: 0, question: "Proceed?", kind: "option", answer: "Alpha" },
+	]);
+	assert.deepEqual(emitted, [
+		{ channel: "gentle-pi:ask-user-question:blocked", data: { active: true } },
+		{ channel: "gentle-pi:ask-user-question:blocked", data: { active: false } },
+	]);
+});
+
+test("ask_user_question echoes an option preview through RPC dialogs", async (t) => {
+	withInteractiveHostEnv(t);
+	const { tool } = registerQuestionTool();
+	const questions = [
+		{ question: "Proceed?", header: "Proceed", options: [option("Alpha", "First choice", "Preview A"), option("Beta")] },
+	];
+	const { ctx } = rpcHostContext(["Alpha"]);
+
+	const result = await run(tool, { questions }, ctx);
+
+	assert.equal(result.content[0]?.text, "1. Proceed? — Alpha\n   selected preview: Preview A");
+	assert.deepEqual(result.details.answers, [
+		{ questionIndex: 0, question: "Proceed?", kind: "option", answer: "Alpha", preview: "Preview A" },
+	]);
+});
+
+test("ask_user_question loops select with a trailing Done entry for a multiSelect question on an interactive host", async (t) => {
+	withInteractiveHostEnv(t);
+	const { tool } = registerQuestionTool();
+	const questions = [
+		{ question: "Pick?", header: "Pick", options: [option("One"), option("Two")], multiSelect: true },
+	];
+	const { ctx, selectCalls } = rpcHostContext(["[ ] One", "Done"]);
+
+	const result = await run(tool, { questions }, ctx);
+
+	assert.deepEqual(selectCalls[0]?.options, ["[ ] One", "[ ] Two", "Done"]);
+	assert.deepEqual(selectCalls[1]?.options, ["[x] One", "[ ] Two", "Done"]);
+	assert.equal(result.content[0]?.text, "1. Pick? — selected: One");
+	assert.deepEqual(result.details.answers, [
+		{ questionIndex: 0, question: "Pick?", kind: "multi", answer: null, selected: ["One"] },
+	]);
+});
+
+test("ask_user_question multiSelect finishes once every option is toggled without needing Done", async (t) => {
+	withInteractiveHostEnv(t);
+	const { tool } = registerQuestionTool();
+	const questions = [
+		{ question: "Pick?", header: "Pick", options: [option("One"), option("Two")], multiSelect: true },
+	];
+	const { ctx, selectCalls } = rpcHostContext(["[ ] One", "[ ] Two"]);
+
+	const result = await run(tool, { questions }, ctx);
+
+	assert.equal(selectCalls.length, 2, "bounded by the safety cap, but finished early once fully toggled");
+	assert.deepEqual(result.details.answers, [
+		{ questionIndex: 0, question: "Pick?", kind: "multi", answer: null, selected: ["One", "Two"] },
+	]);
+});
+
+test("ask_user_question multiSelect toggle/untoggle/toggle sequence still selects correctly after Done", async (t) => {
+	withInteractiveHostEnv(t);
+	const { tool } = registerQuestionTool();
+	const questions = [
+		{ question: "Pick?", header: "Pick", options: [option("One"), option("Two")], multiSelect: true },
+	];
+	// Toggle One on, then off, then on again, then explicit Done: four rounds,
+	// one more than the old options.length + 1 = 3 round bound, so an
+	// un-toggle must never count against the loop's budget.
+	const { ctx, selectCalls } = rpcHostContext(["[ ] One", "[x] One", "[ ] One", "Done"]);
+
+	const result = await run(tool, { questions }, ctx);
+
+	assert.equal(selectCalls.length, 4);
+	assert.deepEqual(result.details.answers, [
+		{ questionIndex: 0, question: "Pick?", kind: "multi", answer: null, selected: ["One"] },
+	]);
+});
+
+test("ask_user_question multiSelect cancels once the safety cap is hit without Done", async (t) => {
+	withInteractiveHostEnv(t);
+	const { tool } = registerQuestionTool();
+	const questions = [
+		{ question: "Pick?", header: "Pick", options: [option("One"), option("Two")], multiSelect: true },
+	];
+	// Toggle only "One" back and forth forever: "Two" never toggles, so the
+	// loop never auto-finishes, and Done is never picked. It must hit the
+	// hard safety cap and refuse to commit whatever was toggled at that point.
+	const selectAnswers = Array.from({ length: 32 }, (_, round) => (round % 2 === 0 ? "[ ] One" : "[x] One"));
+	const { ctx, selectCalls } = rpcHostContext(selectAnswers);
+
+	const result = await run(tool, { questions }, ctx);
+
+	assert.equal(selectCalls.length, 32, "every round of the safety cap must be spent before giving up");
+	assert.equal(result.content[0]?.text, "User cancelled the questionnaire");
+	assert.deepEqual(result.details, { cancelled: true });
+});
+
+test("askMultiSelect scales its round cap so a 40-option question can toggle every option and still reach Done", async () => {
+	// The shipped `ask_user_question` tool schema caps authored options at 4
+	// (`lib/questionnaire/schema.ts`'s `MAX_OPTIONS`), so this exercises
+	// `askMultiSelect` directly rather than through the schema-validated tool,
+	// the same way a future caller with more options would.
+	const labels = Array.from({ length: 40 }, (_, index) => `Option ${index + 1}`);
+	const question = { question: "Pick?", header: "Pick", options: labels.map((label) => option(label)), multiSelect: true };
+	// Toggle the first 39 options on, one per round, then an explicit Done:
+	// 40 rounds total, past the old flat 32-round cap but inside the new
+	// `Math.max(32, options.length + 2)` = 42 bound.
+	const toggleAnswers = labels.slice(0, 39).map((label) => `[ ] ${label}`);
+	const { ctx, selectCalls } = rpcHostContext([...toggleAnswers, "Done"]);
+
+	const answer = await askMultiSelect(ctx as never, question as never);
+
+	assert.equal(selectCalls.length, 40, "every toggle plus the explicit Done fits inside the scaled cap");
+	assert.deepEqual(answer, { questionIndex: -1, question: "Pick?", kind: "multi", answer: null, selected: labels.slice(0, 39) });
+});
+
+test("ask_user_question multiSelect cancels on an unrecognised host answer instead of committing a partial state", async (t) => {
+	withInteractiveHostEnv(t);
+	const { tool } = registerQuestionTool();
+	const questions = [
+		{ question: "Pick?", header: "Pick", options: [option("One"), option("Two")], multiSelect: true },
+	];
+	// "One" gets toggled on first, then the host answers with something that
+	// matches none of the current round's options: the loop must cancel the
+	// whole questionnaire, never commit the partial "One" toggle.
+	const { ctx, selectCalls } = rpcHostContext(["[ ] One", "not a real option"]);
+
+	const result = await run(tool, { questions }, ctx);
+
+	assert.equal(selectCalls.length, 2);
+	assert.equal(result.content[0]?.text, "User cancelled the questionnaire");
+	assert.deepEqual(result.details, { cancelled: true });
+});
+
+test("ask_user_question cancels through RPC dialogs like the TUI path when select returns undefined", async (t) => {
+	withInteractiveHostEnv(t);
+	const { tool, emitted } = registerQuestionTool();
+	const { ctx } = rpcHostContext([undefined]);
+
+	const result = await run(tool, { questions: single() }, ctx);
+
+	assert.equal(result.content[0]?.text, "User cancelled the questionnaire");
+	assert.deepEqual(result.details, { cancelled: true });
+	assert.deepEqual(emitted, [
+		{ channel: "gentle-pi:ask-user-question:blocked", data: { active: true } },
+		{ channel: "gentle-pi:ask-user-question:blocked", data: { active: false } },
+	]);
+});
+
+test("ask_user_question cancels a questionnaire through RPC dialogs on a later question", async (t) => {
+	withInteractiveHostEnv(t);
+	const { tool } = registerQuestionTool();
+	const questions = [
+		{ question: "First?", header: "First", options: [option("Alpha"), option("Beta")] },
+		{ question: "Second?", header: "Second", options: [option("Gamma"), option("Delta")] },
+	];
+	const { ctx, selectCalls } = rpcHostContext(["Alpha", undefined]);
+
+	const result = await run(tool, { questions }, ctx);
+
+	assert.equal(selectCalls.length, 2, "the first question is answered before the cancel is observed");
+	assert.deepEqual(result.details, { cancelled: true });
+});
+
 test("ask_user_question commits a single-select answer end-to-end", async () => {
 	const { tool, emitted } = registerQuestionTool();
 	const rendered = { value: "" };

package/tests/gentle-agents.test.ts

@@ -379,6 +379,142 @@ for (const mode of ["print", "tui", "rpc"] as const) {
 	});
 }
 
+/** Controllable fake for `AgentsDeps.schedule`: records every scheduled callback instead of running it, so a test can fire the RPC publisher's coalescing window deterministically. */
+function fakeScheduler() {
+	const pending: Array<{ id: number; fn: () => void }> = [];
+	let nextId = 0;
+	return {
+		schedule: (fn: () => void, _ms: number) => {
+			const id = nextId++;
+			pending.push({ id, fn });
+			return () => {
+				const index = pending.findIndex((entry) => entry.id === id);
+				if (index !== -1) pending.splice(index, 1);
+			};
+		},
+		flushAll: () => {
+			const due = pending.splice(0, pending.length);
+			for (const entry of due) entry.fn();
+		},
+	};
+}
+
+for (const scenario of [
+	{ label: "an interactive RPC host", mode: "rpc", env: { PATH: "/bin", GENTLE_SHELL_INTERACTIVE_HOST: "1" }, expectPublish: true },
+	{ label: "plain RPC without the interactive-host variable", mode: "rpc", env: { PATH: "/bin" }, expectPublish: false },
+	{ label: "TUI", mode: "tui", env: { PATH: "/bin" }, expectPublish: false },
+] as const) {
+	test(`gentle-agents publishes the live activity payload through setWidget only on ${scenario.label}`, async (t) => {
+		const h = fakePi();
+		const runtime = deps();
+		const scheduler = fakeScheduler();
+		runtime.deps.schedule = scheduler.schedule;
+		runtime.deps.env = scenario.env;
+		gentleAgents(h.pi, {}, runtime.deps);
+		const { ctx } = fakeContext();
+		Object.assign(ctx, { mode: scenario.mode, hasUI: scenario.mode === "tui" || scenario.mode === "rpc" });
+		const setWidget = t.mock.method(ctx.ui, "setWidget");
+
+		await h.fire("session_start", ctx);
+		scheduler.flushAll(); // consume the publisher's own start-time frame, if any
+		setWidget.mock.resetCalls();
+
+		await h.tools.get("subagent_run")!.execute("control", { agent: "explore", task: "Map", mode: "background" }, undefined, undefined, ctx);
+		scheduler.flushAll();
+
+		// The TUI card's own setWidget call always carries a component-factory
+		// function, never an array; only the RPC publisher pushes an array.
+		const activityCalls = setWidget.mock.calls.filter((call) => call.arguments[0] === "gentle-agents" && Array.isArray(call.arguments[1]));
+		if (!scenario.expectPublish) {
+			assert.deepEqual(activityCalls, [], "no array-shaped setWidget push outside an interactive RPC host");
+			return;
+		}
+		assert.equal(activityCalls.length, 1, "one push per coalescing window");
+		// The fake `ui.setWidget` types `content` as the TUI-only component factory;
+		// the RPC publisher instead calls it with a plain `string[]` (real pi's
+		// RPC-mode contract), which needs an unknown-mediated cast here.
+		const [key, lines] = activityCalls[0]!.arguments as unknown as [string, string[]];
+		assert.equal(key, "gentle-agents");
+		assert.equal(lines.length, 1);
+		const activity = JSON.parse(lines[0]!) as { schema: string; tasks: Array<{ summary: { id: string } }> };
+		assert.equal(activity.schema, "gentle-agents.activity/v1");
+		assert.ok(activity.tasks.some((task) => typeof task.summary.id === "string" && task.summary.id.length > 0), "the newly launched task must be in the payload");
+	});
+}
+
+test("gentle-agents notifies once, deduplicated, when the RPC activity publisher's setWidget throws", async (t) => {
+	const h = fakePi();
+	const runtime = deps();
+	const scheduler = fakeScheduler();
+	runtime.deps.schedule = scheduler.schedule;
+	runtime.deps.env = { PATH: "/bin", GENTLE_SHELL_INTERACTIVE_HOST: "1" };
+	gentleAgents(h.pi, {}, runtime.deps);
+	const { ctx } = fakeContext();
+	Object.assign(ctx, { mode: "rpc", hasUI: true });
+	const notify = t.mock.method(ctx.ui, "notify");
+	// Only the publisher's array-shaped push fails; the TUI card's own
+	// component-factory push (`showWidget`) must stay untouched.
+	ctx.ui.setWidget = ((_key: string, content: unknown) => {
+		if (Array.isArray(content)) throw new Error("boom");
+	}) as typeof ctx.ui.setWidget;
+
+	await h.fire("session_start", ctx);
+	scheduler.flushAll(); // the publisher's own start-time frame fails: one notify
+
+	await h.tools.get("subagent_run")!.execute("control", { agent: "explore", task: "Map", mode: "background" }, undefined, undefined, ctx);
+	scheduler.flushAll(); // a second flush with the same recurring failure must not notify again
+
+	assert.equal(notify.mock.callCount(), 1, "the same recurring setWidget failure is deduplicated to one notify per session");
+	assert.match(String(notify.mock.calls[0]?.arguments[0]), /boom/);
+	assert.equal(notify.mock.calls[0]?.arguments[1], "warning");
+});
+
+// Regression for the desktop app's Helpers tab showing helpers from every
+// session: a resumed session's own finished tasks restore from disk into
+// the shared `TaskStore` (see "resuming a session restores its own
+// finished tasks as history, never another session's" above for the
+// overlay-render side of this), and the RPC activity publisher created on
+// `session_start` must scope its `setWidget` payload to the same session,
+// never surfacing another session's restored task.
+test("gentle-agents' RPC activity payload excludes a restored task from another session", async (t) => {
+	const h = fakePi();
+	const runtime = deps();
+	const scheduler = fakeScheduler();
+	runtime.deps.schedule = scheduler.schedule;
+	runtime.deps.env = { PATH: "/bin", GENTLE_SHELL_INTERACTIVE_HOST: "1" };
+	const historyHome = join(root, "rpc-restore-history-home");
+	const own: TaskRecord = { id: "own-1", agent: "explore-a", mode: "background", prompt: "p", label: "p", cwd, parentSessionId: "resumed-session", status: TASK_STATUS.COMPLETED, createdAt: 1, startedAt: 1, endedAt: 100, model: "m", thinking: undefined, sessionPath: null, error: null, result: "done", lastStep: "responded", lastActivityAt: 100, turns: 1, toolCalls: 0, tokens: 0, cost: 0 };
+	const other: TaskRecord = { ...own, id: "not-mine", agent: "explore-other", parentSessionId: "other-session" };
+	await saveTask(historyDir(historyHome), own, emptyThread());
+	await saveTask(historyDir(historyHome), other, emptyThread());
+	runtime.deps.home = historyHome;
+	gentleAgents(h.pi, {}, runtime.deps);
+	const { ctx } = fakeContext();
+	Object.assign(ctx, { mode: "rpc", hasUI: true });
+	ctx.sessionManager.getSessionId = () => "resumed-session";
+	const setWidget = t.mock.method(ctx.ui, "setWidget");
+
+	await h.fire("session_start", ctx, { reason: "resume" });
+
+	// The disk history read behind restoreSessionHistory is fire-and-forget
+	// real async I/O, unrelated to the fake coalescing scheduler; poll both
+	// until the resumed session's own restored task reaches a flushed frame.
+	let activity: { tasks: Array<{ summary: { id: string } }> } | undefined;
+	for (let attempt = 0; attempt < 40 && !activity; attempt += 1) {
+		await new Promise((resolve) => setTimeout(resolve, 25));
+		scheduler.flushAll();
+		const activityCalls = setWidget.mock.calls.filter((call) => call.arguments[0] === "gentle-agents" && Array.isArray(call.arguments[1]));
+		if (activityCalls.length === 0) continue;
+		const [, lines] = activityCalls.at(-1)!.arguments as unknown as [string, string[]];
+		const parsed = JSON.parse(lines[0]!) as { tasks: Array<{ summary: { id: string } }> };
+		if (parsed.tasks.some((entry) => entry.summary.id === "own-1")) activity = parsed;
+	}
+
+	assert.ok(activity, "the RPC activity payload must eventually include the resumed session's own restored task");
+	assert.ok(!activity!.tasks.some((entry) => entry.summary.id === "not-mine"), "another session's restored task must never appear in the RPC activity payload");
+	await h.fire("session_shutdown", ctx);
+});
+
 test("all nine subagent registrations own their transcript shell", () => {
 	const { pi, tools } = fakePi();
 	gentleAgents(pi, {}, deps().deps);