gentle-pi 2.7.0 → 3.0.0

package/tests/sdd-task-truth.test.ts

@@ -0,0 +1,43 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import test from "node:test";
+
+const asset = (name: string) => readFileSync(new URL(`../assets/${name}`, import.meta.url), "utf8");
+
+test("task truth uses ordinary checkboxes without local owner-marker admission", () => {
+ const tasks = asset("agents/sdd-tasks.md"), apply = asset("agents/sdd-apply.md");
+ assert.match(tasks, /- \[ \] 1\. Implement and verify the behavior\./);
+ assert.doesNotMatch(tasks, /<!-- sdd-owner:/);
+ assert.doesNotMatch(apply, /fix-task-ownership-marker|unsupported, duplicate, or non-terminal/);
+ assert.match(apply, /Preserve historical ownership comments/);
+ assert.match(apply, /native task progress and authorized scope/);
+ assert.match(apply, /mark each completed implementation task.*immediately after completion/);
+ assert.match(apply, /Before returning, re-read the persisted tasks artifact/);
+ assert.match(apply, /never overwrite completed work/);
+});
+
+test("task planning honors configured TDD rather than test availability", () => {
+ const tasks = asset("agents/sdd-tasks.md");
+ assert.doesNotMatch(tasks, /If tests exist or strict TDD/);
+ assert.match(tasks, /Only when configured strict TDD is active/);
+ assert.match(tasks, /Test availability alone does not enable TDD/);
+ assert.match(tasks, /400 changed lines/);
+});
+
+test("verification reports remaining task truth without manufacturing archive authority", () => {
+ const verify = asset("agents/sdd-verify.md");
+ assert.doesNotMatch(verify, /mark each as a CRITICAL completeness issue and archive blocker|Archive exceptions are limited/);
+ assert.match(verify, /Report the exact unchecked lines as remaining work/);
+ assert.match(verify, /Do not return a clean `PASS`/);
+ assert.match(verify, /Archive admission follows fresh native status and real permissions/);
+});
+
+test("selected stores preserve partial persistence and cumulative readback truth", () => {
+ const apply = asset("agents/sdd-apply.md"), memory = asset("orchestrator-memory.md");
+ assert.match(apply, /`openspec`\s*\/\s*`both`: write\/update/);
+ assert.match(apply, /`engram`\s*\/\s*`both`: update the/);
+ assert.match(apply, /read back each selected backend/);
+ assert.match(apply, /not atomic/);
+ assert.match(memory, /do not switch the selected store/);
+ assert.doesNotMatch(memory, /return artifacts inline and\/or write OpenSpec files/);
+});

package/tests/session-change-capture.test.ts

@@ -4,7 +4,7 @@ import { mkdtemp, writeFile, rm, realpath } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { installSessionChangeCapture } from "../lib/session-change-capture.ts";
-import { SessionChanges, SESSION_CHANGE_ENTRY } from "../lib/session-changes.ts";
+import { SessionChanges, SESSION_CHANGE_ENTRY, SESSION_CHANGE_EVENT } from "../lib/session-changes.ts";
 
 async function fixture(run: (f: any) => Promise<void>, child = false) {
 	const root = await realpath(await mkdtemp(join(tmpdir(), "change-capture-")));
@@ -17,7 +17,7 @@ async function fixture(run: (f: any) => Promise<void>, child = false) {
 	const ctx = { cwd:root, sessionManager: { getSessionId: () => id, getEntries: () => entries } };
 	installSessionChangeCapture(pi as never, child ? {GENTLE_PI_AGENTS_CHILD:"1"} : {}, () => ({root,commonDir:root}));
 	const fire = (key, event = {}) => handlers.get(key)?.(event, ctx);
-	try { await fire("session_start"); await run({root, entries, ctx, fire, switchSession: () => id = "other"}); }
+	try { await fire("session_start"); await run({root, entries, ctx, fire, pi, switchSession: () => id = "other"}); }
 	finally { await rm(root, {recursive:true,force:true}); }
 }
 
@@ -66,3 +66,21 @@ test("child carries bounded evidence in the existing tool-result details transpo
 	assert.equal(result.details.gentleSessionChange.path,"new");
 	assert.deepEqual(entries,[]);
 },true));
+
+test("the capture-limit warning is emitted once, not on every later write", async () => fixture(async ({root,fire,pi}) => {
+	const events: Array<{notice?: string}> = [];
+	pi.events.on(SESSION_CHANGE_EVENT, (data: {notice?: string}) => events.push(data));
+	for (let i = 0; i < 80; i++) {
+		const path = `f${i}`;
+		const content = "x".repeat(60 * 1024) + "\n";
+		const event = {toolCallId:`w${i}`,toolName:"write",input:{path,content}};
+		await fire("tool_call",event);
+		await writeFile(join(root,path),content);
+		await fire("tool_result",{...event,isError:false});
+		await fire("tool_execution_end",{toolCallId:`w${i}`,toolName:"write",isError:false});
+	}
+	const withNotice = events.filter(event => event.notice !== undefined);
+	assert.equal(withNotice.length,1);
+	assert.match(withNotice[0].notice!,/limit reached/);
+	assert.equal(events.length,80);
+}));

package/tests/session-changes.test.ts

@@ -101,3 +101,14 @@ test("capture capacity is explicit instead of growing without limit", () => {
 	assert.equal(changes.model.files.length,256);
 	assert.match(changes.notice!,/limit reached/);
 });
+
+test("capture-limit notice is delivered once but stays on the model", () => {
+	const changes = new SessionChanges("session");
+	for(let i=0;i<257;i++) changes.record(evidence(String(i),"/repo",String(i)+".ts"));
+	assert.match(changes.takeNotice()!,/limit reached/);
+	assert.equal(changes.takeNotice(),undefined);
+	assert.match(changes.notice!,/limit reached/);
+	assert.match(changes.model.notice!,/limit reached/);
+	assert.equal(new SessionChanges("s").takeNotice(),undefined);
+	assert.equal(new SessionChanges("s").model.notice,undefined);
+});

package/tests/shell-bar.test.ts

@@ -176,6 +176,27 @@ test("shellEnabled honors GENTLE_PI_SHELL=0", () => {
 	assert.equal(shellEnabled({ GENTLE_PI_SHELL: "false" }), false);
 });
 
+test("sidebar unifies project, captured changes, usage and integrations in one frame", () => {
+	const data = model({ changes: { files: 2, added: 7, deleted: 3, notice: "capture warning" }, statuses: ["MCP connected"] });
+	const lines = renderShellSidebarBar(data, plainTheme, 46);
+	const text = lines.join("\n");
+	assert.equal(lines.filter((line) => line.startsWith("╭")).length, 1);
+	let previous = -1;
+	for (const heading of ["Status", "Project", "Changes", "Usage", "Integrations"]) {
+		const index = text.indexOf(heading);
+		assert.ok(index > previous, heading);
+		previous = index;
+	}
+	assert.match(text, /2 files.*\+7.*−3/);
+	assert.match(text, /capture warning/);
+	assert.match(text, /\/gentle:changes/);
+	assert.match(text, /gpt-5\.5/);
+	for (const width of [1, 8, 24, 46]) assert.ok(renderShellSidebarBar(data, plainTheme, width).every((line) => visibleWidth(line) <= width));
+	const empty = renderShellSidebarBar(model(), plainTheme, 46).join("\n");
+	assert.match(empty, /No captured changes/);
+	assert.match(empty, /Integrations/);
+});
+
 test("sidebar profile wraps long names without changing the compact bar", () => {
 	const profile = "team-" + "x".repeat(59);
 	const base = model();

package/tests/shell-card.test.ts

@@ -53,11 +53,11 @@ test("renderCard collapses to the frame and the first body line with an expand h
 	assert.equal(visibleWidth(lines[1]), 60);
 });
 
-test("renderCard keeps the rail and its corners in the tone and the rest of the frame in the border color", () => {
+test("renderCard uses the card tone across the full frame while preserving content roles", () => {
 	const info = renderCard(card(), taggedTheme, 80, { expanded: true });
-	assert.match(info[0], /^<customMessageLabel>╭<\/customMessageLabel><border>─ <\/border><customMessageLabel>✿ Gentle AI<\/customMessageLabel> <muted>·<\/muted> <muted>review preflight<\/muted><border> ─+<\/border><border>╮<\/border>$/);
-	assert.match(info[1], /^<customMessageLabel>│<\/customMessageLabel> <text>.*<border>│<\/border>$/);
-	assert.match(info[info.length - 1], /^<customMessageLabel>╰<\/customMessageLabel><border>─+╯<\/border>$/);
+	assert.match(info[0], /^<customMessageLabel>╭<\/customMessageLabel><customMessageLabel>─ <\/customMessageLabel><customMessageLabel>✿ Gentle AI<\/customMessageLabel> <muted>·<\/muted> <muted>review preflight<\/muted><customMessageLabel> ─+<\/customMessageLabel><customMessageLabel>╮<\/customMessageLabel>$/);
+	assert.match(info[1], /^<customMessageLabel>│<\/customMessageLabel> <text>.*<customMessageLabel>│<\/customMessageLabel>$/);
+	assert.match(info[info.length - 1], /^<customMessageLabel>╰<\/customMessageLabel><customMessageLabel>─+╯<\/customMessageLabel>$/);
 
 	const warning = renderCard(card({ tone: CARD_TONE.WARNING, subtitle: undefined }), taggedTheme, 80, { expanded: true });
 	assert.match(warning[0], /^<warning>╭<\/warning>/);
@@ -65,8 +65,10 @@ test("renderCard keeps the rail and its corners in the tone and the rest of the
 	assert.match(warning[1], /^<warning>│<\/warning> /);
 	assert.match(warning[warning.length - 1], /^<warning>╰<\/warning>/);
 
-	const error = renderCard(card({ tone: CARD_TONE.ERROR }), taggedTheme, 80, { expanded: true });
-	assert.match(error[0], /<error>✿ Gentle AI<\/error>/);
+	const error = renderCard(card({ tone: CARD_TONE.ERROR }), taggedTheme, 80, { expanded: true, hint: "ctrl+o to expand" });
+	assert.match(error[0], /^<error>╭<\/error><error>─ <\/error><error>✿ Gentle AI<\/error> <muted>·<\/muted> <muted>review preflight<\/muted><error> ─+<\/error> <dim>ctrl\+o to expand<\/dim> <error>╮<\/error>$/);
+	assert.match(error[1], /^<error>│<\/error> <text>.*<error>│<\/error>$/);
+	assert.match(error[error.length - 1], /^<error>╰<\/error><error>─+╯<\/error>$/);
 	assert.equal(CARD_TONE.SUCCESS, "success");
 });
 

package/tests/shell-changes.test.ts

@@ -98,6 +98,14 @@ test("changesSummary and the widget describe the session at a glance", () => {
 	assert.equal(visibleWidth(line), 120, "the command sits on the right edge");
 });
 
+test("changesSummary and the widget surface the capture limit", () => {
+	const model = changesModel([file("a.ts", 1, 0)]);
+	model.notice = "Session change capture limit reached; additional changes are not displayed.";
+	assert.equal(changesSummary(model), "1 file · +1 −0 · capture limit reached");
+	assert.match(renderChangesWidget(model, plainTheme, 200)[0], /capture limit reached/);
+	assert.doesNotMatch(changesSummary(changesModel([file("a.ts", 1, 0)])), /capture limit reached/);
+});
+
 test("renderChangesWidget colors counts by direction and yields nothing when clean", () => {
 	const model = changesModel([file("a.ts", 1, 2)]);
 	const [line] = renderChangesWidget(model, taggedTheme, 400);

package/tests/shell-prompt.test.ts

@@ -4,13 +4,46 @@ import { visibleWidth } from "@earendil-works/pi-tui";
 import { stripAnsi } from "../lib/terminal-theme.ts";
 import {
 	framePromptLines,
+	scanWorkingText,
 	PROMPT_STATE,
 	petalGlyph,
 	petalTone,
+	SHELL_PULSE_MS,
+	SHELL_SCANNER_STEPS,
 	withPromptHint,
 	type PromptFrameOptions,
 } from "../lib/shell-prompt.ts";
 
+test("scanner reflects a symmetric light wave across working text at Pi's original cadence", () => {
+	const fg = (role: string, char: string) => `<${role}>${char}</${role}>`;
+	assert.equal(SHELL_PULSE_MS, 80);
+	assert.equal(SHELL_SCANNER_STEPS, 15);
+	for (const word of ["working…", "Thinking…"]) {
+		for (let tick = 0; tick < SHELL_SCANNER_STEPS; tick++) {
+			const frame = scanWorkingText(word, tick, fg);
+			assert.equal(frame.replace(/<[^>]+>/g, ""), word);
+		}
+		assert.match(scanWorkingText(word, 0, fg), /^(<muted>.<\/muted>)+$/);
+		assert.match(scanWorkingText(word, 3, fg), new RegExp(`^<borderAccent>${word[0]}</borderAccent><accent>${word[1]}</accent><thinkingHigh>${word[2]}</thinkingHigh>`));
+		assert.match(scanWorkingText(word, 4, fg), new RegExp(`^<accent>${word[0]}</accent><borderAccent>${word[1]}</borderAccent><accent>${word[2]}</accent>`));
+		assert.match(scanWorkingText(word, 5, fg), new RegExp(`^<thinkingHigh>${word[0]}</thinkingHigh><accent>${word[1]}</accent><borderAccent>${word[2]}</borderAccent>`));
+		assert.match(scanWorkingText(word, 14, fg), /^(<muted>.<\/muted>)+$/);
+		assert.equal(scanWorkingText(word, SHELL_SCANNER_STEPS, fg), scanWorkingText(word, 0, fg));
+	}
+	for (const width of [1, 8, 20, 40]) {
+		for (let tick = 0; tick < SHELL_SCANNER_STEPS; tick++) {
+			const lines = framePromptLines(editorLines(Math.max(4, width)), width, options({ state: PROMPT_STATE.WORKING, tick, fg: (_role, text) => text }));
+			assert.ok(lines.every((line) => visibleWidth(line) <= width));
+		}
+	}
+});
+
+test("compact banner pulse rises from ink through fresh color to a bright tip then fades", () => {
+	const tones = Array.from({ length: 8 }, (_, tick) => petalTone(PROMPT_STATE.WORKING, tick));
+	assert.deepEqual(tones, ["mdQuoteBorder", "thinkingHigh", "accent", "borderAccent", "accent", "thinkingHigh", "mdQuoteBorder", "mdQuoteBorder"]);
+	assert.equal(petalTone(PROMPT_STATE.WORKING, 8), tones[0]);
+});
+
 // The Gentle Shell prompt wraps pi's editor output (a top rule, padded content
 // lines, a bottom rule) in a rounded frame with a petal that shows the agent
 // state. Framing is pure: it takes the editor's lines and returns new ones.
@@ -56,7 +89,7 @@ test("framePromptLines paints the frame with the editor border color and the pet
 
 test("petalTone rests bright, walks the rose ramp while working, and turns to warning when queued", () => {
 	assert.equal(petalTone(PROMPT_STATE.IDLE, 2), "borderAccent");
-	assert.deepEqual([0, 1, 2, 3, 4].map((tick) => petalTone(PROMPT_STATE.WORKING, tick)), ["borderAccent", "accent", "thinkingHigh", "mdQuoteBorder", "borderAccent"]);
+	assert.deepEqual([0, 1, 2, 3, 4].map((tick) => petalTone(PROMPT_STATE.WORKING, tick)), ["mdQuoteBorder", "thinkingHigh", "accent", "borderAccent", "accent"]);
 	assert.equal(petalTone(PROMPT_STATE.QUEUED, 1), "warning");
 });
 
@@ -66,13 +99,14 @@ test("petalGlyph spins through the flowers while working and rests otherwise", (
 	assert.equal(petalGlyph(PROMPT_STATE.QUEUED, 1), "❀");
 });
 
-test("framePromptLines spins the petal and labels the working and queued states", () => {
+test("framePromptLines scans the working word while preserving the frame and queued state", () => {
 	const plain = (_color: string, text: string) => text;
-	const working = framePromptLines(editorLines(40), 40, options({ state: PROMPT_STATE.WORKING, tick: 1 }));
-	assert.match(working[0], /<accent>❀<\/accent>/);
-	assert.match(working[0], /<muted>working<\/muted>/);
-	const workingPlain = framePromptLines(editorLines(40), 40, options({ state: PROMPT_STATE.WORKING, tick: 1, fg: plain }));
-	assert.match(stripAnsi(workingPlain[0]), /^╭─ ❀ working ─+╮$/);
+	const working = framePromptLines(editorLines(40), 40, options({ state: PROMPT_STATE.WORKING, tick: 3 }));
+	assert.match(working[0], /<borderAccent>✾<\/borderAccent>/);
+	assert.match(working[0], /<borderAccent>w<\/borderAccent><accent>o<\/accent><thinkingHigh>r<\/thinkingHigh>/);
+	assert.equal(working[0].replace(/<[^>]+>/g, "").includes("working…"), true);
+	const workingPlain = framePromptLines(editorLines(40), 40, options({ state: PROMPT_STATE.WORKING, tick: 3, fg: plain }));
+	assert.match(stripAnsi(workingPlain[0]), /^╭─ ✾ working… ─+╮$/);
 	assert.equal(visibleWidth(workingPlain[0]), 40);
 
 	const queued = framePromptLines(editorLines(40), 40, options({ state: PROMPT_STATE.QUEUED }));

package/tests/shell-sidebar-banner.test.ts

@@ -5,8 +5,8 @@ import { renderSidebarBanner } from "../lib/shell-sidebar-banner.ts";
 
 const plain = { fg: (_role: string, text: string) => text, bold: (text: string) => text };
 test("sidebar heading is only the centered literal product label", () => {
-	const label = "✿ Gentle-Pi ✿";
-	for (const width of [0, 1, 8, 11, 20, 21, 30, 45, 46, 80]) {
+	const label = "✿ Gentle Shell ✿";
+	for (const width of [0, 1, 8, 11, 15, 16, 17, 20, 21, 30, 45, 46, 80]) {
 		const lines = renderSidebarBanner(plain, width);
 		const space = width - visibleWidth(label);
 		assert.deepEqual(lines, space >= 0 ? [" ".repeat(Math.floor(space / 2)) + label + " ".repeat(Math.ceil(space / 2))] : []);
@@ -17,7 +17,7 @@ test("sidebar heading is only the centered literal product label", () => {
 test("heading uses the current theme on every render", () => {
 	let palette = "dark";
 	const theme = { ...plain, fg: (role: string, text: string) => `<${palette}:${role}>${text}` };
-	assert.equal(renderSidebarBanner(theme, 46)[0].trim(), "<dark:accent>✿ <dark:text>Gentle-Pi <dark:accent>✿");
+	assert.equal(renderSidebarBanner(theme, 46)[0].trim(), "<dark:accent>✿ <dark:text>Gentle Shell <dark:accent>✿");
 	palette = "light";
-	assert.equal(renderSidebarBanner(theme, 46)[0].trim(), "<light:accent>✿ <light:text>Gentle-Pi <light:accent>✿");
+	assert.equal(renderSidebarBanner(theme, 46)[0].trim(), "<light:accent>✿ <light:text>Gentle Shell <light:accent>✿");
 });

package/tests/shell-sidebar-layout.test.ts

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { ScrollView, visibleWidth, type TUI, type TuiMouseEvent } from "@earendil-works/pi-tui";
-import { renderLayoutFrame } from "@earendil-works/pi-tui/dist/layout.js";
+import { CURSOR_MARKER, ScrollView, VStack, visibleWidth, type TUI, type TuiMouseEvent } from "@earendil-works/pi-tui";
+import { getScrollViewsAt, renderLayoutFrame, type LayoutBox } from "@earendil-works/pi-tui/dist/layout.js";
 import { installSidebar, invalidateSidebar } from "../lib/shell-sidebar-layout.ts";
 import { sidebarPart, sidebarState } from "../lib/shell-sidebar.ts";
 import { renderShellSidebarBar } from "../lib/shell-bar.ts";
@@ -32,7 +32,7 @@ test("grouped Status preserves structured fields and opaque integration text", (
 	}, theme, 46);
 	const text = lines.join("\n");
 	let previous = -1;
-	for (const heading of ["Status", "Project", "Model", "Context", "Usage", "Integrations"]) {
+	for (const heading of ["Status", "Project", "Changes", "Usage", "Integrations"]) {
 		const index = text.indexOf(heading);
 		assert.ok(index > previous, heading);
 		previous = index;
@@ -67,13 +67,13 @@ test("only fullscreen at 140 columns activates; shrinking restores bottom paint"
 	}
 });
 
-test("rail orders Status, changes, agents, TODO independent of registration order", (t) => {
+test("rail orders unified Status, agents, TODO without standalone changes", (t) => {
 	const f = fixture();
 	for (const key of ["todo", "agents", "changes"]) {
 		sidebarPart(f.tui, key, { render: () => [key, ""], invalidate() {} });
 	}
 	t.after(installSidebar(f.tui, theme));
-	assert.deepEqual(rail(f).render(50).map((line) => line.trim()), ["✿ Gentle-Pi ✿", "", "Status", "", "changes", "", "agents", "", "todo"]);
+	assert.deepEqual(rail(f).render(50).map((line) => line.trim()), ["✿ Gentle Shell ✿", "", "Status", "", "agents", "", "todo"]);
 });
 
 test("branding belongs to scroll content before Status, never transcript or narrow bottom", (t) => {
@@ -81,14 +81,14 @@ test("branding belongs to scroll content before Status, never transcript or narr
 	t.after(installSidebar(f.tui, theme));
 	const scroll = rail(f);
 	const lines = scroll.render(50);
-	const brandIndex = lines.findIndex((line) => line.includes("✿ Gentle-Pi ✿"));
+	const brandIndex = lines.findIndex((line) => line.includes("✿ Gentle Shell ✿"));
 	assert.ok(brandIndex >= 0 && brandIndex < lines.findIndex((line) => line.includes("Status")));
 	assert.doesNotMatch(lines.join("\n"), /[\u2800-\u28ff]/);
 	const heading = lines[brandIndex];
 	const usableWidth = scroll.getContentWidth(50) - 2;
-	const spare = usableWidth - visibleWidth("✿ Gentle-Pi ✿");
+	const spare = usableWidth - visibleWidth("✿ Gentle Shell ✿");
 	const scrollbarWidth = 50 - scroll.getContentWidth(50);
-	assert.equal(heading, " ".repeat(1 + Math.floor(spare / 2)) + "✿ Gentle-Pi ✿" + " ".repeat(1 + Math.ceil(spare / 2) + scrollbarWidth));
+	assert.equal(heading, " ".repeat(1 + Math.floor(spare / 2)) + "✿ Gentle Shell ✿" + " ".repeat(1 + Math.ceil(spare / 2) + scrollbarWidth));
 	assert.deepEqual(f.root.render(), ["transcript"]);
 	scroll.updateLayout(lines.length, 2, () => {});
 	scroll.scrollBy(9);
@@ -249,30 +249,30 @@ test("real layout frames reuse unchanged sidebar output and invalidate at state
 	t.after(installSidebar(f.tui, theme));
 
 	const first = renderLayoutFrame(f.root, 140, 20, () => {});
-	assert.deepEqual(counts, { footer: 1, changes: 1, agents: 1, todo: 1 });
+	assert.deepEqual(counts, { footer: 1, changes: 0, agents: 1, todo: 1 });
 	const sidebarRail = first.root.children[1]?.component as ScrollView;
 	renderLayoutFrame(f.root, 140, 20, () => {});
-	assert.deepEqual(counts, { footer: 1, changes: 1, agents: 1, todo: 1 });
+	assert.deepEqual(counts, { footer: 1, changes: 0, agents: 1, todo: 1 });
 
 	todo = "Todo two";
 	sidebarRail.invalidate();
 	const changed = renderLayoutFrame(f.root, 140, 20, () => {});
 	assert.match(changed.lines.join("\n"), /Todo two/);
-	assert.deepEqual(counts, { footer: 2, changes: 2, agents: 2, todo: 2 });
+	assert.deepEqual(counts, { footer: 2, changes: 0, agents: 2, todo: 2 });
 
 	f.host.terminal.columns = 139;
 	renderLayoutFrame(f.root, 139, 20, () => {});
 	assert.deepEqual(f.bottom.render(80), ["Status"]);
 	f.host.terminal.columns = 140;
 	renderLayoutFrame(f.root, 140, 20, () => {});
-	assert.deepEqual(counts, { footer: 3, changes: 3, agents: 3, todo: 3 });
+	assert.deepEqual(counts, { footer: 3, changes: 0, agents: 3, todo: 3 });
 
 	f.host.mode = "regular";
 	renderLayoutFrame(f.root, 140, 20, () => {});
 	assert.deepEqual(f.bottom.render(80), ["Status"]);
 	f.host.mode = "fullscreen";
 	renderLayoutFrame(f.root, 140, 20, () => {});
-	assert.deepEqual(counts, { footer: 4, changes: 4, agents: 4, todo: 4 });
+	assert.deepEqual(counts, { footer: 4, changes: 0, agents: 4, todo: 4 });
 
 	let replacementRenders = 0;
 	sidebarPart(f.tui, "todo", {
@@ -385,3 +385,87 @@ test("unsupported roots, empty rails and overflowing parts leave native layout i
 	t.after(installSidebar(f.tui, theme));
 	assert.deepEqual(f.bottom.render(80), ["Status"]);
 });
+
+// A real native subtree exposes duplicate rendering hidden by empty-layout fixtures.
+function nativeSidebarFixture(legacyMeasurement = false) {
+	let transcriptRenders = 0;
+	let editorRows = 1;
+	const transcript = {
+		render(width: number) {
+			transcriptRenders++;
+			return Array.from({ length: 1000 }, (_, index) => `\x1b[32mEntry ${index} 界 é at ${width}\x1b[0m`);
+		},
+		invalidate() {},
+	};
+	const primary = new ScrollView(transcript, { primary: true, follow: "end", scrollbar: "always" });
+	const editor = { render: () => Array.from({ length: editorRows }, (_, index) => `Editor ${index}${index === editorRows - 1 ? CURSOR_MARKER : ""}`), invalidate() {} };
+	const root = new VStack([{ component: primary, basis: 0, grow: 1 }, { component: editor }]);
+	const originalRender = root.render;
+	const host = { mode: "fullscreen", terminal: { columns: 180 }, layoutRoot: root, requestRender() {} };
+	const tui = host as unknown as TUI;
+	sidebarPart(tui, "footer", { render: () => Array.from({ length: 100 }, (_, i) => `Status ${i}`), invalidate() {} });
+	const dispose = installSidebar(tui, theme);
+	const nativeRoot = root as unknown as { [NODE](): { entries: Array<{ component: { render(width: number): string[] } }> } };
+	if (legacyMeasurement) nativeRoot[NODE]().entries[0].component.render = (width) => root.render(width);
+	return {
+		root, primary, host, dispose, originalRender,
+		growEditor: () => { editorRows = 4; },
+		frame(width = host.terminal.columns, height = 30) {
+			host.terminal.columns = width;
+			transcriptRenders = 0;
+			const frame = renderLayoutFrame(root, width, height, () => {});
+			return { frame, transcriptRenders };
+		},
+	};
+}
+
+function layoutGeometry(box: LayoutBox): unknown {
+	return { rect: box.rect, clip: box.clip, lineOffset: box.lineOffset, scroll: !!box.scrollView, children: box.children.map(layoutGeometry) };
+}
+
+test("fullscreen native transcript renders once without changing bytes, geometry or primary scroll", (t) => {
+	const current = nativeSidebarFixture();
+	const legacy = nativeSidebarFixture(true);
+	t.after(current.dispose);
+	t.after(legacy.dispose);
+	for (const grow of [false, true]) {
+		if (grow) { current.growEditor(); legacy.growEditor(); }
+		for (const [width, height] of [[180, 30], [140, 18], [220, 50]]) {
+			const actual = current.frame(width, height);
+			const expected = legacy.frame(width, height);
+			assert.equal(actual.transcriptRenders, 1, "measurement must not render the native transcript");
+			assert.equal(expected.transcriptRenders, 2, "legacy control must reproduce the redundant render");
+			assert.deepEqual(actual.frame.lines, expected.frame.lines);
+			assert.deepEqual(layoutGeometry(actual.frame.root), layoutGeometry(expected.frame.root));
+			assert.equal(actual.frame.primaryScrollView, current.primary);
+			assert.equal(current.root.render, current.originalRender, "native root rendering is not patched");
+			assert.ok(actual.frame.lines.some(line => line.includes(CURSOR_MARKER)), "editor cursor remains visible");
+		}
+	}
+});
+
+test("native transcript and sidebar keep separate scroll routing across resize, breakpoint and mode transitions", (t) => {
+	const fixture = nativeSidebarFixture();
+	t.after(fixture.dispose);
+	let result = fixture.frame();
+	const rail = result.frame.root.children[1].component as ScrollView;
+	assert.equal(getScrollViewsAt(result.frame, 1, 1)[0], fixture.primary);
+	assert.equal(getScrollViewsAt(result.frame, 179, 1)[0], rail);
+	const transcriptTop = fixture.primary.scrollTop;
+	rail.scrollBy(5);
+	result = fixture.frame();
+	assert.equal(fixture.primary.scrollTop, transcriptTop);
+	assert.equal(rail.scrollTop, 5);
+	fixture.primary.scrollBy(-7);
+	result = fixture.frame();
+	assert.equal(fixture.primary.scrollTop, transcriptTop - 7);
+	assert.equal(rail.scrollTop, 5);
+	assert.equal(result.transcriptRenders, 1);
+	for (const [mode, width] of [["fullscreen", 139], ["fullscreen", 140], ["regular", 180], ["fullscreen", 180]] as const) {
+		fixture.host.mode = mode;
+		result = fixture.frame(width);
+		assert.equal(result.transcriptRenders, 1);
+		assert.equal(result.frame.primaryScrollView, fixture.primary);
+		assert.equal(result.frame.root.children.some(box => box.component === rail), mode === "fullscreen" && width >= 140);
+	}
+});

package/tests/startup-banner.test.ts

@@ -2,11 +2,63 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import { syncBuiltinESMExports } from "node:module";
 import fs from "node:fs/promises";
+import { readFileSync } from "node:fs";
 import startup, { readGitBranch } from "../extensions/startup-banner.ts";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { visibleWidth } from "@earendil-works/pi-tui";
 import { stripAnsi } from "../lib/terminal-theme.ts";
 
+test("startup artwork spells Gentle Shell with aligned animation spans", () => {
+	const source = readFileSync(new URL("../extensions/startup-banner.ts", import.meta.url), "utf8");
+	const logo = JSON.parse(source.match(/const TEXT_LOGO = (\[[\s\S]*?\]);/)![1].replace(/,\s*]/, "]")) as string[];
+	const weights = JSON.parse(source.match(/const LETTER_WEIGHTS = (\[[^;]+\]);/)![1]) as number[];
+	// Preserve the original script, including its descending G and dark shadow.
+	const gentle = [
+		"                  ▄▄▄▀▀▀▀▀██                                ▄▄▀▄▄",
+		"              ▄▄█▀▀▒▒▒▒▒▄▄█▀▒                   ▄██     ▄▄█▀█▄█▀▒▒",
+		"          ▄▄██▀▒▒▒▒▒▄▄▄▀▀▒▒▒▒        ▄▄▄  ▀▀▀▀██▀▀▀▀▀███▀█▄▀▀▒▒▒▒",
+		"        ▄██▀▒▒▒▒     ▒▒▄▄█ ▄▄▄▀██ ▄▄▄▀▀▀▄  ▄██▀▒▒▒▒▄██▀▀▀▒▄▄███",
+		"       ██▀▒▒▒     ▄▄▄███▀▄██▀▀▀▄▄██▀▀▄█▀▄▄██▀▒▒▒▄▄██▀▒▒▄██▀▀▀▄▄",
+		"       ▀█▄▄▄▄▄▀▀▀█▄▄███▄▒▀▀▀▀▀▀▒▀▀▒▒▀▀▀▀▒██▄▄▀▀▀ ▀█▄▀▀▀ ▀▀▀▀▀▒▒",
+		"        ▒▄▄▄█▀▀▀█▄█▀▀▒▒▒▒ ▒▒▒▒▒▒ ▒▒  ▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒ ▒▒▒▒▒",
+		"     ▄▄▀▀ ▒▒▒▒▄██▀▒▒▒▒",
+		"   ▄█ ▒▒▒▄▄██▀▀▒▒▒▒",
+		"    ▀▀▀▀▀▀▒▒▒▒▒▒",
+		"     ▒▒▒▒▒▒",
+	];
+	assert.equal(logo.length, 11, "retain the full-height script silhouette");
+	for (const [row, prefix] of gentle.entries()) {
+		assert.ok(logo[row].startsWith(prefix), `original Gentle script row ${row}`);
+		assert.ok(logo[row].includes("▒") || row === 0, "retain dark shadow");
+	}
+	assert.equal(weights.length, 11, "one variable-width span per GENTLESHELL letter");
+	assert.ok(new Set(weights).size > 2, "script spans must not use fixed block-font widths");
+	assert.ok(logo.slice(0, 7).every((line) => /[▄▀█]/.test(line.slice(68))), "Shell has tall slanted strokes");
+	assert.ok(logo.slice(1, 7).every((line) => /▒/.test(line.slice(68))), "Shell retains the dark shadow");
+	const shell = logo.map((line) => line.slice(68));
+	assert.match(shell[0], /▄▄█▀▀▀██/, "S has its upper bowl");
+	assert.match(shell[3], /▀▀▀██▄▄/, "S curves into its lower bowl");
+	assert.match(shell[5], /▀█▄▄▄▄█▀▀▒▒/, "S closes with a shadowed exit stroke");
+	assert.match(shell[4], /▄██▀▄██▀██▒/, "h has a rising stem and connected arch");
+	assert.deepEqual(logo.slice(3, 6).map((line) => line.slice(93, 101)), [
+		" ▄▄▀▀██ ",
+		"▄██▄▄▀▒ ",
+		"▀█▄▄▄▄▀▀",
+	], "e has an upper loop/counter, a crossbar, and a curved lower exit rather than a wedge");
+	assert.equal(logo[3][100], " ", "e loop stays distinct from the following l");
+	assert.equal(logo[4][100], " ", "e counter opens before the l stem without moving it");
+	assert.equal(shell[0].split("▄▄▀▄▄").length - 1, 2, "both l ascenders retain looped tops");
+	assert.match(shell[5], /█▄▄▀▀▀▄▄▀█▄▄▀▀▀$/, "both l exits connect with an ascending script stroke");
+	assert.equal(Math.max(...logo.map((line) => line.length)), 120, "connected script retains glyph scale while tightening letter placement");
+	// Like Gentle, adjacent baseline strokes must meet, not merely have smaller gaps.
+	assert.match(shell[4], /▀██▄▄██▀▄██▀██▒/, "S exit meets the h entry");
+	assert.match(shell[5], /▀█▄▄▄▄▀▀█▄▄▀▀▀/, "e lower exit still meets the unchanged l stem");
+	assert.match(shell[5], /██▄▄▀▀█▄▄▄▄▀▀/, "h exit remains connected to e");
+	assert.deepEqual(weights, [22, 9, 8, 9, 8, 9, 10, 13, 8, 8, 13]);
+	assert.equal(weights.reduce((sum, width) => sum + width, 0), Math.max(...logo.map((line) => line.length)) - 3,
+		"span widths exactly cover the ink bounds from the G descender to the final l shadow");
+});
+
 test("startup branch lookup uses direct git argv and hides its Windows child", async () => {
 	const calls: Array<{ command: string; args: readonly string[]; options: Record<string, unknown> }> = [];
 	const run = ((command: string, args: readonly string[], options: Record<string, unknown>, callback: (error: Error | null, stdout: string) => void) => {
@@ -46,6 +98,7 @@ test("startup banner keeps animating after invalidate and cleans up on dispose",
 		header = factory({ requestRender() { renders++; } }, { fg: (_role: string, text: string) => text });
 	} } });
 	t.mock.timers.tick(50);
+	assert.match(header!.render(200).join("\n"), /\x1b\[38;2;95;30;60m▒/, "script shadow keeps the dark pink palette");
 	const afterBoot = renders;
 	t.mock.timers.tick(25);
 	assert.ok(renders > afterBoot, "animation timer requests renders");
@@ -91,13 +144,13 @@ for (const showRose of [false, true]) for (const showTextLogo of [false, true])
 		} } });
 		t.mock.timers.tick(50);
 		try {
-			for (const width of [40, 80, 160]) {
+			for (const width of [40, 80, 160, 200]) {
 				const lines = header!.render(width);
 				assert.ok(lines.every((line) => visibleWidth(line) <= width));
 				const text = stripAnsi(lines.join("\n"));
 				assert.match(text, /GIT:/);
 				assert.match(text, /PATH:/);
-				if (width === 160) {
+				if (width >= 160) {
 					assert.equal(/[\u2800-\u28ff]/.test(text), showRose);
 					assert.equal(/[▒▄▀█]/.test(text), showTextLogo);
 				}