gentle-pi 3.7.0 → 4.1.0

package/tests/bounded-writer-admission.test.ts

@@ -0,0 +1,146 @@
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, realpathSync, renameSync, rmSync, symlinkSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { __testing } from "../extensions/gentle-ai.ts";
+import { allowedEditSurfaces, inheritAllowedEditSurfaces, isBoundedWriter, bindSessionRepositoryPreparation, boundSessionRepositoryAuthorityCurrent, captureBoundSessionRepositoryAuthority, isDevelopmentSurface, prepareBoundSessionRepository, safeBootstrapDirectory, sessionRepositoryAuthority } from "../lib/bounded-writer-admission.ts";
+import type { NativeReviewCli } from "../lib/native-review-cli.ts";
+
+test("development admission excludes sensitive, config and bookkeeping surfaces structurally", () => {
+	for (const path of ["README.md", "odd/tasks/feature.md", ".pi/settings.json", "docs/app.ts", ".ssh/app.ts", ".aws/app.ts", ".gnupg/app.ts", "credentials/app.ts", "tokens/app.ts", "secrets/app.ts", "vite.config.ts", ".env", "private.key"]) assert.equal(isDevelopmentSurface(path), false, path);
+	for (const path of ["src/app.ts", "lib/core.go", "tests/feature.test.ts", "src/**/*"]) assert.equal(isDevelopmentSurface(path), true, path);
+});
+
+test("authority capture is synchronous and retains root/common-dir across misses", () => {
+	let identity: { root: string; commonDir: string } | undefined = { root: "/fixture", commonDir: "/fixture/git" };
+	const current = sessionRepositoryAuthority("/fixture", () => identity);
+	identity = undefined;
+	assert.equal(current(), false);
+	identity = { root: "/fixture", commonDir: "/other/git" };
+	assert.equal(current(), false);
+	identity = { root: "/other", commonDir: "/fixture/git" };
+	assert.equal(current(), false);
+});
+
+test("captured authority cannot fall back to missing or a replacement incarnation", () => {
+	const cwd = realpathSync(tmpdir());
+	const manager = { getSessionId: () => "same-id", getCwd: () => cwd };
+	const neverBound = captureBoundSessionRepositoryAuthority(manager, cwd);
+	assert.equal(neverBound(), true, "never-bound compatibility callers remain permitted");
+	const unbind = bindSessionRepositoryPreparation(manager, cwd, async () => true, () => true);
+	assert.equal(neverBound(), false, "capture cannot silently adopt a subsequently minted binding");
+	const captured = captureBoundSessionRepositoryAuthority(manager, cwd);
+	assert.equal(captured(), true);
+	unbind();
+	assert.equal(captured(), false, "revoked binding never becomes permissive absence");
+	assert.equal(boundSessionRepositoryAuthorityCurrent(manager, cwd), false, "new calls from revoked owners are also rejected");
+	const replacement = bindSessionRepositoryPreparation(manager, cwd, async () => true, () => true);
+	assert.equal(captured(), false, "same manager and ID cannot substitute another incarnation");
+	const fresh = captureBoundSessionRepositoryAuthority(manager, cwd);
+	assert.equal(fresh(), true);
+	manager.getSessionId = () => "changed-id";
+	assert.equal(fresh(), false);
+	replacement();
+});
+
+for (const race of ["loss", "replacement", "cancellation"] as const) {
+	test(`pending preparation revalidates established authority and owner before STATUS: ${race}`, async t => {
+		const cwd = realpathSync(mkdtempSync(join(tmpdir(), "bootstrap-authority-race-")));
+		t.after(() => rmSync(cwd, { recursive: true, force: true }));
+		const manager = { getSessionId: () => "fixture", getCwd: () => cwd };
+		let release!: () => void;
+		const gate = new Promise<void>(resolve => { release = resolve; });
+		let calls = 0;
+		const abort = new AbortController();
+		const unbind = bindSessionRepositoryPreparation(manager, cwd, async (_root, current) => {
+			execFileSync("git", ["init", "--quiet", cwd]);
+			assert.equal(current(), true, "first authorized bootstrap establishes retained identity");
+			await gate;
+			if (!current()) return false;
+			calls++;
+			return true;
+		}, () => true);
+		const pending = prepareBoundSessionRepository(manager, cwd, abort.signal);
+		let successor: (() => void) | undefined;
+		if (race === "loss") renameSync(join(cwd, ".git"), join(cwd, "saved-git"));
+		if (race === "replacement") successor = bindSessionRepositoryPreparation(manager, cwd, async () => true, () => true);
+		if (race === "cancellation") abort.abort();
+		release();
+		assert.equal(await pending, false);
+		assert.equal(calls, 0, "no STATUS after authority/owner/cancellation drift during await");
+		unbind(); successor?.();
+	});
+}
+
+// Never invoke native code against the real HOME or filesystem root.
+test("explicit review protects canonical HOME aliases, filesystem root and sensitive directories", async t => {
+	const root = realpathSync(mkdtempSync(join(tmpdir(), "bootstrap-safety-")));
+	const home = join(root, "home");
+	const alias = join(root, "home-alias");
+	mkdirSync(home);
+	mkdirSync(join(home, ".ssh"));
+	symlinkSync(home, alias);
+	const previous = process.env.HOME;
+	process.env.HOME = home;
+	t.after(() => { if (previous === undefined) delete process.env.HOME; else process.env.HOME = previous; rmSync(root, { recursive: true, force: true }); });
+	let calls = 0;
+	const native = { reviewMode: async () => ({ operation: "status", status: { effective: "on", source: "global", global: "on", cloneLocal: "" } }), targetStatus: async () => { calls++; throw new Error("protected native invocation"); } } as unknown as NativeReviewCli;
+	for (const target of [home, alias, "/", join(home, ".ssh")]) {
+		try { await __testing.executeReviewControllerOperation({ operation: "inspect", workspaceRoot: target }, home, native, undefined, null); }
+		catch { /* The public boundary can reject before returning an envelope. */ }
+	}
+	assert.equal(calls, 0, "no native STATUS against protected directories");
+});
+
+// A Git repository created in HOME, an ancestor of it, or a broad user folder
+// turns every later Git call in the user's tree into a scan of everything
+// below it (a Windows user measured ~47s startups). Bootstrap refuses them.
+test("native bootstrap refuses HOME ancestors and broad user folders but keeps project folders", t => {
+	const root = realpathSync(mkdtempSync(join(tmpdir(), "bootstrap-broad-")));
+	t.after(() => rmSync(root, { recursive: true, force: true }));
+	const home = join(root, "home");
+	const broad = ["Documents", "Desktop", "Downloads", "OneDrive", "OneDrive - Contoso", join("OneDrive", "Documents")];
+	for (const folder of [...broad, join("Documents", "project"), "project"]) mkdirSync(join(home, folder), { recursive: true });
+	for (const target of [root, home, ...broad.map(folder => join(home, folder))]) assert.equal(safeBootstrapDirectory(target, { home }), undefined, target);
+	for (const target of [join(home, "project"), join(home, "Documents", "project")]) assert.equal(safeBootstrapDirectory(target, { home }), target, target);
+});
+
+test("native bootstrap compares HOME case-insensitively on Windows only", t => {
+	const root = realpathSync(mkdtempSync(join(tmpdir(), "bootstrap-case-")));
+	t.after(() => rmSync(root, { recursive: true, force: true }));
+	const home = join(root, "home");
+	mkdirSync(join(home, "project"), { recursive: true });
+	const differentlyCasedHome = home.toUpperCase();
+	assert.equal(safeBootstrapDirectory(home, { home: differentlyCasedHome, platform: "win32" }), undefined);
+	assert.equal(safeBootstrapDirectory(home, { home: differentlyCasedHome, platform: "linux" }), home);
+	assert.equal(safeBootstrapDirectory(join(home, "project"), { home: differentlyCasedHome, platform: "win32" }), join(home, "project"));
+});
+
+// gentle-shell#1713: a writer continuation without its own section was
+// rejected, and every retry shortened the follow-up. A continuation resumes
+// the same delegated task, so it inherits the surfaces that launch admitted.
+test("writer continuations inherit the original surfaces only when they carry none", () => {
+	const original = "Implement it.\n\n## Allowed edit surfaces\n- src/model.ts\n- `docs/with space.md`\n\n## Return\nReport";
+	const inherited = inheritAllowedEditSurfaces("gentle-ai-worker", "Continue with the remaining specs.", undefined, original);
+	assert.deepEqual(allowedEditSurfaces(inherited), ["docs/with space.md", "src/model.ts"]);
+	assert.ok(inherited.startsWith("Continue with the remaining specs."));
+	const own = "Continue.\n## Allowed edit surfaces\nsrc/other.ts";
+	assert.equal(inheritAllowedEditSurfaces("gentle-ai-worker", own, undefined, original), own, "a follow-up section is validated as written, never merged");
+	const viaContext = "## Allowed edit surfaces\nsrc/other.ts";
+	assert.equal(inheritAllowedEditSurfaces("worker", "Continue.", viaContext, original), "Continue.");
+	assert.equal(inheritAllowedEditSurfaces("gentle-ai-explore", "Continue.", undefined, original), "Continue.", "non-writers are untouched");
+	assert.equal(inheritAllowedEditSurfaces("jd-fix-agent", "Continue.", undefined, original), "Continue.", "Judgment Day fix batches keep their exact protocol");
+	assert.equal(inheritAllowedEditSurfaces("gentle-ai-worker", "Continue.", undefined, "No surfaces here."), "Continue.", "nothing to inherit stays rejectable");
+	// Review R3-002: an entry admitted only when quoted must round-trip quoted.
+	const quotedOnly = "## Allowed edit surfaces\n- `-`\n- src/model.ts";
+	assert.deepEqual(allowedEditSurfaces(quotedOnly), ["-", "src/model.ts"]);
+	assert.deepEqual(allowedEditSurfaces(inheritAllowedEditSurfaces("worker", "Continue.", undefined, quotedOnly)), ["-", "src/model.ts"]);
+});
+
+// gentle-shell#1731: only agents behind the surfaces guard claim surfaces at runtime.
+test("bounded writers are exactly the agents behind the Allowed edit surfaces guard", () => {
+	for (const name of ["gentle-ai-worker", "worker", "jd-fix-agent"]) assert.equal(isBoundedWriter(name), true, name);
+	for (const name of ["explore", "gentle-ai-explore", "gentle-ai-verify", "reviewer", ""]) assert.equal(isBoundedWriter(name), false, name);
+});

package/tests/branch-pr-skill.test.ts

@@ -0,0 +1,43 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import test from "node:test";
+
+const skill = readFileSync(join(import.meta.dirname, "..", "skills/branch-pr/SKILL.md"), "utf8");
+
+test("target-host reads require explicit destination, operation and credential/session authorization", () => {
+	assert.match(skill, /explicit.*(?:destination|target).*operation.*credential\/session.*before.*target-host reads/i);
+	assert.match(skill, /reuse fresh target-bound.*issue.*default branch.*type.*labels.*checks/i);
+	assert.match(skill, /(?:do not|never).*ambient SSH/i);
+});
+
+test("issue linkage and protected labels retain human decisions without extra proof", () => {
+	assert.match(skill, /human-selected.*closing.*nonclosing.*Refs/i);
+	assert.match(skill, /protected labels.*exact direct instruction.*MAINTAIN\/ADMIN/i);
+	assert.match(skill, /human-selected.*size:exception.*rationale.*no separate instructor proof/i);
+	assert.doesNotMatch(skill, /Every PR body MUST contain:[\s\S]*?```markdown\s*Closes #<issue-number>/i);
+});
+
+test("oversized single PR does not impose Gentle size labels on generic users", () => {
+	assert.match(skill, /size:exception.*Gentle-owned.*not.*universal/i);
+	assert.match(skill, /destination repository's documented contribution\/size policy/i);
+	assert.match(skill, /only when.*policy.*size:exception/i);
+	assert.match(skill, /(?:never|do not).*request.*(?:create|add).*label.*generic/i);
+	assert.match(skill, /single-pr.*not.*(?:waive|bypass).*authorization/i);
+});
+
+test("required checks are target-policy based and actions are not automatic", () => {
+	assert.match(skill, /REQUIRED CI.*target policy/i);
+	assert.match(skill, /CodeRabbit.*optional.*unless required/i);
+	assert.match(skill, /(?:do not|never).*automatically commit.*push.*open.*PR.*merge/i);
+	assert.match(skill, /applicable test-first/i);
+	assert.match(skill, /advisory 400/i);
+	assert.doesNotMatch(skill, /\bSDD\b|OpenSpec|TUI Strict TDD/i);
+});
+
+test("template checklist reflects evidence rather than pre-checked assertions", () => {
+	assert.match(skill, /(?:do not|never).*unverified `?\[x\]`?/i);
+	assert.doesNotMatch(skill, /^- \[x\]/m);
+	assert.match(skill, /shellcheck on modified scripts/i);
+	assert.match(skill, /skills.*at least one agent/i);
+});

package/tests/bridge-wake-lifecycle.test.ts

@@ -0,0 +1,129 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { createAssistantMessageEventStream, getCurrentSystemPrompt, getCurrentTools, type AssistantMessage, type TranscriptContext } from "@earendil-works/pi-ai";
+import { createAgentSession, DefaultResourceLoader, ModelRuntime, SettingsManager, SessionManager } from "@earendil-works/pi-coding-agent";
+import gentleAgents, { type SessionTransportFactory } from "../extensions/gentle-agents.ts";
+import { fakeChild, type FakeChild } from "./agents-fake-child.ts";
+
+const sdk = import.meta.resolve("@earendil-works/pi-coding-agent");
+const { UserMessageComponent } = await import(new URL("./modes/interactive/components/user-message.js", sdk).href);
+const { initTheme } = await import(new URL("./modes/interactive/theme/theme.js", sdk).href);
+initTheme("dark");
+const transport: SessionTransportFactory = {
+	createRegistry: async () => ({ list: async () => [], listActivations: async () => [] }),
+	createListener: registry => ({ registry, start: async () => {}, close: async () => {} }),
+	createClient: () => ({ close() {}, sendNotification: async () => { throw new Error("Offline fixture forbids transport"); } }),
+};
+const tick = () => new Promise<void>(resolve => setImmediate(resolve));
+async function until(predicate: () => boolean) {
+	const deadline = Date.now() + 2000;
+	while (!predicate() && Date.now() < deadline) await tick();
+	assert.ok(predicate(), "offline lifecycle did not settle");
+}
+
+test("actual SDK Bridge wake retains preparation, history, reload and resumed rendering offline", async () => {
+	const root = mkdtempSync(join(tmpdir(), "bridge-lifecycle-"));
+	const home = join(root, "home"), cwd = join(root, "project"), agentDir = join(root, "agent");
+	mkdirSync(home, { recursive: true });
+	mkdirSync(cwd); mkdirSync(join(agentDir, "agents"), { recursive: true });
+	writeFileSync(join(agentDir, "agents", "explore.md"), "---\ndescription: Offline fixture\n---\nReturn a fixture answer.");
+	const children: FakeChild[] = [], requests: TranscriptContext[] = [];
+	let preparations = 0;
+	const modelRuntime = await ModelRuntime.create({ authPath: join(agentDir, "offline-auth.json"), modelsPath: null, refreshOnCreate: false });
+	// The provider name tests routing, but this model has no live implementation.
+	modelRuntime.registerProvider("claude-bridge", {
+		api: "bridge-offline-test", apiKey: "explicit-offline-dummy", baseUrl: "http://offline.invalid",
+		models: [{ id: "offline-recording", name: "Offline recording", reasoning: false, input: ["text"], cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, contextWindow: 100000, maxTokens: 1000 }],
+		streamSimple: (model, context) => {
+			assert.equal(model.id, "offline-recording");
+			requests.push(structuredClone(context));
+			const stream = createAssistantMessageEventStream();
+			const message: AssistantMessage = { role: "assistant", api: model.api, provider: model.provider, model: model.id, timestamp: Date.now(), content: [{ type: "text", text: "Offline continued" }], stopReason: "stop", usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } } };
+			queueMicrotask(() => { stream.push({ type: "start", partial: message }); stream.push({ type: "done", reason: "stop", message }); stream.end(); });
+			return stream;
+		},
+	});
+	const settingsManager = SettingsManager.inMemory({ compaction: { enabled: false }, retry: { enabled: false } });
+	const loader = new DefaultResourceLoader({ cwd, agentDir, settingsManager, noExtensions: true, noSkills: true, noPromptTemplates: true, noThemes: true, noContextFiles: true,
+		extensionFactories: [pi => {
+			gentleAgents(pi, {}, { home, agentHome: agentDir, env: { PATH: "/usr/bin:/bin" }, pi: { command: "offline-child", args: [] }, spawn: () => { const child = fakeChild(); children.push(child); return child.child; }, schedule: () => () => {}, sessionTransport: transport, resolveWorktree: () => undefined });
+			pi.registerTool({ name: "sentinel", label: "Sentinel", description: "Offline sentinel tool", parameters: { type: "object", properties: {} } as never, execute: async () => ({ content: [], details: undefined }) });
+			pi.on("before_agent_start", event => {
+				preparations++;
+				pi.setActiveTools(["sentinel"]);
+				event.systemPromptOptions.appendSystemPrompt += `\nBRIDGE_PREPARATION_SENTINEL_${preparations}`;
+				event.systemPromptOptions.selectedTools = ["sentinel"];
+			});
+		}],
+	});
+	await loader.reload();
+	const manager = SessionManager.create(cwd, join(root, "sessions"));
+	const model = modelRuntime.getModel("claude-bridge", "offline-recording")!;
+	const errors: string[] = [];
+	const create = async (sessionManager: SessionManager) => {
+		const result = await createAgentSession({ cwd, agentDir, modelRuntime, model, tools: ["sentinel"], settingsManager, resourceLoader: loader, sessionManager });
+		await result.session.bindExtensions({ mode: "rpc", onError: error => errors.push(error.error) });
+		return result.session;
+	};
+	let session = await create(manager);
+	try {
+		await session.prompt("Ordinary human turn");
+		const launch = async (id: string) => {
+			const tool = session.extensionRunner.getAllRegisteredTools().find(tool => tool.definition.name === "subagent_run")!.definition;
+			const count = children.length;
+			const result = await tool.execute(id, { agent: "explore", task: "Offline work", mode: "background" }, undefined, undefined, session.extensionRunner.createToolContext(id, undefined));
+			assert.ok(JSON.stringify(result).includes("taskId"), JSON.stringify(result));
+			await until(() => children.length > count);
+			return children.at(-1)!;
+		};
+		const child = await launch("completion");
+		child.emit({ type: "agent_end", messages: [{ role: "assistant", content: [{ type: "text", text: "OFFLINE_CHILD_RESULT" }] }] });
+		child.emit({ type: "agent_settled" });
+		await until(() => requests.length === 2 && session.isIdle);
+		assert.equal(preparations, 2, "wake traverses normal prompt/before_agent_start");
+		assert.match(getCurrentSystemPrompt(requests[1].messages), /BRIDGE_PREPARATION_SENTINEL_2/);
+		assert.deepEqual(getCurrentTools(requests[1].messages).map(tool => tool.name), ["sentinel"]);
+		const wakeEntries = manager.getEntries().filter(entry => entry.type === "custom" && entry.customType === "gentle-agents.wake-identity");
+		assert.equal(wakeEntries.length, 1);
+		const identity = (wakeEntries[0] as { data: { text: string } }).data;
+		assert.ok(session.messages.some(message => message.role === "user" && JSON.stringify(message.content).includes(identity.text)), "wake is still user-role history");
+		assert.ok(JSON.stringify(requests[1].messages).includes(identity.text), "wake remains model-visible");
+		assert.equal(manager.getEntries().filter(entry => entry.type === "custom_message" && entry.customType === "gentle-agents.result").length, 1);
+		const render = (text: string) => new UserMessageComponent(text, undefined, 1, session.extensionRunner.getMarkdownTransformers()).render(80);
+		assert.deepEqual(render(identity.text), []);
+		assert.ok(render("Ordinary human turn").length > 0);
+		await session.reload();
+		assert.equal(session.extensionRunner.getMarkdownTransformers().length, 1);
+		assert.deepEqual(render(identity.text), [], "reload reconstructs the durable identity");
+		const file = manager.getSessionFile()!;
+		await session.extensionRunner.emit({ type: "session_shutdown", reason: "quit" });
+		session.dispose();
+		await loader.reload();
+		session = await create(SessionManager.open(file));
+		assert.equal(session.extensionRunner.getMarkdownTransformers().length, 1);
+		assert.deepEqual(render(identity.text), [], "opening saved history restores suppression");
+		const queryChild = await launch("query");
+		queryChild.message({ id: "q1", kind: "query", message: "OFFLINE_CHILD_QUERY" });
+		await until(() => requests.length === 3 && session.isIdle);
+		assert.equal(preparations, 3);
+		assert.match(getCurrentSystemPrompt(requests[2].messages), /BRIDGE_PREPARATION_SENTINEL_3/);
+		assert.deepEqual(getCurrentTools(requests[2].messages).map(tool => tool.name), ["sentinel"]);
+		assert.equal(session.sessionManager.getEntries().filter(entry => entry.type === "custom" && entry.customType === "gentle-agents.wake-identity").length, 1, "resume reuses one identity");
+		assert.equal(session.sessionManager.getEntries().filter(entry => entry.type === "custom_message" && entry.customType === "gentle-agents.message").length, 1, "query stored once");
+		await session.extensionRunner.emit({ type: "session_shutdown", reason: "quit" });
+		session.dispose();
+		await loader.reload();
+		session = await create(SessionManager.inMemory(cwd));
+		assert.equal(session.extensionRunner.getMarkdownTransformers().length, 1);
+		assert.ok(render(identity.text).length > 0, "switching to another session releases the old identity");
+		assert.ok(render("Ordinary human turn").length > 0);
+		assert.deepEqual(errors, []);
+	} finally {
+		await session.extensionRunner.emit({ type: "session_shutdown", reason: "quit" });
+		session.dispose();
+		rmSync(root, { recursive: true, force: true });
+	}
+});

package/tests/bridge-wake-rendering.test.ts

@@ -0,0 +1,56 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { createAgentSession, ModelRuntime, DefaultResourceLoader, SettingsManager, SessionManager } from "@earendil-works/pi-coding-agent";
+import gentleAgents from "../extensions/gentle-agents.ts";
+
+// Resolve from the installed SDK entry, never from a vendored runtime copy.
+const sdk = import.meta.resolve("@earendil-works/pi-coding-agent");
+const { UserMessageComponent } = await import(new URL("./modes/interactive/components/user-message.js", sdk).href);
+const { initTheme } = await import(new URL("./modes/interactive/theme/theme.js", sdk).href);
+initTheme("dark");
+const oldWake = "[System-generated Gentle Agents notification, not written by the user] Subagent output was delivered to this session above. Review it and continue.";
+
+test("real user renderer preserves ordinary content and removes only the owned reserved wake", async () => {
+	// Every path is owned by this test so CI never depends on ambient TMPDIR, HOME, or agent directories.
+	const root = mkdtempSync(join(tmpdir(), "bridge-rendering-"));
+	try {
+		const home = join(root, "home"), cwd = join(root, "project"), agentDir = join(root, "agent");
+		mkdirSync(home); mkdirSync(cwd); mkdirSync(agentDir);
+		const manager = SessionManager.inMemory(cwd);
+		const wake = `${oldWake} [gentle-agents wake: 67da57d9-7fbe-47b6-9187-c31109fe4eba]`;
+		manager.appendCustomEntry("gentle-agents.wake-identity", { sessionId: manager.getSessionId(), nonce: "invalid", text: "Human continuation" });
+		manager.appendCustomEntry("gentle-agents.wake-identity", { sessionId: "other-session", nonce: "67da57d9-7fbe-47b6-9187-c31109fe4eba", text: "Human continuation" });
+		manager.appendCustomEntry("gentle-agents.wake-identity", { sessionId: manager.getSessionId(), nonce: "67da57d9-7fbe-47b6-9187-c31109fe4eba", text: wake });
+		const settingsManager = SettingsManager.inMemory();
+		const loader = new DefaultResourceLoader({
+			cwd, agentDir, settingsManager,
+			noExtensions: true, noSkills: true, noPromptTemplates: true, noThemes: true, noContextFiles: true,
+			extensionFactories: [pi => gentleAgents(pi, {}, { home, agentHome: agentDir, schedule: () => () => {} })],
+		});
+		await loader.reload();
+		const loaded = loader.getExtensions();
+		assert.deepEqual(loaded.errors, []);
+		const modelRuntime = await ModelRuntime.create({ authPath: join(agentDir, "offline-auth.json"), modelsPath: null, refreshOnCreate: false });
+		const { session } = await createAgentSession({ cwd, agentDir, resourceLoader: loader, sessionManager: manager, settingsManager, modelRuntime, tools: [] });
+		await session.bindExtensions({});
+		try {
+			const transformers = session.extensionRunner.getMarkdownTransformers();
+			assert.equal(transformers.length, 1);
+			for (const width of [12, 80, 140]) {
+				assert.deepEqual(new UserMessageComponent(wake, undefined, 1, transformers).render(width), [], "no lines, padding, bubble, or OSC markers");
+				for (const ordinary of [oldWake, `Quoted: ${wake}`, ` ${wake}`, `${wake}\n`, "Human continuation"]) {
+					assert.ok(new UserMessageComponent(ordinary, undefined, 1, transformers).render(width).length > 0);
+				}
+			}
+			assert.equal(transformers[0](wake, { messageType: "assistant", isStreaming: false, availableWidth: 80 }), wake);
+		} finally {
+			await session.extensionRunner.emit({ type: "session_shutdown", reason: "quit" });
+			session.dispose();
+		}
+	} finally {
+		rmSync(root, { recursive: true, force: true });
+	}
+});