@dungle-scrubs/tallow 0.8.28 → 0.9.0

package/node_modules/@mariozechner/pi-tui/src/tui.ts

@@ -283,6 +283,19 @@ export class TUI extends Container {
 		this.clearOnShrink = enabled;
 	}
 
+	/**
+	 * Reset the startup grace period timer, suppressing screen-clearing full
+	 * redraws for another {@link STARTUP_GRACE_MS} milliseconds.
+	 *
+	 * Call this at the start of a session switch so the chatContainer.clear()
+	 * → renderInitialMessages() transition doesn't cause visible flicker.
+	 *
+	 * @returns {void}
+	 */
+	resetRenderGrace(): void {
+		this.startedAtMs = Date.now();
+	}
+
 	/**
 	 * Request that the next full render clears the terminal scrollback buffer.
 	 *
@@ -403,8 +416,25 @@ export class TUI extends Container {
 		for (const overlay of this.overlayStack) overlay.component.invalidate?.();
 	}
 
+	/**
+	 * Timestamp when `start()` was called.
+	 * Used by startup grace period to suppress screen-clearing full redraws.
+	 */
+	private startedAtMs = 0;
+
+	/**
+	 * Duration (ms) after `start()` during which shrink-triggered full redraws
+	 * use a gentler line-by-line overwrite instead of screen clear.
+	 *
+	 * This prevents the visual flicker that occurs when session resume causes
+	 * rapid content height changes (extension hooks, widget adds/removes) before
+	 * the full message history is rendered.
+	 */
+	private static readonly STARTUP_GRACE_MS = 3000;
+
 	start(): void {
 		this.stopped = false;
+		this.startedAtMs = Date.now();
 		this.terminal.start(
 			(data) => this.handleInput(data),
 			() => this.requestRender()
@@ -454,6 +484,45 @@ export class TUI extends Container {
 		this.terminal.stop();
 	}
 
+	/** When >0, scheduled renders are deferred until the batch completes. */
+	private renderBatchDepth = 0;
+
+	/** Whether a render was requested while batching was active. */
+	private renderDeferredDuringBatch = false;
+
+	/** Whether a forced render was requested while batching was active. */
+	private renderForceDeferredDuringBatch = false;
+
+	/**
+	 * Begin a render batch — all `requestRender()` calls are coalesced and
+	 * deferred until the matching `endRenderBatch()`. Nestable.
+	 *
+	 * Use to prevent intermediate renders (and the screen clears they cause)
+	 * during multi-step UI mutations such as session resume.
+	 *
+	 * @returns {void}
+	 */
+	beginRenderBatch(): void {
+		this.renderBatchDepth++;
+	}
+
+	/**
+	 * End a render batch. When the outermost batch ends, a single render is
+	 * scheduled if any were deferred.
+	 *
+	 * @returns {void}
+	 */
+	endRenderBatch(): void {
+		if (this.renderBatchDepth <= 0) return;
+		this.renderBatchDepth--;
+		if (this.renderBatchDepth === 0 && this.renderDeferredDuringBatch) {
+			const wasForce = this.renderForceDeferredDuringBatch;
+			this.renderDeferredDuringBatch = false;
+			this.renderForceDeferredDuringBatch = false;
+			this.requestRender(wasForce);
+		}
+	}
+
 	requestRender(force = false): void {
 		if (force) {
 			this.previousLines = [];
@@ -464,6 +533,11 @@ export class TUI extends Container {
 			this.previousViewportTop = 0;
 			this.rollingShrinkPeak = 0;
 		}
+		if (this.renderBatchDepth > 0) {
+			this.renderDeferredDuringBatch = true;
+			if (force) this.renderForceDeferredDuringBatch = true;
+			return;
+		}
 		if (this.renderRequested) return;
 		this.scheduleRender();
 	}
@@ -1004,6 +1078,11 @@ export class TUI extends Container {
 		// Width changed - need full re-render (line wrapping changes)
 		const widthChanged = this.previousWidth !== 0 && this.previousWidth !== width;
 
+		// Whether we are within the startup grace period where screen-clearing
+		// full redraws are softened to prevent flicker during session resume.
+		const inStartupGrace =
+			this.startedAtMs > 0 && Date.now() - this.startedAtMs < TUI.STARTUP_GRACE_MS;
+
 		// Helper to clear viewport (and optionally scrollback) and render all new lines
 		const fullRender = (clear: boolean): void => {
 			this.fullRedrawCount += 1;
@@ -1035,6 +1114,44 @@ export class TUI extends Container {
 			this.previousWidth = width;
 		};
 
+		/**
+		 * Gentle full redraw: home cursor + overwrite each line + clear below.
+		 *
+		 * Used during the startup grace period instead of fullRender(true) for
+		 * shrink-triggered redraws. Avoids the visible blank frame caused by
+		 * `\x1b[2J` (clear screen), which makes messages appear to flash in and
+		 * out when session resume triggers rapid content height changes.
+		 *
+		 * Unlike fullRender(true), this never clears the screen — it writes each
+		 * line with a preceding `\x1b[2K` (clear line) so stale content is
+		 * overwritten without a blank frame. Lines below the new content are
+		 * individually erased.
+		 */
+		const gentleFullRender = (): void => {
+			this.fullRedrawCount += 1;
+			let buffer = "\x1b[?2026h\x1b[H"; // Begin synchronized output + home cursor
+			for (let i = 0; i < newLines.length; i++) {
+				buffer += "\x1b[2K"; // Clear current line
+				buffer += newLines[i];
+				if (i < newLines.length - 1) buffer += "\r\n";
+			}
+			// Erase lines that were previously rendered but are no longer needed
+			const staleLines = Math.max(0, this.maxLinesRendered - newLines.length);
+			for (let i = 0; i < staleLines; i++) {
+				buffer += "\r\n\x1b[2K";
+			}
+			buffer += "\x1b[?2026l"; // End synchronized output
+			this.terminal.write(buffer);
+			this.cursorRow = Math.max(0, newLines.length + staleLines - 1);
+			this.hardwareCursorRow = this.cursorRow;
+			this.maxLinesRendered = newLines.length;
+			this.previousViewportTop = Math.max(0, this.maxLinesRendered - height);
+			this.rollingShrinkPeak = newLines.length;
+			this.positionHardwareCursor(cursorPos, newLines.length);
+			this.previousLines = newLines;
+			this.previousWidth = width;
+		};
+
 		const debugRedraw = process.env.PI_DEBUG_REDRAW === "1";
 		const logRedraw = (reason: string): void => {
 			if (!debugRedraw) return;
@@ -1066,7 +1183,11 @@ export class TUI extends Container {
 			this.overlayStack.length === 0
 		) {
 			logRedraw(`clearOnShrink (maxLinesRendered=${this.maxLinesRendered})`);
-			fullRender(true);
+			if (inStartupGrace) {
+				gentleFullRender();
+			} else {
+				fullRender(true);
+			}
 			return;
 		}
 
@@ -1077,7 +1198,11 @@ export class TUI extends Container {
 		const shrinkDelta = this.previousLines.length - newLines.length;
 		if (shrinkDelta > 5 && this.overlayStack.length === 0) {
 			logRedraw(`large shrink (${shrinkDelta} lines)`);
-			fullRender(true);
+			if (inStartupGrace) {
+				gentleFullRender();
+			} else {
+				fullRender(true);
+			}
 			return;
 		}
 
@@ -1092,7 +1217,11 @@ export class TUI extends Container {
 			logRedraw(
 				`rolling shrink (peak=${this.rollingShrinkPeak}, now=${newLines.length}, delta=${this.rollingShrinkPeak - newLines.length})`
 			);
-			fullRender(true);
+			if (inStartupGrace) {
+				gentleFullRender();
+			} else {
+				fullRender(true);
+			}
 			return;
 		}
 
@@ -1167,7 +1296,11 @@ export class TUI extends Container {
 				const extraLines = this.previousLines.length - newLines.length;
 				if (extraLines > height) {
 					logRedraw(`extraLines > height (${extraLines} > ${height})`);
-					fullRender(true);
+					if (inStartupGrace) {
+						gentleFullRender();
+					} else {
+						fullRender(true);
+					}
 					return;
 				}
 				if (extraLines > 0) {
@@ -1195,7 +1328,11 @@ export class TUI extends Container {
 		// If first changed line is above the current viewport basis, partial redraw is unsafe.
 		if (firstChanged < prevViewportTop) {
 			logRedraw(`firstChanged < viewportTop (${firstChanged} < ${prevViewportTop})`);
-			fullRender(true);
+			if (inStartupGrace) {
+				gentleFullRender();
+			} else {
+				fullRender(true);
+			}
 			return;
 		}
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@dungle-scrubs/tallow",
-	"version": "0.8.28",
+	"version": "0.9.0",
 	"description": "An opinionated coding agent. Built on pi.",
 	"piConfig": {
 		"name": "tallow",

package/schemas/settings.schema.json

@@ -429,11 +429,6 @@
 					"default": ["◐", "◓", "◑", "◒"],
 					"minItems": 1
 				},
-				"plan_mode": {
-					"type": "string",
-					"description": "Plan mode indicator (default: '⏸').",
-					"default": "⏸"
-				},
 				"task_list": {
 					"type": "string",
 					"description": "Task list indicator (default: '📋').",

package/extensions/plan-mode-tool/__tests__/e2e.mjs

@@ -1,350 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * E2E test for the plan-mode extension.
- *
- * Proves:
- *   1. plan_mode tool remains available after toggling modes
- *   2. Plan mode enforces a strict read-only allowlist
- *   3. Non-allowlisted extension tools are blocked in plan mode
- *   4. Disabling plan mode restores normal access
- *
- * Uses the SDK to load ONLY the plan-mode extension (isolated).
- * Costs ~$0.01 per run.
- *
- * Usage:
- *   node extensions/plan-mode-tool/__tests__/e2e.mjs
- */
-
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { getModel } from "@mariozechner/pi-ai";
-import {
-	AuthStorage,
-	createAgentSession,
-	DefaultResourceLoader,
-	ModelRegistry,
-	SessionManager,
-	SettingsManager,
-} from "@mariozechner/pi-coding-agent";
-import { Type } from "@sinclair/typebox";
-
-// ── Helpers ──────────────────────────────────────────────────
-
-const results = [];
-
-/**
- * Record a test result.
- * @param {string} name - Test name
- * @param {boolean} passed - Pass/fail
- * @param {string} [detail] - Extra detail on failure
- */
-function check(name, passed, detail) {
-	results.push({ name, passed, detail });
-	const icon = passed ? "\x1b[32m✓\x1b[0m" : "\x1b[31m✗\x1b[0m";
-	let line = `  ${icon} ${name}`;
-	if (!passed && detail) line += `\n    ${detail.slice(0, 300)}`;
-	console.log(line);
-}
-
-/**
- * Get the text content of the most recent tool result for a given tool name.
- * @param {import("@mariozechner/pi-coding-agent").AgentSession} session
- * @param {string} toolName
- * @returns {string}
- */
-function lastToolResultText(session, toolName) {
-	const msgs = session.messages;
-	for (let i = msgs.length - 1; i >= 0; i--) {
-		const m = msgs[i];
-		if (m.role === "toolResult" && m.toolName === toolName) {
-			for (const part of m.content) {
-				if (part.type === "text") return part.text;
-			}
-		}
-	}
-	return "";
-}
-
-/**
- * Check if any tool result in the session contains "not found" error.
- * @param {import("@mariozechner/pi-coding-agent").AgentSession} session
- * @param {string} toolName
- * @returns {boolean}
- */
-function hasToolNotFoundError(session, toolName) {
-	const msgs = session.messages;
-	for (let i = msgs.length - 1; i >= 0; i--) {
-		const m = msgs[i];
-		if (m.role === "toolResult") {
-			for (const part of m.content) {
-				if (part.type === "text" && part.text.includes(`Tool ${toolName} not found`)) {
-					return true;
-				}
-			}
-		}
-	}
-	return false;
-}
-
-/**
- * Check if a tool call was blocked by plan-mode policy.
- * @param {import("@mariozechner/pi-coding-agent").AgentSession} session
- * @param {string} toolName
- * @returns {boolean}
- */
-function hasPlanModeToolBlockedError(session, toolName) {
-	const msgs = session.messages;
-	for (let i = msgs.length - 1; i >= 0; i--) {
-		const m = msgs[i];
-		if (m.role !== "toolResult") continue;
-		for (const part of m.content) {
-			if (part.type === "text" && part.text.includes(`Plan mode: tool "${toolName}" blocked`)) {
-				return true;
-			}
-		}
-	}
-	return false;
-}
-
-// ── Isolated extension loading ───────────────────────────────
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const extensionSrcDir = path.resolve(__dirname, "..");
-
-const testAgentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-e2e-plan-"));
-const extDst = path.join(testAgentDir, "extensions/plan-mode-tool");
-fs.mkdirSync(extDst, { recursive: true });
-for (const file of ["index.ts", "utils.ts"]) {
-	fs.copyFileSync(path.join(extensionSrcDir, file), path.join(extDst, file));
-}
-
-// ── Setup ────────────────────────────────────────────────────
-
-console.log("\n\x1b[1m══ Plan Mode Extension E2E Test ══\x1b[0m\n");
-
-const authStorage = new AuthStorage();
-const modelRegistry = new ModelRegistry(authStorage);
-const model = getModel("anthropic", "claude-haiku-4-5");
-if (!model) {
-	console.error("✗ Model claude-haiku-4-5 not found");
-	process.exit(1);
-}
-
-const settingsManager = SettingsManager.inMemory({ compaction: { enabled: false } });
-
-/**
- * Register mock tools used to validate strict plan-mode allowlisting.
- * @param {import("@mariozechner/pi-coding-agent").ExtensionAPI} pi
- */
-function registerMockTools(pi) {
-	pi.registerTool({
-		name: "bg_bash",
-		label: "bg_bash",
-		description: "Mock background bash tool",
-		parameters: Type.Object({ command: Type.String() }),
-		async execute(_toolCallId, params) {
-			return {
-				content: [{ type: "text", text: `mock-bg-bash-ok:${params.command}` }],
-				details: {},
-			};
-		},
-	});
-
-	pi.registerTool({
-		name: "subagent",
-		label: "subagent",
-		description: "Mock subagent tool",
-		parameters: Type.Object({ task: Type.String() }),
-		async execute(_toolCallId, params) {
-			return {
-				content: [{ type: "text", text: `mock-subagent-ok:${params.task}` }],
-				details: {},
-			};
-		},
-	});
-
-	pi.registerTool({
-		name: "mcp__mock__ping",
-		label: "mcp__mock__ping",
-		description: "Mock MCP-style tool",
-		parameters: Type.Object({}),
-		async execute() {
-			return {
-				content: [{ type: "text", text: "mock-mcp-ok" }],
-				details: {},
-			};
-		},
-	});
-
-	pi.registerTool({
-		name: "questionnaire",
-		label: "questionnaire",
-		description: "Mock read-only questionnaire tool",
-		parameters: Type.Object({}),
-		async execute() {
-			return {
-				content: [{ type: "text", text: "mock-questionnaire-ok" }],
-				details: {},
-			};
-		},
-	});
-}
-
-console.log("Loading extension (isolated)...");
-const loader = new DefaultResourceLoader({
-	cwd: os.tmpdir(),
-	agentDir: testAgentDir,
-	settingsManager,
-	extensionFactories: [registerMockTools],
-	skillsOverride: () => ({ skills: [], diagnostics: [] }),
-	promptsOverride: () => ({ prompts: [], diagnostics: [] }),
-	agentsFilesOverride: () => ({ agentsFiles: [] }),
-});
-await loader.reload();
-
-const exts = loader.getExtensions();
-console.log(`  Extensions loaded: ${exts.extensions.length}, errors: ${exts.errors.length}`);
-if (exts.errors.length > 0) {
-	console.error("  Extension errors:", exts.errors);
-}
-
-console.log("Creating session (haiku)...\n");
-const { session } = await createAgentSession({
-	model,
-	thinkingLevel: "off",
-	authStorage,
-	modelRegistry,
-	resourceLoader: loader,
-	sessionManager: SessionManager.inMemory(),
-	settingsManager,
-});
-
-// Log tool calls
-session.subscribe((event) => {
-	if (event.type === "tool_execution_start") {
-		process.stdout.write(`    \x1b[2m→ ${event.toolName}\x1b[0m\n`);
-	}
-});
-
-// ── Test 1: plan_mode tool exists at startup ─────────────────
-
-console.log("\x1b[1mTest 1: plan_mode tool available at startup\x1b[0m");
-await session.prompt(
-	'Call the plan_mode tool with action "status". Only call this one tool, nothing else.'
-);
-const statusText = lastToolResultText(session, "plan_mode");
-const noStartupError = !hasToolNotFoundError(session, "plan_mode");
-check("plan_mode tool callable at startup", noStartupError, statusText);
-check("reports normal mode", statusText.includes("normal"), statusText);
-
-// ── Test 2: Enable plan mode, verify plan_mode survives ──────
-
-console.log("\n\x1b[1mTest 2: Enable plan mode → plan_mode tool still available\x1b[0m");
-await session.prompt(
-	'Call the plan_mode tool with action "enable". Only call this one tool, nothing else.'
-);
-const enableText = lastToolResultText(session, "plan_mode");
-const noEnableError = !hasToolNotFoundError(session, "plan_mode");
-check("plan_mode callable during enable", noEnableError, enableText);
-check("reports plan mode enabled", enableText.includes("enabled"), enableText);
-
-// Now check status — plan_mode should still work IN plan mode
-await session.prompt(
-	'Call the plan_mode tool with action "status". Only call this one tool, nothing else.'
-);
-const planStatusText = lastToolResultText(session, "plan_mode");
-const noPlanStatusError = !hasToolNotFoundError(session, "plan_mode");
-check("plan_mode callable while in plan mode", noPlanStatusError, planStatusText);
-check("reports planning mode", planStatusText.includes("planning"), planStatusText);
-
-// ── Test 3: Disable plan mode, verify plan_mode survives ─────
-
-console.log("\n\x1b[1mTest 3: Disable plan mode → plan_mode tool still available\x1b[0m");
-await session.prompt(
-	'Call the plan_mode tool with action "disable". Only call this one tool, nothing else.'
-);
-const disableText = lastToolResultText(session, "plan_mode");
-const noDisableError = !hasToolNotFoundError(session, "plan_mode");
-check("plan_mode callable during disable", noDisableError, disableText);
-check("reports disabled", disableText.includes("disabled"), disableText);
-
-// Final status check — should be back to normal
-await session.prompt(
-	'Call the plan_mode tool with action "status". Only call this one tool, nothing else.'
-);
-const finalStatusText = lastToolResultText(session, "plan_mode");
-const noFinalError = !hasToolNotFoundError(session, "plan_mode");
-check("plan_mode callable after round-trip", noFinalError, finalStatusText);
-check("back to normal mode", finalStatusText.includes("normal"), finalStatusText);
-
-// ── Test 4: Strict allowlist enforcement in plan mode ────────
-
-console.log("\n\x1b[1mTest 4: Strict allowlist blocks non-read-only tools\x1b[0m");
-await session.prompt(
-	'Call the plan_mode tool with action "enable". Only call this one tool, nothing else.'
-);
-
-await session.prompt(
-	'Call the edit tool to edit file "/tmp/test.txt" replacing "a" with "b". Only call edit, nothing else.'
-);
-const editBlocked =
-	hasToolNotFoundError(session, "edit") || hasPlanModeToolBlockedError(session, "edit");
-check("edit tool blocked in plan mode", editBlocked, "edit should not be available in plan mode");
-
-await session.prompt(
-	'Call the bg_bash tool with command "echo blocked". Only call bg_bash, nothing else.'
-);
-const bgBashBlocked =
-	hasToolNotFoundError(session, "bg_bash") || hasPlanModeToolBlockedError(session, "bg_bash");
-check("bg_bash blocked in plan mode", bgBashBlocked, "bg_bash should be blocked in plan mode");
-
-await session.prompt('Call the subagent tool with task "ping". Only call subagent, nothing else.');
-const subagentBlocked =
-	hasToolNotFoundError(session, "subagent") || hasPlanModeToolBlockedError(session, "subagent");
-check("subagent blocked in plan mode", subagentBlocked, "subagent should be blocked in plan mode");
-
-await session.prompt("Call the mcp__mock__ping tool. Only call this one tool, nothing else.");
-const mcpBlocked =
-	hasToolNotFoundError(session, "mcp__mock__ping") ||
-	hasPlanModeToolBlockedError(session, "mcp__mock__ping");
-check("mcp__* tools blocked in plan mode", mcpBlocked, "MCP tools should be blocked in plan mode");
-
-await session.prompt("Call the questionnaire tool. Only call this one tool, nothing else.");
-const questionnaireText = lastToolResultText(session, "questionnaire");
-const questionnaireAllowed = questionnaireText.includes("mock-questionnaire-ok");
-check("allowlisted questionnaire tool still works", questionnaireAllowed, questionnaireText);
-
-// ── Test 5: Disabling plan mode restores normal access ───────
-
-console.log("\n\x1b[1mTest 5: Disable restores normal tool access\x1b[0m");
-await session.prompt(
-	'Call the plan_mode tool with action "disable". Only call this one tool, nothing else.'
-);
-await session.prompt(
-	'Call the subagent tool with task "after-disable". Only call subagent, nothing else.'
-);
-const subagentAfterDisableText = lastToolResultText(session, "subagent");
-const subagentRestored = subagentAfterDisableText.includes("mock-subagent-ok:after-disable");
-check("subagent restored after disabling plan mode", subagentRestored, subagentAfterDisableText);
-
-// ── Cleanup & Summary ────────────────────────────────────────
-
-session.dispose();
-fs.rmSync(testAgentDir, { recursive: true, force: true });
-
-const passed = results.filter((r) => r.passed).length;
-const total = results.length;
-
-console.log(`\n\x1b[1m══ Results: ${passed}/${total} passed ══\x1b[0m`);
-if (passed < total) {
-	console.log("\n\x1b[31mFailed:\x1b[0m");
-	for (const r of results.filter((r) => !r.passed)) {
-		console.log(`  ✗ ${r.name}`);
-		if (r.detail) console.log(`    ${r.detail.slice(0, 300)}`);
-	}
-}
-console.log();
-process.exit(passed === total ? 0 : 1);