gentle-pi 3.5.0 → 3.5.1

package/runtime/gentle-shell-launcher.mjs

@@ -1,5 +1,5 @@
 // Generated by scripts/build-runtime-modules.mjs. Do not edit.
-import { join } from "node:path";
+import { join, resolve as resolvePath } from "node:path";
 
 // The gentle-shell launcher: pure, side-effect-free functions over injected
 // env/fs/exec. `bin/gentle-shell.mjs` (T2) wires these into the real process,
@@ -28,6 +28,7 @@ function isPiSubcommand(token        )                        {
 
 
 
+
 	                                                                  
 
 
@@ -44,6 +45,7 @@ export function parseLauncherArgs(argv          )                     {
 			link: false,
 			isolated: false,
 			home: undefined,
+			packageRoot: undefined,
 			help: false,
 			version: false,
 			command: "home",
@@ -57,6 +59,7 @@ export function parseLauncherArgs(argv          )                     {
 	let link = false;
 	let isolated = false;
 	let home                    ;
+	let packageRoot                    ;
 	let help = false;
 	let version = false;
 	let error                    ;
@@ -109,6 +112,26 @@ export function parseLauncherArgs(argv          )                     {
 			i += 1;
 			continue;
 		}
+		if (arg.startsWith("--package-root=")) {
+			const value = arg.slice("--package-root=".length);
+			if (value.length === 0) {
+				error = "--package-root requires a non-empty path argument";
+				continue;
+			}
+			packageRoot = value;
+			continue;
+		}
+		if (arg === "--package-root") {
+			const value = argv[i + 1];
+			if (value === undefined || value.length === 0) {
+				error = "--package-root requires a non-empty path argument";
+				if (value !== undefined) i += 1;
+				continue;
+			}
+			packageRoot = value;
+			i += 1;
+			continue;
+		}
 		if (passthrough.length === 0 && isPiSubcommand(arg)) {
 			piSubcommand = arg;
 		}
@@ -125,7 +148,7 @@ export function parseLauncherArgs(argv          )                     {
 		}
 	}
 
-	return { link, isolated, home, help, version, command: undefined, commandArgs: [], passthrough, piSubcommand, error };
+	return { link, isolated, home, packageRoot, help, version, command: undefined, commandArgs: [], passthrough, piSubcommand, error };
 }
 
 // --- home resolution -------------------------------------------------------
@@ -308,29 +331,325 @@ export function checkPeerVersionPin(packageJson                      , peerName
 	return { ok: true, pinned };
 }
 
-// --- settings.json detection ---------------------------------------------------
+// --- settings.json package declaration detection --------------------------
 
-function packageEntryDeclaresGentlePi(entry         )          {
-	const declares = (value         )          => typeof value === "string" && (value === "npm:gentle-pi" || value.startsWith("npm:gentle-pi@"));
-	if (declares(entry)) return true;
-	if (entry !== null && typeof entry === "object") return declares((entry                           ).source);
-	return false;
+// Matches the raw git URL forms pi accepts without a `git:` prefix.
+const GIT_URL_PATTERN = /^(?:https?|ssh|git):\/\//;
+
+function entrySource(entry         )                     {
+	if (typeof entry === "string") return entry;
+	if (entry !== null && typeof entry === "object") {
+		const source = (entry                           ).source;
+		if (typeof source === "string") return source;
+	}
+	return undefined;
 }
 
-export function settingsDeclareGentlePi(settingsText                    )          {
-	if (settingsText === undefined) return false;
+
+
+// A settings `packages` entry is npm- or git-sourced only via an explicit
+// `npm:`/`git:` prefix or a bare git URL; every other source (relative or
+// absolute) is a local path, per pi's own package-source rules.
+export function packageSourceKind(source        )                    {
+	if (source.startsWith("npm:")) return "npm";
+	if (source.startsWith("git:")) return "git";
+	if (GIT_URL_PATTERN.test(source)) return "git";
+	return "path";
+}
+
+function npmSourceDeclaresGentlePi(source        )          {
+	return source === "npm:gentle-pi" || source.startsWith("npm:gentle-pi@");
+}
+
+// npm:<name> or npm:<name>@<version>, tolerating a scoped `@scope/name`: only
+// the first `@` *after* the leading scope marker starts a version suffix.
+function npmPackageName(source        )         {
+	const spec = source.slice("npm:".length);
+	if (spec.startsWith("@")) {
+		const versionAt = spec.indexOf("@", 1);
+		return versionAt === -1 ? spec : spec.slice(0, versionAt);
+	}
+	const versionAt = spec.indexOf("@");
+	return versionAt === -1 ? spec : spec.slice(0, versionAt);
+}
+
+function parseSettingsPackages(settingsText                    )                        {
+	if (settingsText === undefined) return undefined;
 	let parsed         ;
 	try {
 		parsed = JSON.parse(settingsText);
 	} catch {
-		return false;
+		return undefined;
 	}
-	if (typeof parsed !== "object" || parsed === null) return false;
+	if (typeof parsed !== "object" || parsed === null) return undefined;
 	const packages = (parsed                           ).packages;
-	if (!Array.isArray(packages)) return false;
+	return Array.isArray(packages) ? packages : undefined;
+}
+
+function packageEntryDeclaresGentlePi(entry         )          {
+	const source = entrySource(entry);
+	return source !== undefined && packageSourceKind(source) === "npm" && npmSourceDeclaresGentlePi(source);
+}
+
+// Deprecated: recognises only an `npm:gentle-pi` declaration. Kept as a thin
+// compatibility wrapper over the pre-existing behaviour for any caller that
+// only cares about the npm case; findGentlePiDeclaration below also detects
+// a path package whose own package.json names it "gentle-pi".
+export function settingsDeclareGentlePi(settingsText                    )          {
+	const packages = parseSettingsPackages(settingsText);
+	if (packages === undefined) return false;
 	return packages.some(packageEntryDeclaresGentlePi);
 }
 
+
+
+
+
+
+
+
+
+
+// Detects a settings.json `packages` entry that already loads gentle-pi,
+// either as `npm:gentle-pi[@version]` or as a local path (string or object
+// `source`) whose own package.json declares `"name": "gentle-pi"`. Path
+// entries are resolved relative to `opts.agentDir`, matching how pi itself
+// resolves a settings-relative local path.
+export function findGentlePiDeclaration(settingsText                    , opts                                )                                  {
+	const packages = parseSettingsPackages(settingsText);
+	if (packages === undefined) return undefined;
+
+	for (const entry of packages) {
+		const source = entrySource(entry);
+		if (source === undefined) continue;
+		const kind = packageSourceKind(source);
+		if (kind === "npm" && npmSourceDeclaresGentlePi(source)) return { kind: "npm" };
+		if (kind === "path") {
+			const dir = resolvePath(opts.agentDir, source);
+			if (opts.readPackageName(dir) === "gentle-pi") return { kind: "path", dir };
+		}
+	}
+	return undefined;
+}
+
+// --- take-over decision ---------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export function decideTakeOver(input                     )          {
+	if (input.packageRootExplicit) return true;
+	if (input.declaration === undefined) return false;
+	if (input.declaration.kind === "npm") return false;
+	const realDeclaredDir = input.realDeclaredDir ?? input.declaration.dir;
+	return realDeclaredDir !== input.realPackageRoot;
+}
+
+// --- other-package injection planning --------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+function entryFilterKeys(entry         )           {
+	if (entry === null || typeof entry !== "object") return [];
+	const record = entry                           ;
+	const keys           = [];
+	if ("extensions" in record) keys.push("extensions");
+	if ("autoload" in record) keys.push("autoload");
+	return keys;
+}
+
+// Plans the `-e <dir>` flags a take-over must add for every OTHER settings
+// package once `--no-extensions` drops normal settings-driven extension
+// discovery. git-sourced packages are skipped (their install directory is
+// not derivable without pi's own package manager) with a warning; object
+// entries carrying `extensions`/`autoload` filters are still included, with
+// a warning that the take-over cannot honour those filters (their skills,
+// prompts, and themes still load through ordinary settings discovery, which
+// --no-extensions does not affect).
+export function otherPackageInjections(input                             )                         {
+	const paths           = [];
+	const warnings           = [];
+	const packages = parseSettingsPackages(input.settingsText);
+	if (packages === undefined) return { paths, warnings };
+	const isDirectory = input.isDirectory ?? (() => true);
+	const realpath = input.realpath ?? ((dir        ) => dir);
+
+	for (const entry of packages) {
+		const source = entrySource(entry);
+		if (source === undefined) continue;
+		const kind = packageSourceKind(source);
+
+		// Skip every gentle-pi entry unconditionally, not only the one
+		// matching `skip`'s kind: settings can carry more than one gentle-pi
+		// declaration (for example an npm:gentle-pi entry alongside the path
+		// declaration actually being taken over), and re-injecting any of
+		// them as an "other package" would double-load gentle-pi extensions.
+		if (kind === "npm" && npmSourceDeclaresGentlePi(source)) continue;
+		if (kind === "path") {
+			const dir = resolvePath(input.agentDir, source);
+			// Compared through realpath on BOTH sides (not the raw resolved
+			// strings): skip.dir may already be a realpath itself
+			// (bin/gentle-shell.mjs's --package-root take-over) or may not be
+			// (a plain settings.json declaration), so only comparing one side
+			// through realpath would break whichever case does not match that
+			// assumption. Realpath'ing both keeps the exact-match case
+			// (skip.dir derived from the very same source) trivially correct
+			// while also recognising a settings entry that reaches the same
+			// physical directory as skip through a symlink.
+			if (input.skip.kind === "path" && realpath(dir) === realpath(input.skip.dir)) continue;
+		}
+
+		if (kind === "git") {
+			warnings.push(
+				`gentle-shell: skipping git-sourced package "${source}" during takeover (its install directory is not derivable without pi's own package manager).`,
+			);
+			continue;
+		}
+
+		const filters = entryFilterKeys(entry);
+		if (filters.length > 0) {
+			warnings.push(
+				`gentle-shell: package "${source}" has ${filters.join("/")} filters that this takeover cannot honour for extensions; its skills, prompts, and themes still load through settings discovery.`,
+			);
+		}
+
+		const dir = kind === "npm" ? join(input.agentDir, "npm", "node_modules", npmPackageName(source)) : resolvePath(input.agentDir, source);
+		if (!isDirectory(dir)) {
+			warnings.push(`gentle-shell: skipping declared package "${source}": ${dir} is not a directory`);
+			continue;
+		}
+		paths.push(dir);
+	}
+	return { paths, warnings };
+}
+
+// --- loose extension discovery ----------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// scripts/build-runtime-modules.mjs rewrites every occurrence of a dot, the
+// letters ts, and an immediately following closing quote (single or double)
+// to end in mjs instead, when it generates runtime/gentle-shell-launcher.mjs
+// — a plain `.replace(/\.ts(["'])/g, ...)` that cannot tell an import
+// specifier from an ordinary string literal. Any other string ending the
+// same way — a dot, the letters ts, and a closing quote right after — would
+// get silently corrupted into the mjs form in the generated runtime module,
+// so the three constants below are built by concatenation instead of
+// written as literals that would trigger the same rewrite.
+const TS_EXTENSION = `.t${"s"}`;
+const INDEX_TS_FILENAME = `index${TS_EXTENSION}`;
+const DECLARATION_FILE_SUFFIX = `.d${TS_EXTENSION}`;
+const LOOSE_EXTENSION_FILE_PATTERN = /\.(?:ts|js|mjs)$/;
+
+function isLooseExtensionFile(name        )          {
+	if (name.startsWith(".")) return false;
+	if (name.endsWith(DECLARATION_FILE_SUFFIX)) return false;
+	return LOOSE_EXTENSION_FILE_PATTERN.test(name);
+}
+
+// Mirrors pi's own discoverExtensionsInDir (packages/coding-agent/src/core/
+// extensions/loader.ts): direct *.ts/*.js/*.mjs files, plus <subdir>/index.ts
+// (falling back to <subdir>/index.js) for a child directory that has one. No
+// recursion beyond that one level, matching pi's own rule that a more complex
+// nested package must use a package.json manifest instead.
+//
+// Unlike pi's own scan, hidden entries (dotfiles, and hidden subdirectories)
+// and *.d.ts files are deliberately excluded here: pi's `-e <file>` flag hands
+// the path straight to its module loader with no directory-discovery pass of
+// its own (see buildPiInvocation's takeOver branch), so a hidden file or a
+// type-only declaration file was never a runnable extension and would only
+// surface a confusing "Cannot find module"/empty-module error once injected.
+//
+// Returns already-resolved absolute file paths, sorted by name so the result
+// (and therefore -e ordering) does not depend on the host filesystem's
+// unspecified readdir order.
+export function discoverLooseExtensionEntries(dir        , fs                  )           {
+	let entries                         ;
+	try {
+		entries = fs.readdir(dir);
+	} catch {
+		return [];
+	}
+
+	const sorted = [...entries].sort((a, b) => a.name.localeCompare(b.name));
+	const discovered           = [];
+
+	for (const entry of sorted) {
+		if (entry.name.startsWith(".")) continue;
+
+		if (entry.isFile) {
+			if (isLooseExtensionFile(entry.name)) discovered.push(join(dir, entry.name));
+			continue;
+		}
+
+		if (!entry.isDirectory) continue;
+		const childDir = join(dir, entry.name);
+		const indexTs = join(childDir, INDEX_TS_FILENAME);
+		const indexJs = join(childDir, "index.js");
+		if (fs.exists(indexTs)) discovered.push(indexTs);
+		else if (fs.exists(indexJs)) discovered.push(indexJs);
+	}
+
+	return discovered;
+}
+
 // --- pi invocation builder ---------------------------------------------------
 
 
@@ -349,35 +668,99 @@ export function settingsDeclareGentlePi(settingsText                    )
 
 
 
+	                                         
+
+
+	                                      
+	                                    
+
 
 
 
 
-// The `-e/--theme/--skill/--prompt-template` injection is skipped when the
-// caller already confirmed the target settings.json declares the package
-// (the `--link` case with a pi-managed install), or when passthrough[0] is
-// one of pi's own subcommands: pi dispatches install/remove/uninstall/
-// update/list/config/auth on argv[0] before it even parses flags, so any
-// injected flag ahead of it stops pi from recognising its subcommand at
-// all — this is exactly the observed 2026-09-22 bug where `gentle-shell
-// install npm:x` opened an interactive pi session instead of running the
-// package manager. Isolated and path homes never declare the package, so
-// callers pass `settingsDeclareGentlePi: false` for those and the
-// injection always happens there, unless a pi subcommand is set.
+
+
+
+
+
+
+
+
+
+
+
+
+
+function packageRootAssetArgs(packageRoot        )           {
+	return ["--theme", join(packageRoot, "themes"), "--skill", join(packageRoot, "skills"), "--prompt-template", join(packageRoot, "prompts")];
+}
+
+function packageRootInjectionArgs(packageRoot        )           {
+	return ["-e", packageRoot, ...packageRootAssetArgs(packageRoot)];
+}
+
+// Four cases, checked in this order — `piSubcommand` first, then `takeOver`:
+//   - piSubcommand: pi dispatches install/remove/uninstall/update/list/
+//     config/auth on argv[0] before it even parses flags, so any injected
+//     -e/--theme/--skill/--prompt-template flag ahead of it stops pi from
+//     recognising its subcommand at all — this is exactly the observed
+//     2026-09-22 bug where `gentle-shell install npm:x` opened an
+//     interactive pi session instead of running the package manager. No
+//     injection of any kind (including a take-over's --no-extensions and
+//     other-package/loose-extension -e flags) may precede it.
+//   - takeOver: the target settings declare a *different* gentle-pi, or
+//     --package-root forced a takeover regardless of any declaration. This
+//     must win over the next two cases even when there is no declaration to
+//     report, or the plain branch would silently drop --no-extensions and
+//     the other-package injections while bin/gentle-shell.mjs still prints
+//     the "taking over" message. `--no-extensions` drops normal
+//     settings-driven extension discovery, so it is replaced by an explicit
+//     `-e <dir>` for every OTHER settings package (skills/prompts/themes
+//     for those packages still load through ordinary settings discovery,
+//     which --no-extensions does not affect), then an explicit `-e <file>`
+//     for every loose extension entry normal discovery would otherwise have
+//     found under <agentDir>/extensions and the project-local
+//     .pi/extensions, and finally this launcher's own packageRoot injected
+//     last so it wins any conflict. Every -e path is injected at most once
+//     (R3-001): a loose entry that duplicates an other-package path, or
+//     repeats within looseExtensionEntries itself, is skipped rather than
+//     loaded twice.
+//   - Not takeOver, no declaration: inject this launcher's own packageRoot,
+//     exactly as when nothing else in settings loads gentle-pi.
+//   - Not takeOver, with a declaration: no injection at all — the target
+//     settings already load a gentle-pi the launcher accepts as-is (the
+//     `--link` case with a pi-managed install matching this launcher).
 export function buildPiInvocation(input                        )               {
 	const args = [...input.runtime.args];
-	if (input.piSubcommand === undefined && !input.settingsDeclareGentlePi) {
-		args.push(
-			"-e",
-			input.packageRoot,
-			"--theme",
-			join(input.packageRoot, "themes"),
-			"--skill",
-			join(input.packageRoot, "skills"),
-			"--prompt-template",
-			join(input.packageRoot, "prompts"),
-		);
+
+	if (input.piSubcommand !== undefined) {
+		// No injection at all: pi must see the bare subcommand as argv[0].
+	} else if (input.takeOver) {
+		args.push("--no-extensions");
+		const injected = new Set        ();
+		for (const otherPath of input.otherPackagePaths) {
+			if (injected.has(otherPath)) continue;
+			injected.add(otherPath);
+			args.push("-e", otherPath);
+		}
+		for (const entry of input.looseExtensionEntries ?? []) {
+			if (injected.has(entry)) continue;
+			injected.add(entry);
+			args.push("-e", entry);
+		}
+		// R3-003: the launcher's own package root must also be checked
+		// against the dedupe set instead of being appended unconditionally,
+		// or a settings package/loose entry that resolves to the same
+		// directory as --package-root would be injected twice.
+		if (!injected.has(input.packageRoot)) {
+			injected.add(input.packageRoot);
+			args.push("-e", input.packageRoot);
+		}
+		args.push(...packageRootAssetArgs(input.packageRoot));
+	} else if (input.declaration === undefined) {
+		args.push(...packageRootInjectionArgs(input.packageRoot));
 	}
+
 	args.push(...input.passthrough);
 
 	return {
@@ -455,6 +838,8 @@ export function helpText()         {
 		"  --link           Use your existing pi agent home (never edits its settings.json).",
 		"  --isolated       Use the dedicated ~/.gentle-shell/agent home (default).",
 		"  --home <path>    Use a custom agent home directory.",
+		"  --package-root <dir>  Force this directory as the gentle-pi package to load, taking over",
+		"                        from any conflicting package the target settings.json already declares.",
 		"  --help, -h       Show this help text.",
 		"  --version        Show gentle-shell, pi, and home version information.",
 		"",

package/tests/agents-rpc-publisher.test.ts

@@ -185,6 +185,41 @@ test("projectRpcActivity honors a custom maxThreadItems override", () => {
 	assert.deepEqual((activity.tasks[0]!.thread.items as { text: string }[]).map((item) => item.text), ["n3", "n4"]);
 });
 
+// Regression for the desktop app's Helpers tab showing helpers from every
+// session: `TaskStore` restores finished tasks of every session from disk at
+// startup, so an RPC push scoped to `opts.parentSessionId` must project only
+// the current session's tasks, and its `summary` counts must match.
+test("projectRpcActivity with parentSessionId keeps only that session's tasks and computes the summary from them", () => {
+	const store = new TaskStore();
+	store.add(task("mine-running", "s1", { status: TASK_STATUS.RUNNING }));
+	store.add(task("mine-finished", "s1", { status: TASK_STATUS.COMPLETED, endedAt: 100 }));
+	store.add(task("other-running", "s2", { status: TASK_STATUS.RUNNING }));
+	store.add(task("other-finished", "s2", { status: TASK_STATUS.COMPLETED, endedAt: 200 }));
+
+	const activity = projectRpcActivity(store, { parentSessionId: "s1" });
+
+	assert.deepEqual(
+		activity.tasks.map((entry) => entry.summary.id).sort(),
+		["mine-finished", "mine-running"],
+		"only the requested session's tasks are projected",
+	);
+	assert.deepEqual(activity.summary, store.summary("s1"), "summary counts are scoped to the same session filter, not the whole store");
+	assert.notDeepEqual(activity.summary, store.summary(), "an unfiltered summary would have counted the other session's tasks too");
+});
+
+// Tasks restored on demand (e.g. opening an older task from another session
+// in the overlay) can land in the shared store without ever being live in
+// the current session; the RPC projection must still exclude them by id.
+test("projectRpcActivity with parentSessionId excludes a task from another session even when it is the only one in the store", () => {
+	const store = new TaskStore();
+	store.add(task("not-mine", "other-session"));
+
+	const activity = projectRpcActivity(store, { parentSessionId: "current-session" });
+
+	assert.deepEqual(activity.tasks, []);
+	assert.deepEqual(activity.summary, { running: 0, queued: 0, waiting: 0, finished: 0 });
+});
+
 test("encodeActivityLines returns the activity untouched as a single line when it already fits", () => {
 	const activity: RpcActivity = { schema: ACTIVITY_SCHEMA, summary: { running: 0, queued: 0, waiting: 0, finished: 0 }, tasks: [] };
 
@@ -366,6 +401,37 @@ test("createRpcActivityPublisher stop unsubscribes everything and publishes exac
 	assert.equal(calls.length, 1, "no further frame is published after stop");
 });
 
+// `parentSessionId` is a value captured at construction, not a live getter.
+// Honoring a mid-process session switch (a resumed/new/forked session) is
+// the caller's job: stop the old publisher and construct a new one scoped
+// to the new session id, exactly as `extensions/gentle-agents.ts` does on
+// every `session_start`. This locks in that only the newly scoped publisher
+// ever sees the other session's tasks.
+test("createRpcActivityPublisher recreated with a new parentSessionId after a session switch publishes only the new session's tasks", () => {
+	const store = new TaskStore();
+	store.add(task("session-a-task", "session-a"));
+	const scheduler = fakeScheduler();
+	const calls: string[][] = [];
+	const ui = { setWidget: (_key: string, lines: string[]) => calls.push(lines) };
+
+	const first = createRpcActivityPublisher({ store, ui, schedule: scheduler.schedule, parentSessionId: "session-a" });
+	first.start();
+	scheduler.flushAll();
+	const firstActivity = JSON.parse(calls.at(-1)![0]!) as RpcActivity;
+	assert.deepEqual(firstActivity.tasks.map((entry) => entry.summary.id), ["session-a-task"]);
+
+	first.stop();
+	calls.length = 0;
+	store.add(task("session-b-task", "session-b"));
+
+	const second = createRpcActivityPublisher({ store, ui, schedule: scheduler.schedule, parentSessionId: "session-b" });
+	second.start();
+	scheduler.flushAll();
+
+	const secondActivity = JSON.parse(calls.at(-1)![0]!) as RpcActivity;
+	assert.deepEqual(secondActivity.tasks.map((entry) => entry.summary.id), ["session-b-task"], "the publisher scoped to the new session must never carry the old session's task");
+});
+
 test("createRpcActivityPublisher flush publishes immediately and cancels a pending coalescing timer", () => {
 	const store = new TaskStore();
 	store.add(task("t1", "s1"));

package/tests/gentle-agents.test.ts

@@ -469,6 +469,52 @@ test("gentle-agents notifies once, deduplicated, when the RPC activity publisher
 	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);