gentle-pi 2.6.4 → 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

@@ -0,0 +1,86 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+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, 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-")));
+	const handlers = new Map<string, Function>();
+	const entries: any[] = [];
+	const listeners = new Map<string, Function>();
+	const pi = { on: (key, fn) => handlers.set(key, fn), appendEntry: (customType, data) => entries.push({type:"custom",customType,data}),
+		events: { on: (key, fn) => { listeners.set(key, fn); return () => listeners.delete(key); }, emit: (key, data) => listeners.get(key)?.(data) } };
+	let id = "session";
+	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, pi, switchSession: () => id = "other"}); }
+	finally { await rm(root, {recursive:true,force:true}); }
+}
+
+test("capture reads no inventory at startup and ignores read-only tools", async () => fixture(async ({fire, entries}) => {
+	await fire("tool_call", {toolCallId:"r",toolName:"read",input:{path:"missing"}});
+	await fire("tool_result", {toolCallId:"r",toolName:"read",input:{path:"missing"},isError:false});
+	await fire("tool_execution_end", {toolCallId:"r",toolName:"read",isError:false});
+	assert.deepEqual(entries, []);
+}));
+
+test("successful writes capture only the exact tool target and persist for reload", async () => fixture(async ({root,fire,entries}) => {
+	await writeFile(join(root,"file"),"human baseline\n");
+	const event = {toolCallId:"w",toolName:"write",input:{path:"file",content:"agent output\n"}};
+	await fire("tool_call",event);
+	await writeFile(join(root,"file"),event.input.content);
+	await fire("tool_result",{...event,isError:false});
+	assert.equal(entries.length,0);
+	await fire("tool_execution_end",{toolCallId:"w",toolName:"write",isError:false});
+	assert.equal(entries[0].customType,SESSION_CHANGE_ENTRY);
+	await writeFile(join(root,"file"),"later human output\n");
+	const changes = new SessionChanges("session",entries);
+	assert.match(changes.loadDiff(root,changes.model.files[0]),/\+agent output/);
+	assert.doesNotMatch(changes.loadDiff(root,changes.model.files[0]),/later human/);
+}));
+
+test("failed and stale-session tool outcomes never add session changes", async () => fixture(async ({root,fire,entries,switchSession}) => {
+	const event={toolCallId:"w",toolName:"write",input:{path:"new",content:"agent\n"}};
+	await fire("tool_call",event);
+	await writeFile(join(root,"new"),event.input.content);
+	await fire("tool_result",{...event,isError:false});
+	await fire("tool_execution_end",{toolCallId:"w",toolName:"write",isError:true});
+	assert.equal(entries.length,0);
+	await fire("tool_call",{...event,toolCallId:"x"});
+	switchSession();
+	await fire("tool_result",{...event,toolCallId:"x",isError:false});
+	await fire("tool_execution_end",{toolCallId:"x",toolName:"write",isError:false});
+	assert.equal(entries.length,0);
+}));
+
+test("child carries bounded evidence in the existing tool-result details transport", async () => fixture(async ({root,fire,entries}) => {
+	const event={toolCallId:"w",toolName:"write",input:{path:"new",content:"agent\n"}};
+	await fire("tool_call",event); await writeFile(join(root,"new"),event.input.content);
+	const result=await fire("tool_result",{...event,isError:false,details:{original:"preserved"}});
+	assert.equal(result.details.original,"preserved");
+	assert.equal(result.details.gentleSessionChange.id,"w");
+	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-shell.test.ts

@@ -0,0 +1,38 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import shell from "../extensions/gentle-shell.ts";
+import { SESSION_CHANGE_ENTRY, SESSION_CHANGE_EVENT } from "../lib/session-changes.ts";
+
+function fixture(entries: any[] = []) {
+	const handlers = new Map<string, Function[]>(), listeners = new Map<string, Function[]>();
+	const commands = new Map<string, any>(), widgets = new Map<string, any>();
+	let gitCalls = 0;
+	const pi: any = { on: (key, fn) => handlers.set(key, [...(handlers.get(key) ?? []), fn]),
+		events: { on: (key, fn) => { listeners.set(key,[...(listeners.get(key) ?? []), fn]); return () => {}; }, emit: (key,data) => listeners.get(key)?.forEach(fn=>fn(data)) },
+		appendEntry: (customType,data) => entries.push({type:"custom",customType,data}), registerTool() {}, registerShortcut() {}, registerMessageRenderer() {},
+		registerCommand: (key, registration) => commands.set(key,registration) };
+	const notices: string[] = [];
+	const ctx: any = { hasUI:true, cwd:"/repo", sessionManager:{getSessionId:()=>"session",getEntries:()=>entries},
+		ui: { setFooter() {}, getEditorComponent:()=>({}), setWorkingVisible() {}, setWidget:(key,value)=>widgets.set(key,value), notify:(text)=>notices.push(text) } };
+	shell(pi,{}, {resolveWorktree:()=>({root:"/repo",commonDir:"/git"}),devBinary:()=>undefined,
+		gitRunner:()=>async()=>{gitCalls++; return await new Promise<any>(()=>{});} });
+	const fire=async(key,event={})=>{for(const fn of handlers.get(key)??[]) await fn(event,ctx);};
+	return {pi,ctx,entries,notices,commands,widgets,fire,gitCalls:()=>gitCalls};
+}
+test("Gentle Shell startup never waits for a repository scan",async()=>{
+	const f=fixture();
+	await Promise.race([f.fire("session_start"),new Promise((_,reject)=>setTimeout(()=>reject(new Error("startup blocked by Git inventory")),100))]);
+	assert.equal(f.gitCalls(),0);
+	await f.commands.get("gentle:changes").handler("",f.ctx);
+	assert.match(f.notices.join("\n"),/captured.*agent|agent.*changes/i);
+	await f.fire("session_shutdown");
+});
+test("reload and new evidence refresh Changes without Git or live file reads",async()=>{
+	const f=fixture([{type:"custom",customType:SESSION_CHANGE_ENTRY,data:{sessionId:"session",evidence:{id:"child:1",root:"/repo",path:"own.ts",before:{kind:"absent"},after:{kind:"text",text:"own\n"}}}}]);
+	await Promise.race([f.fire("session_start"),new Promise((_,reject)=>setTimeout(()=>reject(new Error("startup blocked")),100))]);
+	f.pi.events.emit(SESSION_CHANGE_EVENT,{sessionId:"session"});
+	await new Promise(resolve=>setImmediate(resolve));
+	assert.equal(f.gitCalls(),0);
+	assert.equal(typeof f.widgets.get("gentle-shell-changes"),"function");
+	await f.fire("session_shutdown");
+});

package/tests/session-changes.test.ts

@@ -0,0 +1,114 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { mkdtemp, writeFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { SessionChanges, readChangeSnapshot, SESSION_CHANGE_ENTRY, MAX_CHANGE_BYTES } from "../lib/session-changes.ts";
+
+const text = (text: string) => ({ kind: "text" as const, text });
+const absent = { kind: "absent" as const };
+const evidence = (id = "a", root = "/repo", path = "file.ts", before = text("old\n"), after = text("new\n")) => ({ id, root, path, before, after });
+
+test("session changes starts empty without reading the worktree or its untracked contents", async () => {
+	const changes = new SessionChanges("session");
+	assert.deepEqual(await changes.refresh(), { files: [], added: 0, deleted: 0 });
+	assert.deepEqual(changes.worktrees, []);
+});
+
+test("only attributed changes appear, against the pre-tool content rather than HEAD", () => {
+	const changes = new SessionChanges("session");
+	changes.record(evidence("a", "/repo", "file.ts", text("preexisting human edit\nold\n"), text("preexisting human edit\nnew\n")));
+	assert.equal(changes.model.files.length, 1);
+	assert.equal(changes.model.added, 1);
+	assert.equal(changes.model.deleted, 1);
+	assert.match(changes.loadDiff("/repo", changes.model.files[0]), /\+new/);
+	assert.doesNotMatch(changes.loadDiff("/repo", changes.model.files[0]), /\+preexisting/);
+});
+
+test("diff counts include content lines that resemble patch headers", () => {
+	const changes = new SessionChanges("session");
+	changes.record(evidence("headers", "/repo", "patch.txt", text("-- old content\n"), text("++ new content\n")));
+	assert.equal(changes.model.added, 1);
+	assert.equal(changes.model.deleted, 1);
+});
+
+test("contiguous own edits combine and own reverts remove the file and worktree", () => {
+	const changes = new SessionChanges("session");
+	changes.record(evidence());
+	changes.record(evidence("b", "/repo", "file.ts", text("new\n"), text("final\n")));
+	assert.equal(changes.model.added, 1);
+	assert.match(changes.loadDiff("/repo", changes.model.files[0]), /\+final/);
+	changes.record(evidence("c", "/repo", "file.ts", text("final\n"), text("old\n")));
+	assert.deepEqual(changes.worktrees, []);
+});
+
+test("external edits between agent operations are not folded into an attributed diff", () => {
+	const changes = new SessionChanges("session");
+	changes.record(evidence());
+	changes.record(evidence("b", "/repo", "file.ts", text("external\n"), text("agent again\n")));
+	const file = changes.model.files[0];
+	assert.match(file.countsUnavailable!, /external|continuity/i);
+	assert.doesNotMatch(changes.loadDiff("/repo", file), /\+external|\-external/);
+});
+
+test("new files and child worktrees are admitted only by positive mutation evidence", () => {
+	const changes = new SessionChanges("session");
+	changes.record({ ...evidence("child:1", "/linked", "new.ts"), before: absent });
+	assert.deepEqual(changes.worktrees.map(tree => tree.root), ["/linked"]);
+	assert.equal(changes.model.files[0].status, "added");
+});
+
+test("reload restores only the exact session and deduplicates operation identities", () => {
+	const row = { type: "custom", customType: SESSION_CHANGE_ENTRY, data: { sessionId: "session", evidence: evidence() } };
+	const changes = new SessionChanges("session", [row, row, { ...row, data: { sessionId: "other", evidence: evidence("b", "/other") } }]);
+	assert.equal(changes.model.files.length, 1);
+	changes.record(evidence());
+	assert.equal(changes.model.added, 1);
+});
+
+test("oversized, binary, nonregular and missing snapshots are bounded and explicit", async () => {
+	const dir = await mkdtemp(join(tmpdir(), "session-changes-"));
+	try {
+		await writeFile(join(dir, "large"), Buffer.alloc(MAX_CHANGE_BYTES + 1, 65));
+		await writeFile(join(dir, "binary"), Buffer.from([65, 0, 66]));
+		assert.equal((await readChangeSnapshot(join(dir, "large"))).kind, "unavailable");
+		assert.equal((await readChangeSnapshot(join(dir, "binary"))).kind, "unavailable");
+		assert.equal((await readChangeSnapshot(dir)).kind, "unavailable");
+		assert.deepEqual(await readChangeSnapshot(join(dir, "missing")), absent);
+	} finally { await rm(dir, { recursive: true, force: true }); }
+});
+
+test("bounded captures mark partial counts, including the narrow widget", async () => {
+	const { renderChangesWidget } = await import("../lib/shell-changes.ts");
+	const changes = new SessionChanges("session");
+	changes.record({ ...evidence("large", "/repo", "a-very-long-path-that-does-not-fit-in-the-widget.bin"), before: {kind:"unavailable",reason:"Binary file"}, after:{kind:"unavailable",reason:"Binary file"} });
+	assert.match(renderChangesWidget(changes.model,{fg:(_color,text)=>text},75).join("\n"),/partial counts/);
+});
+
+test("same-count edits change preview revisions and malformed evidence is rejected", () => {
+	const changes = new SessionChanges("session");
+	changes.record(evidence());
+	const first = changes.model.files[0].diffRevision;
+	changes.record(evidence("b","/repo","file.ts",text("new\n"),text("other\n")));
+	assert.notEqual(changes.model.files[0].diffRevision,first);
+	assert.equal(changes.record({...evidence("bad"),path:"../escape"}),false);
+	assert.equal(changes.record({...evidence("bad"),path:".git/config"}),false);
+});
+
+test("capture capacity is explicit instead of growing without limit", () => {
+	const changes = new SessionChanges("session");
+	for(let i=0;i<257;i++) changes.record(evidence(String(i),"/repo",String(i)+".ts"));
+	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

@@ -7,6 +7,7 @@ import {
 	gaugeTone,
 	renderGauge,
 	renderShellBar,
+	renderShellSidebarBar,
 	shellEnabled,
 	type ShellBarModel,
 	type ShellBarTheme,
@@ -174,3 +175,37 @@ test("shellEnabled honors GENTLE_PI_SHELL=0", () => {
 	assert.equal(shellEnabled({ GENTLE_PI_SHELL: "0" }), false);
 	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();
+	const active = model({ profile });
+	for (const width of [24, 46]) {
+		const lines = renderShellSidebarBar(active, plainTheme, width);
+		assert.ok(lines.every((line) => visibleWidth(line) <= width));
+		assert.match(lines.join("\n"), /Profile/);
+		assert.ok(lines.join("").replace(/[│\s]/g, "").includes(profile));
+	}
+	assert.deepEqual(renderShellBar(active, plainTheme, 120), renderShellBar(base, plainTheme, 120));
+});

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>✿");
 });