gentle-pi 4.3.0 → 4.4.0

package/tests/gentle-shell-launcher.test.ts

@@ -1890,8 +1890,34 @@ test("quoteForCmdExe leaves a plain token untouched", () => {
 	assert.equal(quoteForCmdExe("pi"), "pi");
 });
 
-test("quoteForCmdExe quotes a token with a space and escapes an inner double quote", () => {
-	assert.equal(quoteForCmdExe('say "hi" now'), '"say \\"hi\\" now"');
+test("quoteForCmdExe quotes a token with a space and the other cmd.exe specials", () => {
+	assert.equal(quoteForCmdExe("say hi now"), '"say hi now"');
+	assert.equal(quoteForCmdExe("a&b"), '"a&b"');
+});
+
+// cmd.exe has no backslash escape: a `"` inside a quoted token ends the
+// quoted section, so everything after it is parsed as command syntax. The
+// simple quoting cannot represent such a token, so it refuses it instead of
+// emitting a command line that lets the argument inject commands.
+test("quoteForCmdExe rejects a token with a double quote", () => {
+	for (const token of ['say "hi" now', 'x" & whoami & rem "', '"', 'a"b']) {
+		assert.throws(() => quoteForCmdExe(token), /double quote/);
+	}
+});
+
+test("planSpawn refuses a win32 .cmd launch whose argument carries a double quote", () => {
+	const hostile = 'x" & whoami & rem "';
+	for (const command of ["C:\\Program Files\\nodejs\\pi.cmd", "C:\\pi\\pi.BAT"]) {
+		assert.throws(() => planSpawn({ command, args: ["--version", hostile], platform: "win32" }), /double quote/);
+	}
+	assert.throws(() => planSpawn({ command: 'C:\\pi\\a"b.cmd', args: [], platform: "win32" }), /double quote/);
+});
+
+test("planSpawn passes a double quote through when no cmd.exe command line is built", () => {
+	const args = ["--prompt", 'say "hi"'];
+	assert.deepEqual(planSpawn({ command: "C:\\pi\\pi.exe", args, platform: "win32" }), { command: "C:\\pi\\pi.exe", args, shell: false });
+	assert.deepEqual(planSpawn({ command: "/usr/bin/pi", args, platform: "linux" }), { command: "/usr/bin/pi", args, shell: false });
+	assert.deepEqual(planSpawn({ command: "/usr/local/bin/pi.cmd", args, platform: "darwin" }), { command: "/usr/local/bin/pi.cmd", args, shell: false });
 });
 
 test("quoteForCmdExe quotes an empty token", () => {

package/tests/gentle-shell-startup-update.test.ts

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import { test } from "node:test";
 import { parseLauncherArgs } from "../lib/gentle-shell-launcher.ts";
-import { findStartupUpdate, shouldCheckStartupUpdate } from "../lib/gentle-shell-startup-update.ts";
+import { findStartupUpdate, parseStartupReleaseCache, shouldCheckStartupUpdate, writeStartupReleaseCache } from "../lib/gentle-shell-startup-update.ts";
 
 const eligible = {
 	args: parseLauncherArgs([]), env: {}, bundled: true, inputTTY: true, outputTTY: true,
@@ -83,3 +83,79 @@ test("custom deadline is bounded and settled lookups clear the timeout", async (
 	t.mock.timers.tick(20);
 	assert.equal(settledSignal?.aborted, false);
 });
+
+// A fresh cache keeps the everyday launch off the network entirely: the offer
+// (or its absence) is decided from the recorded lookup, and the live lookup —
+// whose result is the only thing worth caching — runs only when the cache is
+// stale, missing, or malformed.
+test("a fresh cache decides the offer without touching the network", async () => {
+	const offline = async (): Promise<string> => { throw new Error("lookup must not run on a fresh cache"); };
+	const fresh = { checkedAt: Date.now() - 60 * 60 * 1000, latest: "2.0.0" };
+	assert.deepEqual(await findStartupUpdate({ current: "1.0.0", lookup: offline, cache: fresh, ttlMs: 24 * 60 * 60 * 1000 }), {
+		current: "1.0.0", latest: "2.0.0", notesUrl: "https://github.com/Gentleman-Programming/gentle-shell/releases/tag/v2.0.0",
+	});
+	assert.equal(await findStartupUpdate({ current: "2.0.0", lookup: offline, cache: fresh, ttlMs: 24 * 60 * 60 * 1000 }), undefined);
+});
+
+test("a fresh cache respects the skipped release exactly like a live lookup", async () => {
+	const offline = async (): Promise<string> => { throw new Error("lookup must not run on a fresh cache"); };
+	assert.equal(await findStartupUpdate({ current: "1.0.0", skipped: "2.0.0", lookup: offline, cache: { checkedAt: Date.now() - 1000, latest: "2.0.0" } }), undefined);
+	assert.equal((await findStartupUpdate({ current: "1.0.0", skipped: "2.0.0", lookup: offline, cache: { checkedAt: Date.now() - 1000, latest: "2.0.1" } }))?.latest, "2.0.1");
+});
+
+test("a stale, missing or malformed cache runs the live lookup and records its answer", async () => {
+	const written: string[] = [];
+	const opts = {
+		current: "1.0.0",
+		lookup: async () => "2.0.1",
+		ttlMs: 1000,
+		cacheWrite: (latest: string) => { written.push(latest); },
+	};
+	// Stale beyond the TTL.
+	assert.equal((await findStartupUpdate({ ...opts, cache: { checkedAt: Date.now() - 1001, latest: "2.0.0" } }))?.latest, "2.0.1");
+	// No cache at all.
+	assert.equal((await findStartupUpdate({ ...opts }))?.latest, "2.0.1");
+	// A cache whose latest never parsed: never trusted, refreshed instead.
+	assert.equal((await findStartupUpdate({ ...opts, cache: { checkedAt: Date.now() - 1, latest: "garbage" } }))?.latest, "2.0.1");
+	assert.deepEqual(written, ["2.0.1", "2.0.1", "2.0.1"]);
+});
+
+test("an unanswered lookup is never cached", async () => {
+	const written: string[] = [];
+	assert.equal(await findStartupUpdate({ current: "1.0.0", lookup: async () => undefined, cacheWrite: (latest) => { written.push(latest); } }), undefined);
+	assert.equal(await findStartupUpdate({ current: "1.0.0", lookup: async () => { throw new Error("offline"); }, cacheWrite: (latest) => { written.push(latest); } }), undefined);
+	assert.deepEqual(written, []);
+});
+
+test("the cache ages against the injected clock, not the wall", async () => {
+	const now = 1_700_000_000_000;
+	const offline = async (): Promise<string> => { throw new Error("lookup must not run on a fresh cache"); };
+	// Exactly at the TTL boundary the cache is already stale: the check errs
+	// toward the live lookup, never toward skipping it.
+	assert.equal((await findStartupUpdate({ current: "1.0.0", lookup: async () => "2.0.0", ttlMs: 1000, nowMs: now, cache: { checkedAt: now - 1000, latest: "2.0.0" } }))?.latest, "2.0.0");
+	assert.deepEqual(await findStartupUpdate({ current: "1.0.0", lookup: offline, ttlMs: 1000, nowMs: now - 1, cache: { checkedAt: now - 1000, latest: "2.0.0" } }).then((offer) => offer?.latest), "2.0.0");
+});
+
+test("parseStartupReleaseCache accepts the recorded shape and rejects everything else", () => {
+	assert.deepEqual(parseStartupReleaseCache({ checkedAt: "2026-01-01T00:00:00.000Z", latest: "2.0.1" }), { checkedAt: Date.parse("2026-01-01T00:00:00.000Z"), latest: "2.0.1" });
+	assert.deepEqual(parseStartupReleaseCache({ checkedAt: 1_700_000_000_000, latest: "2.0.1" }), { checkedAt: 1_700_000_000_000, latest: "2.0.1" });
+	for (const bad of [undefined, null, "x", [], {}, { checkedAt: "nope", latest: "2.0.1" }, { checkedAt: 1_700_000_000_000 }, { checkedAt: 1_700_000_000_000, latest: "" }]) {
+		assert.equal(parseStartupReleaseCache(bad), undefined);
+	}
+});
+
+test("writeStartupReleaseCache records one lookup alongside the existing config keys", () => {
+	const stored: string[] = [];
+	const config = JSON.stringify({ skippedStartupRelease: "9.9.9", other: { nested: true } });
+	writeStartupReleaseCache(() => config, (text) => stored.push(text), "2.0.1", 1_700_000_000_000);
+	const saved = JSON.parse(stored[0]);
+	assert.equal(saved.skippedStartupRelease, "9.9.9");
+	assert.deepEqual(saved.other, { nested: true });
+	assert.equal(saved.startupReleaseCheck.latest, "2.0.1");
+	assert.equal(saved.startupReleaseCheck.checkedAt, new Date(1_700_000_000_000).toISOString());
+	// An absent config file starts a minimal one.
+	writeStartupReleaseCache(() => undefined, (text) => stored.push(text), "2.0.1");
+	assert.deepEqual(JSON.parse(stored[1]).startupReleaseCheck.latest, "2.0.1");
+	// An invalid config must fail loudly, never overwrite it silently.
+	assert.throws(() => writeStartupReleaseCache(() => "{ broken", () => {}, "2.0.1"));
+});

package/tests/gentle-shell-uninstall.test.ts

@@ -977,6 +977,65 @@ test("bundled on Windows: the user Path entry goes first, the running node.exe,
 	} finally { w.cleanup(); }
 });
 
+// #2469: a home that self-uninstall keeps must not keep Pi pointed at the npm
+// the uninstall removed: a stale `npmCommand` makes every later `pi install`
+// fail with ENOENT naming the deleted node.exe.
+const bundledNpmCommand = (w: BundledWorld) => [w.node, join(dirname(w.node), "gentle-shell", "npm"), "--update-notifier=false"];
+
+const bundledNpmSettings = (w: BundledWorld, npmCommand: unknown) => `${JSON.stringify({ theme: "dark", npmCommand }, null, "  ")}\n`;
+
+test("bundled: keeping the home removes the npmCommand that names the removed prefix and keeps the rest of settings.json", posixOnly, async () => {
+	const w = bundledWorld();
+	try {
+		const settings = join(w.shared.agent, "settings.json");
+		write(settings, bundledNpmSettings(w, bundledNpmCommand(w)));
+		assert.equal(await w.uninstall(["--yes"]), 0, w.err.join("\n"));
+		assert.deepEqual(JSON.parse(readFileSync(settings, "utf8")), { theme: "dark" });
+		assert.ok(w.out.join("\n").includes(`npmCommand from ${settings}`), w.out.join("\n"));
+	} finally { w.cleanup(); }
+});
+
+test("bundled: keeping the home leaves settings.json alone when npmCommand does not name the prefix", posixOnly, async () => {
+	const w = bundledWorld();
+	try {
+		const settings = join(w.shared.agent, "settings.json");
+		const text = bundledNpmSettings(w, ["/usr/local/bin/node", "--update-notifier=false"]);
+		write(settings, text);
+		assert.equal(await w.uninstall(["--yes"]), 0, w.err.join("\n"));
+		assert.equal(readFileSync(settings, "utf8"), text);
+	} finally { w.cleanup(); }
+});
+
+test("bundled: keeping the home never rewrites a settings.json that is not a JSON object", posixOnly, async () => {
+	const w = bundledWorld();
+	try {
+		const settings = join(w.shared.agent, "settings.json");
+		write(settings, "not json at all\n");
+		assert.equal(await w.uninstall(["--yes"]), 0, w.err.join("\n"));
+		assert.equal(readFileSync(settings, "utf8"), "not json at all\n");
+	} finally { w.cleanup(); }
+});
+
+test("bundled on Windows: keeping the home also removes the npmCommand naming the removed prefix", async () => {
+	const w = bundledWorld({ platform: "win32" });
+	try {
+		const settings = join(w.shared.agent, "settings.json");
+		write(settings, `${JSON.stringify({ npmCommand: bundledNpmCommand(w) }, null, "  ")}\n`);
+		assert.equal(await w.uninstall(["--yes"]), 0, w.err.join("\n"));
+		assert.equal(readFileSync(settings, "utf8"), "{}\n");
+		assert.ok(w.out.join("\n").includes(`npmCommand from ${settings}`), w.out.join("\n"));
+	} finally { w.cleanup(); }
+});
+
+test("bundled: --include-shared removes the home with its settings, so no npmCommand cleanup is needed", posixOnly, async () => {
+	const w = bundledWorld();
+	try {
+		write(join(w.shared.agent, "settings.json"), bundledNpmSettings(w, bundledNpmCommand(w)));
+		assert.equal(await w.uninstall(["--yes", "--include-shared"]), 0, w.err.join("\n"));
+		assert.equal(existsSync(join(w.shared.agent, "settings.json")), false);
+	} finally { w.cleanup(); }
+});
+
 // #2201: the standalone isolated home keeps its config in ~/.gentle-shell/gentle-ai.
 test("Gentle Shell's own config folder next to the isolated home is removed; the shared config home keeps its rule", async () => {
 	const w = world();

package/tests/gentle-shell.test.ts

@@ -4,7 +4,7 @@ import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, realpathSy
 import { createRequire } from "node:module";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import test, { after, afterEach } from "node:test";
+import test, { after, afterEach, type TestContext } from "node:test";
 import { initTheme, type ExtensionAPI, type ExtensionContext, type SlashCommandInfo, type SourceInfo } from "@earendil-works/pi-coding-agent";
 import { CURSOR_MARKER, matchesKey, stripTerminalSequences as stripAnsi, TuiMainScreen, visibleWidth, type TUI, type TuiMouseEvent } from "@earendil-works/pi-tui";
 import installGentleShell, { backgroundChangeRefreshesSettled, buildShellBarModel, createActiveProfileReader, changesShortcut, devBinaryCard, extractQueuedText, fetchCodexUsage, fetchNanUsage, loadFileDiff, shellGitRunner, openInExternalEditor, usageShortcut, GentlePromptEditor } from "../extensions/gentle-shell.ts";
@@ -163,6 +163,9 @@ function fakePi(script: GitScript[] = [{ numstat: "", porcelain: "" }], commands
 			if (args.includes("worktree")) return { stdout: "worktree /repo\0branch refs/heads/main\0\0", stderr: "", code: 0, killed: false };
 			// Roots outside the worktree list read as a detached HEAD.
 			if (args.includes("symbolic-ref")) return { stdout: "", stderr: "", code: 1, killed: false };
+			// The unborn-HEAD ask is cheap metadata, not a scan round: the script
+			// models one numstat+porcelain pair per round, exactly like real Git.
+			if (args.includes("rev-parse")) return { stdout: "", stderr: "", code: 0, killed: false };
 			const isNumstat = args.includes("diff");
 			const step = script[Math.min(isNumstat ? round : round++, script.length - 1)];
 			return { stdout: isNumstat ? step.numstat : step.porcelain, stderr: "", code: 0, killed: false };
@@ -2048,7 +2051,7 @@ test("gentleShell shows working while the agent runs and queued when messages wa
 	const editor = installedPrompt(ctx, ui, handlers);
 
 	for (const handler of handlers.get("agent_start") ?? []) handler({}, ctx);
-	assert.match(stripAnsi(editor.render(60)[0]), /^╭─ ✿ working… ─+╮$/);
+	assert.match(stripAnsi(editor.render(60)[0]), /^╭─ [✿❀❁✾] working… ─+╮$/);
 	pending.value = true;
 	assert.match(stripAnsi(editor.render(60)[0]), /^╭─ [✿❀❁✾] queued ─+╮$/);
 	for (const handler of handlers.get("agent_end") ?? []) handler({}, ctx);
@@ -2821,7 +2824,7 @@ test("vim selector exposes enable, disable and status; status and cancellation d
  } finally { editor.dispose(); }
 });
 
-test("animations command reports without writing and switches the live pulse", async (t) => {
+test("animations command reports without writing and switches the live watchdog", async (t) => {
 	const configHome = scopedDoubleEscCancelConfigHome(t);
 	const delays: number[] = [];
 	let active = 0;
@@ -2839,9 +2842,9 @@ test("animations command reports without writing and switches the live pulse", a
 	assert.match(ui.notices.at(-1)!, /animations: quality/);
 	assert.equal(existsSync(join(configHome, "animations.json")), false);
 	for (const handler of handlers.get("agent_start") ?? []) handler({}, ctx);
-	assert.deepEqual(delays, [2000, 80]);
+	assert.deepEqual(delays, [2000, 1000]);
 	await command.handler("performance", ctx);
-	assert.deepEqual(delays, [2000, 80, 1000]);
+	assert.deepEqual(delays, [2000, 1000, 1000]);
 	assert.equal(active, 2);
 	await command.handler("potato", ctx);
 	assert.equal(active, 1);
@@ -2850,7 +2853,7 @@ test("animations command reports without writing and switches the live pulse", a
 	await command.handler("invalid", ctx);
 	assert.equal(JSON.parse(readFileSync(join(configHome, "animations.json"), "utf8")).policy, "potato");
 	await command.handler("quality", ctx);
-	assert.deepEqual(delays, [2000, 80, 1000, 80]);
+	assert.deepEqual(delays, [2000, 1000, 1000, 1000]);
 	for (const handler of handlers.get("agent_settled") ?? []) handler({}, ctx);
 	assert.equal(active, 1);
 	editor.dispose();
@@ -2939,7 +2942,7 @@ test("animations with no argument opens a selectable menu and applies the chosen
 	assert.equal(existsSync(join(dismissHome, "animations.json")), false);
 });
 
-test("prompt uses the compact banner cadence and releases its unref timer at settlement", async (t) => {
+test("prompt installs the silence watchdog unref'd and releases it at settlement", async (t) => {
 	const configHome = scopedDoubleEscCancelConfigHome(t);
 	writeFileSync(join(configHome, "animations.json"), '{"schema":"gentle-pi.animations/v1","policy":"quality"}');
 	const delays: number[] = [];
@@ -2957,7 +2960,7 @@ test("prompt uses the compact banner cadence and releases its unref timer at set
 	const editor = installedPrompt(ctx, ui, handlers);
 	assert.equal(active, 1);
 	for (const handler of handlers.get("agent_start") ?? []) handler({}, ctx);
-	assert.deepEqual(delays, [2000, 80]);
+	assert.deepEqual(delays, [2000, 1000]);
 	assert.equal(unrefs, 2);
 	for (const handler of handlers.get("agent_settled") ?? []) handler({}, ctx);
 	assert.equal(active, 1);
@@ -2966,6 +2969,109 @@ test("prompt uses the compact banner cadence and releases its unref timer at set
 	assert.equal(active, 0);
 });
 
+// gentle-shell#994: the working animation is render-driven. Frames the host
+// already paints while streaming advance the petal for free; a low-cadence
+// watchdog repaints only silent phases (long tool runs with no output).
+interface RecordedInterval { tick: () => void; delay: number; stopped: boolean }
+
+function recordIntervals(t: TestContext): RecordedInterval[] {
+	const intervals: RecordedInterval[] = [];
+	t.mock.method(globalThis, "setInterval", (tick: () => void, delay: number) => {
+		const timer: RecordedInterval = { tick, delay, stopped: false };
+		intervals.push(timer);
+		return { unref() {}, timer };
+	});
+	t.mock.method(globalThis, "clearInterval", (handle: { timer: RecordedInterval }) => { handle.timer.stopped = true; });
+	return intervals;
+}
+
+function petalGlyphOf(editor: GentlePromptEditor): string {
+	return stripAnsi(editor.render(60)[0]).match(/[✿❀❁✾]/)?.[0] ?? "";
+}
+
+test("streaming frames advance the working petal and the quality watchdog stays silent while renders flow", (t) => {
+	const configHome = scopedDoubleEscCancelConfigHome(t);
+	writeFileSync(join(configHome, "animations.json"), '{"schema":"gentle-pi.animations/v1","policy":"quality"}');
+	const intervals = recordIntervals(t);
+	const renders = t.mock.method(fakeTui, "requestRender", () => {});
+	const { pi, handlers } = fakePi();
+	gentleShell(pi, { GENTLE_PI_CONFIG_HOME: configHome }, { now: () => 1_000_000 });
+	const { ctx, ui } = fakeContext();
+	const editor = installedPrompt(ctx, ui, handlers);
+	for (const handler of handlers.get("agent_start") ?? []) handler({}, ctx);
+	const watchdog = intervals.find((entry) => entry.delay === 1000);
+	assert.ok(watchdog, "working installs the 1000ms silence watchdog");
+	const glyphs = [0, 1, 2, 3].map(() => petalGlyphOf(editor));
+	assert.ok(new Set(glyphs).size > 1, `each streamed frame must advance the petal, got ${glyphs.join("")}`);
+	const before = renders.mock.callCount();
+	watchdog!.tick();
+	assert.equal(renders.mock.callCount(), before, "renders are already flowing, so the watchdog must not force one");
+	editor.dispose();
+	assert.equal(watchdog!.stopped, true);
+});
+
+test("silent working phases repaint only through the 1000ms watchdog window", (t) => {
+	const configHome = scopedDoubleEscCancelConfigHome(t);
+	writeFileSync(join(configHome, "animations.json"), '{"schema":"gentle-pi.animations/v1","policy":"quality"}');
+	const intervals = recordIntervals(t);
+	const renders = t.mock.method(fakeTui, "requestRender", () => {});
+	let clock = 1_000_000;
+	const { pi, handlers } = fakePi();
+	gentleShell(pi, { GENTLE_PI_CONFIG_HOME: configHome }, { now: () => clock });
+	const { ctx, ui } = fakeContext();
+	const editor = installedPrompt(ctx, ui, handlers);
+	for (const handler of handlers.get("agent_start") ?? []) handler({}, ctx);
+	const watchdog = intervals.find((entry) => entry.delay === 1000);
+	assert.ok(watchdog, "working installs the 1000ms silence watchdog");
+	const baseline = petalGlyphOf(editor);
+	const before = renders.mock.callCount();
+	watchdog!.tick();
+	assert.equal(renders.mock.callCount(), before, "no frame painted within the window, but the window has not elapsed yet");
+	clock += 1000;
+	watchdog!.tick();
+	assert.equal(renders.mock.callCount(), before + 1, "silence past the window forces exactly one repaint");
+	assert.notEqual(petalGlyphOf(editor), baseline, "the watchdog advanced the petal tick");
+	const afterForced = renders.mock.callCount();
+	watchdog!.tick();
+	assert.equal(renders.mock.callCount(), afterForced, "the watchdog's own repaint counts as render traffic for the next window");
+	editor.dispose();
+});
+
+test("potato installs no working watchdog and the petal never advances", (t) => {
+	const configHome = scopedDoubleEscCancelConfigHome(t);
+	writeFileSync(join(configHome, "animations.json"), '{"schema":"gentle-pi.animations/v1","policy":"potato"}');
+	const intervals = recordIntervals(t);
+	const { pi, handlers } = fakePi();
+	gentleShell(pi, { GENTLE_PI_CONFIG_HOME: configHome });
+	const { ctx, ui } = fakeContext();
+	const editor = installedPrompt(ctx, ui, handlers);
+	for (const handler of handlers.get("agent_start") ?? []) handler({}, ctx);
+	assert.ok(!intervals.some((entry) => entry.delay !== 2000), "potato must not animate: no watchdog interval at all");
+	const glyphs = [0, 1, 2].map(() => petalGlyphOf(editor));
+	assert.deepEqual(glyphs, ["✿", "✿", "✿"], "potato keeps the petal static");
+	editor.dispose();
+});
+
+test("the working watchdog is cleared on settlement and on dispose", (t) => {
+	const configHome = scopedDoubleEscCancelConfigHome(t);
+	writeFileSync(join(configHome, "animations.json"), '{"schema":"gentle-pi.animations/v1","policy":"quality"}');
+	const intervals = recordIntervals(t);
+	const { pi, handlers } = fakePi();
+	gentleShell(pi, { GENTLE_PI_CONFIG_HOME: configHome });
+	const { ctx, ui } = fakeContext();
+	const editor = installedPrompt(ctx, ui, handlers);
+	for (const handler of handlers.get("agent_start") ?? []) handler({}, ctx);
+	const watchdog = intervals.filter((entry) => entry.delay === 1000).at(-1);
+	assert.ok(watchdog && !watchdog.stopped, "working keeps the watchdog armed");
+	for (const handler of handlers.get("agent_settled") ?? []) handler({}, ctx);
+	assert.equal(watchdog!.stopped, true, "settlement must clear the watchdog");
+	for (const handler of handlers.get("agent_start") ?? []) handler({}, ctx);
+	const rearmWatchdog = intervals.filter((entry) => entry.delay === 1000).at(-1);
+	assert.ok(rearmWatchdog && rearmWatchdog !== watchdog && !rearmWatchdog.stopped, "the next turn re-arms a fresh watchdog");
+	editor.dispose();
+	assert.equal(rearmWatchdog!.stopped, true, "dispose must clear the watchdog");
+});
+
 // ---------------------------------------------------------------------------
 // double-esc-cancel (issue #1163): opt-in, off by default. While the prompt
 // is working and autocomplete is hidden, the first Esc is swallowed and the
@@ -4811,6 +4917,9 @@ test("new sessions do not inherit another session's worktrees", async () => {
  const first=fakeContext();
  await fire(h.handlers,"session_start",first.ctx);
  await h.tools.get("session_worktree_register")!.execute("r",{path:"/linked"},undefined,undefined,first.ctx);
+ // The registration kicks off its own async scan; settle it so its Git calls
+ // cannot land after the next session clears the shared call log.
+ await changesSettled();
  await fire(h.handlers,"session_shutdown",first.ctx);
  const next=fakeContext({entries:[...first.ctx.sessionManager.getEntries()]});
  (next.ctx.sessionManager as any).getSessionId=()=>"new-session";
@@ -6376,3 +6485,69 @@ for (const kind of ["unset", "empty", "bundled"] as const) {
 		assert.equal(read(), "other (repo)", "the pinned profile exists only in that config home's store");
 	});
 }
+
+// gentle-shell#2464: a pasted image is an atomic chip in the draft and a real
+// image attachment on submit, never a temp-file path the model must `read`.
+const CHIP_PNG = new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01]);
+const chipKeybindings = { matches: (data: string, action: string) => action === "app.clipboard.pasteImage" && data === "\x1bv" };
+
+async function pastedChipPrompt(model?: ExtensionContext["model"]) {
+	const { pi, handlers } = fakePi();
+	gentleShell(pi, {}, { readClipboardImage: async () => ({ bytes: CHIP_PNG, mimeType: "image/png" }) });
+	const { ctx, ui } = fakeContext();
+	if (model) (ctx as { model: unknown }).model = model;
+	const editor = installedPrompt(ctx, ui, handlers, chipKeybindings);
+	editor.onPasteImage = () => assert.fail("Pi's path-inserting paste must not run when the clipboard holds an image");
+	editor.setText("what is this?");
+	editor.handleInput("\x1bv");
+	await settle();
+	const input = (text: string, source = "interactive") => handlers.get("input")?.[0]?.({ type: "input", text, source }, ctx);
+	// Pi's real order: the editor empties its draft, then onSubmit hands the
+	// text to session.prompt(), which runs the input handlers.
+	const submit = () => {
+		let sent = "";
+		editor.onSubmit = (text) => { sent = text; };
+		editor.handleInput("\r");
+		return input(sent);
+	};
+	return { editor, ui, input, submit };
+}
+
+test("pasted image chips are submitted as real image attachments (gentle-shell#2464)", async () => {
+	const { editor, ui, input, submit } = await pastedChipPrompt();
+	assert.equal(editor.getText(), "what is this? [Image#1]");
+	const strip = (ui.widgets.get("gentle-shell-image-attachments") as (tui: unknown, theme: unknown) => { render(width: number): string[] })(fakeTui, plainTheme);
+	assert.equal(stripAnsi(strip.render(80)[0] ?? ""), "[Image#1] png · 2×1 · 24 B");
+	assert.deepEqual(submit(), {
+		action: "transform",
+		text: "what is this? [Image#1]",
+		images: [{ type: "image", data: Buffer.from(CHIP_PNG).toString("base64"), mimeType: "image/png" }],
+	});
+	// Sent images are released: recalling the same text later is ordinary text.
+	assert.equal(editor.getText(), "");
+	assert.deepEqual(strip.render(80), []);
+	assert.deepEqual(input("what is this? [Image#1]"), { action: "continue" });
+});
+
+test("a pasted image chip deleted before submit is never sent (gentle-shell#2464)", async () => {
+	const { editor, submit } = await pastedChipPrompt();
+	editor.handleInput("\x7f");
+	assert.equal(editor.getText(), "what is this? ");
+	assert.deepEqual(submit(), { action: "continue" });
+});
+
+test("pasted image chips leave non-interactive input and deleted chips untouched (gentle-shell#2464)", async () => {
+	const { input } = await pastedChipPrompt();
+	assert.deepEqual(input("[Image#1] from an extension", "extension"), { action: "continue" });
+	assert.deepEqual(input("the chip was deleted"), { action: "continue" });
+});
+
+test("pasted image chips warn instead of sending images a text-only model rejects (gentle-shell#2464)", async () => {
+	const { ui, input } = await pastedChipPrompt({ id: "text-only", provider: "acme", input: ["text"] } as unknown as ExtensionContext["model"]);
+	assert.deepEqual(input("what is this? [Image#1]"), {
+		action: "transform",
+		text: "what is this? [Image#1 omitted: the current model does not accept images]",
+		images: [],
+	});
+	assert.ok(ui.notices.some((notice) => /1 pasted image was not sent: the current model does not accept images/.test(notice)));
+});

package/tests/gentle-todo.test.ts

@@ -498,6 +498,17 @@ test("the system prompt carries only a byte-stable todo block; the current list
 	assert.equal(finishedEvent.systemPromptOptions.appendSystemPrompt, emptyEvent.systemPromptOptions.appendSystemPrompt, "finishing the list must not change the system prompt");
 });
 
+// weak-model-economy S1: small tasks skip the todo list (bench C-econ).
+test("the todo block exempts small tasks before the tracking rules", async () => {
+	const { pi, fire } = fakePi();
+	gentleTodo(pi, {});
+	const { ctx } = fakeContext();
+	await fire("session_start", ctx);
+	const event = promptEvent();
+	await fire("before_agent_start", ctx, event);
+	assert.ok(event.systemPromptOptions.appendSystemPrompt.startsWith("## Todo list\nA small task (Task Size) uses no todo list: do it and report. For tracked or multi-step work, keep it current with the `todo` tool: mark a task in_progress before starting it,"));
+});
+
 /**
  * Drives the extension the way Pi's agent loop does (#2195): every model request
  * runs the context handlers over the persisted transcript, and a custom message

package/tests/image-attachments.test.ts

@@ -0,0 +1,119 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { describeAttachment, formatBytes, ImageAttachments, imageToken } from "../lib/image-attachments.ts";
+
+// A 2×1 PNG header: signature, IHDR length/type, width 2, height 1.
+const PNG_2X1 = new Uint8Array([
+	0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
+	0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
+	0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+	0x08, 0x06, 0x00, 0x00, 0x00,
+]);
+const png = () => ({ bytes: PNG_2X1, mimeType: "image/png" });
+const base64 = Buffer.from(PNG_2X1).toString("base64");
+
+const graphemes = (text: string) => [...new Intl.Segmenter(undefined, { granularity: "grapheme" }).segment(text)];
+
+test("pasted images get sequential whitespace-free chips and keep one in-memory copy", () => {
+	const attachments = new ImageAttachments();
+	const first = attachments.add(png());
+	const second = attachments.add(png());
+	assert.equal(first.token, "[Image#1]");
+	assert.equal(second.token, imageToken(2));
+	assert.doesNotMatch(first.token, /\s/);
+	assert.deepEqual(first.dimensions, { widthPx: 2, heightPx: 1 });
+	assert.equal(first.base64, base64);
+	assert.equal(first.byteLength, PNG_2X1.length);
+	assert.equal("bytes" in first, false);
+	assert.equal(attachments.size, 2);
+});
+
+test("referenced chips follow draft order, appear once, and ignore unregistered tokens", () => {
+	const attachments = new ImageAttachments();
+	attachments.add(png());
+	attachments.add(png());
+	const ids = attachments.referenced("see [Image#2] then [Image#9] and [Image#1] [Image#2]").map((attachment) => attachment.id);
+	assert.deepEqual(ids, [2, 1]);
+	assert.deepEqual(attachments.referenced("the chip was deleted"), []);
+});
+
+test("submitting a draft attaches every chip still in the text as a real image", () => {
+	const attachments = new ImageAttachments();
+	attachments.add(png());
+	attachments.add(png());
+	const submitted = attachments.submit("what changed in [Image#2]?", true);
+	assert.deepEqual(submitted, {
+		text: "what changed in [Image#2]?",
+		images: [{ type: "image", data: base64, mimeType: "image/png" }],
+		omitted: 0,
+	});
+	// The deleted chip (#1) was never sent; both are released once the editor is empty.
+	assert.equal(attachments.size, 0);
+});
+
+test("numbers never repeat, so a chip recalled from history cannot bind to a newer image", () => {
+	const attachments = new ImageAttachments();
+	attachments.add(png());
+	attachments.submit("describe [Image#1]", true);
+	const next = attachments.add(png());
+	assert.equal(next.token, "[Image#2]");
+	// Up-arrow recall of the earlier prompt: its chip is no longer registered.
+	assert.deepEqual(attachments.referenced("describe [Image#1]"), []);
+	assert.deepEqual(attachments.spans("describe [Image#1]"), []);
+	attachments.clear();
+	assert.equal(attachments.add(png()).token, "[Image#3]");
+});
+
+test("a submit Pi runs late keeps the chips of the draft already in the editor", () => {
+	const attachments = new ImageAttachments();
+	attachments.add(png());
+	attachments.add(png());
+	attachments.add(png());
+	// Queued during compaction: `[Image#1]` is sent after `[Image#2]` was pasted
+	// into a new draft; `[Image#3]` was pasted and deleted again.
+	const submitted = attachments.submit("look [Image#1]", true, "and now [Image#2]");
+	assert.equal(submitted?.images.length, 1);
+	assert.deepEqual(attachments.referenced("and now [Image#2]").map((attachment) => attachment.id), [2]);
+	assert.equal(attachments.size, 1);
+	assert.equal(attachments.submit("and now [Image#2]", true)?.images.length, 1);
+	assert.equal(attachments.size, 0);
+});
+
+test("a model without image input gets a plain note instead of a silent drop", () => {
+	const attachments = new ImageAttachments();
+	attachments.add(png());
+	const submitted = attachments.submit("look at [Image#1] and [Image#4]", false);
+	assert.deepEqual(submitted, {
+		text: "look at [Image#1 omitted: the current model does not accept images] and [Image#4]",
+		images: [],
+		omitted: 1,
+	});
+});
+
+test("drafts without registered chips pass through untouched and release stale images", () => {
+	const attachments = new ImageAttachments();
+	assert.equal(attachments.submit("plain [Image#1] text", true), undefined);
+	attachments.add(png());
+	assert.equal(attachments.submit("chip deleted before submit", true), undefined);
+	assert.equal(attachments.size, 0);
+});
+
+test("a registered chip is one segment, so one Backspace removes it", () => {
+	const attachments = new ImageAttachments();
+	const text = "a [Image#1] b";
+	// No registered chip yet: the host segmentation is returned as-is.
+	const native = graphemes(text);
+	assert.equal(attachments.segment(text, native), native);
+	attachments.add(png());
+	const merged = [...attachments.segment(text, graphemes(text))].map((segment) => segment.segment);
+	assert.deepEqual(merged, ["a", " ", "[Image#1]", " ", "b"]);
+	assert.deepEqual(attachments.spans(text), [{ start: 2, end: 11 }]);
+	const unregistered = "x [Image#7]";
+	assert.equal([...attachments.segment(unregistered, graphemes(unregistered))].length, unregistered.length);
+});
+
+test("chip descriptions name format, pixel size and weight", () => {
+	assert.equal(describeAttachment({ mimeType: "image/png", byteLength: 86_016, dimensions: { widthPx: 1280, heightPx: 720 } }), "png · 1280×720 · 84 KB");
+	assert.equal(describeAttachment({ mimeType: "image/jpeg", byteLength: 512 }), "jpg · 512 B");
+	assert.equal(formatBytes(3 * 1024 * 1024), "3.0 MB");
+});