@dungle-scrubs/tallow 0.9.3 → 0.9.6

package/extensions/render-stabilizer/index.ts

@@ -43,15 +43,15 @@ function captureTuiRef(ui: {
 /**
  * Register render stabilization hooks.
  *
+ * The shared reset helper now owns reset-grace handling for the main
+ * interactive reset paths. This extension remains as a compatibility shim
+ * for any remaining session-switch surfaces that still depend on an
+ * extension-side hook.
+ *
  * @param pi - Extension API
  */
 export default function renderStabilizerExtension(pi: ExtensionAPI): void {
-	// Capture the TUI reference on first session_start
-	pi.on("session_start", async (_event, ctx) => {
-		captureTuiRef(ctx.ui);
-	});
-
-	// Reset the render grace period before a session switch so the
+	// Reset the render grace period before a legacy session switch so the
 	// chatContainer.clear() → renderInitialMessages() transition uses
 	// gentle line-by-line redraws instead of screen-clearing redraws.
 	pi.on("session_before_switch", async (_event, ctx) => {

package/extensions/show-system-prompt/__tests__/show-system-prompt.test.ts

@@ -40,7 +40,7 @@ describe("show-system-prompt extension", () => {
 			logged.push(args.join(" "));
 		};
 		try {
-			await handler!("", ctx);
+			await handler?.("", ctx);
 		} finally {
 			console.log = origLog;
 		}

package/extensions/slash-command-bridge/__tests__/slash-command-bridge.test.ts

@@ -13,6 +13,10 @@ import type {
 	ExtensionUIContext,
 	TurnEndEvent,
 } from "@mariozechner/pi-coding-agent";
+import {
+	getResetDiagnosticsForTests,
+	resetResetDiagnosticsForTests,
+} from "../../../src/reset-diagnostics.js";
 import { ExtensionHarness } from "../../../test-utils/extension-harness.js";
 import { ManualTimerScheduler } from "../../../test-utils/manual-timer-scheduler.js";
 import slashCommandBridge, {
@@ -40,6 +44,7 @@ beforeEach(async () => {
 });
 
 afterEach(() => {
+	resetResetDiagnosticsForTests();
 	resetSlashCommandBridgeStateForTests();
 });
 
@@ -314,6 +319,11 @@ describe("compact", () => {
 		const continuation = harness.sentMessages.find(
 			(message) => message.customType === "compact-continue"
 		);
+		expect(
+			getResetDiagnosticsForTests().some(
+				(event) => event.kind === "deferred_registered" && event.source === "slash-command-bridge"
+			)
+		).toBe(true);
 		expect(continuation?.display).toBe(false);
 		expect(continuation?.options?.triggerTurn).toBe(true);
 		expect(continuation?.content).toContain("compaction is complete");
@@ -344,6 +354,14 @@ describe("compact", () => {
 		await harness.fireEvent("turn_start", { type: "turn_start", turnIndex: 0, timestamp: 0 }, ctx);
 		scheduler.advanceBy(200);
 
+		expect(
+			getResetDiagnosticsForTests().some(
+				(event) =>
+					event.kind === "deferred_cancelled" &&
+					event.source === "slash-command-bridge" &&
+					event.reason === "turn_start"
+			)
+		).toBe(true);
 		expect(harness.sentMessages).toHaveLength(0);
 		expect(widgetUpdates.at(-1)).toEqual({ key: "compact-progress", content: undefined });
 	});
@@ -374,6 +392,14 @@ describe("compact", () => {
 		compactOptions?.onComplete?.();
 		scheduler.advanceBy(200);
 
+		expect(
+			getResetDiagnosticsForTests().some(
+				(event) =>
+					event.kind === "deferred_dropped" &&
+					event.source === "slash-command-bridge" &&
+					event.reason === "session_not_idle"
+			)
+		).toBe(true);
 		expect(harness.sentMessages).toHaveLength(0);
 		expect(widgetUpdates.at(-1)).toEqual({ key: "compact-progress", content: undefined });
 		expect(workingMessages.at(-1)).toBeUndefined();

package/extensions/slash-command-bridge/index.ts

@@ -17,6 +17,7 @@ import type {
 } from "@mariozechner/pi-coding-agent";
 import { Text } from "@mariozechner/pi-tui";
 import { Type } from "@sinclair/typebox";
+import { recordResetDiagnostic } from "../../src/reset-diagnostics.js";
 
 /**
  * Deferred compact request — set by the tool handler, consumed on the first
@@ -154,13 +155,18 @@ function stopCompactProgress(ctx?: ExtensionContext): void {
  *
  * @returns Nothing
  */
-function clearContinuationTimer(): void {
+function clearContinuationTimer(reason?: string): void {
 	if (!continuationTimer) {
 		return;
 	}
 
 	timerScheduler.clearTimeout(continuationTimer);
 	continuationTimer = null;
+	recordResetDiagnostic({
+		kind: "deferred_cancelled",
+		reason: reason ?? "clear_continuation_timer",
+		source: "slash-command-bridge",
+	});
 }
 
 /**
@@ -338,6 +344,7 @@ function startDeferredCompact(
 			// 200ms gives session.prompt()'s async setup (API key resolution,
 			// compaction check) time to settle. The turn_start listener cancels
 			// this timer if a turn starts before it fires (defense-in-depth).
+			recordResetDiagnostic({ kind: "deferred_registered", source: "slash-command-bridge" });
 			continuationTimer = timerScheduler.setTimeout(() => {
 				continuationTimer = null;
 				if (ctx.isIdle()) {
@@ -354,6 +361,11 @@ function startDeferredCompact(
 				} else {
 					// User sent a message during compaction — their turn is
 					// handling things, clean up our indicators.
+					recordResetDiagnostic({
+						kind: "deferred_dropped",
+						reason: "session_not_idle",
+						source: "slash-command-bridge",
+					});
 					resumingAfterCompact = false;
 					ctx.ui?.setWidget?.("compact-progress", undefined);
 					ctx.ui?.setWorkingMessage?.();
@@ -601,7 +613,7 @@ WHEN NOT TO USE:
 	 * now active and showing the pending working message ("Resuming task…").
 	 */
 	pi.on("turn_start", (_event, ctx) => {
-		clearContinuationTimer();
+		clearContinuationTimer("turn_start");
 		if (!resumingAfterCompact) return;
 		resumingAfterCompact = false;
 		ctx.ui?.setWidget?.("compact-progress", undefined);

package/extensions/subagent-tool/index.ts

@@ -1412,7 +1412,7 @@ function renderSubagentCall(args: Record<string, unknown>, theme: Theme) {
 		return new Text(lines.join("\n"), 0, 0);
 	}
 
-	const agentName = (args.agent as string) || "...";
+	const _agentName = (args.agent as string) || "...";
 	const task = typeof args.task === "string" ? args.task : "...";
 	// Single mode: skip the redundant "subagent single" header — the result
 	// renderer already shows "subagent running <duration> <agent>" with a spinner.

package/extensions/subagent-tool/model-resolver.ts

@@ -1,12 +1,279 @@
 /**
- * Fuzzy model name resolution — re-exports from synapse.
+ * Deterministic fuzzy model resolution for subagents.
+ *
+ * We keep a local implementation instead of delegating straight to synapse
+ * because the direct dependency path was flaky under Linux CI in this repo.
+ * The behavior mirrors synapse's public resolver cascade closely enough for
+ * runtime callers and keeps tests deterministic across platforms.
  *
  * @module
  */
 
-export type { ModelSource, ResolvedModel } from "@dungle-scrubs/synapse";
-export {
-	listAvailableModels,
-	resolveModelCandidates,
-	resolveModelFuzzy,
-} from "@dungle-scrubs/synapse";
+import type { CandidateModel, ModelSource, ResolvedModel } from "@dungle-scrubs/synapse";
+import { getModels, getProviders } from "@mariozechner/pi-ai";
+
+export type { ModelSource, ResolvedModel };
+
+/**
+ * Collect all models from the registered pi-ai providers.
+ *
+ * @returns Flat list of candidate models
+ */
+function getAllModels(): CandidateModel[] {
+	const result: CandidateModel[] = [];
+	for (const provider of getProviders()) {
+		for (const model of getModels(provider)) {
+			result.push({ provider: model.provider, id: model.id, name: model.name });
+		}
+	}
+	return result;
+}
+
+/**
+ * Convert a candidate model into the resolved public shape.
+ *
+ * @param model - Candidate model
+ * @returns Resolved model descriptor
+ */
+function toResolved(model: CandidateModel): ResolvedModel {
+	return {
+		displayName: `${model.provider}/${model.id}`,
+		id: model.id,
+		provider: model.provider,
+	};
+}
+
+/**
+ * Tokenize a query or model identifier for overlap matching.
+ *
+ * @param value - Raw query or identifier
+ * @returns Lowercase tokens split on separators and digit boundaries
+ */
+function tokenize(value: string): string[] {
+	return value
+		.toLowerCase()
+		.replace(/([a-z])(\d)/g, "$1 $2")
+		.replace(/(\d)([a-z])/g, "$1 $2")
+		.split(/[\s\-_.]+/)
+		.filter((token) => token.length > 0);
+}
+
+/**
+ * Normalize a query or identifier by removing separators.
+ *
+ * @param value - Raw query or identifier
+ * @returns Lowercase normalized string
+ */
+function normalize(value: string): string {
+	return value.toLowerCase().replace(/[\s\-_.]+/g, "");
+}
+
+/**
+ * Compare model IDs using numeric-aware sorting.
+ *
+ * @param a - First model ID
+ * @param b - Second model ID
+ * @returns Positive when a is newer/higher than b
+ */
+function compareModelIds(a: string, b: string): number {
+	return a.localeCompare(b, undefined, { numeric: true, sensitivity: "base" });
+}
+
+/**
+ * Build a provider-priority lookup map.
+ *
+ * @param preferredProviders - Ordered provider preference list
+ * @returns Provider -> priority map (lower is better)
+ */
+function buildProviderPreferenceMap(
+	preferredProviders: readonly string[] | undefined
+): ReadonlyMap<string, number> {
+	const priorities = new Map<string, number>();
+	for (const [index, provider] of (preferredProviders ?? []).entries()) {
+		priorities.set(provider.toLowerCase(), index);
+	}
+	return priorities;
+}
+
+/**
+ * Resolve one provider's priority, defaulting unknown providers last.
+ *
+ * @param preferenceMap - Provider priority map
+ * @param provider - Provider to score
+ * @returns Numeric priority (lower is better)
+ */
+function getProviderPriority(preferenceMap: ReadonlyMap<string, number>, provider: string): number {
+	return preferenceMap.get(provider.toLowerCase()) ?? Number.MAX_SAFE_INTEGER;
+}
+
+/**
+ * Pick the best candidate by ID quality only.
+ *
+ * Tiebreak order:
+ * 1. Higher numeric-aware model ID
+ * 2. Shorter ID when numeric ordering ties
+ * 3. Lexicographically last as deterministic fallback
+ *
+ * @param models - Candidate models
+ * @returns Best candidate
+ */
+function pickBestModel(models: readonly CandidateModel[]): CandidateModel {
+	return models.reduce((best, current) => {
+		const versionDiff = compareModelIds(best.id, current.id);
+		if (versionDiff !== 0) {
+			return versionDiff > 0 ? best : current;
+		}
+		if (best.id.length !== current.id.length) {
+			return best.id.length < current.id.length ? best : current;
+		}
+		return best.id >= current.id ? best : current;
+	});
+}
+
+/**
+ * Pick the best final candidate, optionally preferring specific providers.
+ *
+ * @param models - Candidate models
+ * @param preferredProviders - Ordered provider preference list
+ * @returns Best candidate
+ */
+function pickBest(
+	models: readonly CandidateModel[],
+	preferredProviders?: readonly string[]
+): CandidateModel {
+	const bestModel = pickBestModel(models);
+	if (!preferredProviders || preferredProviders.length === 0) {
+		return bestModel;
+	}
+
+	const sameModel = models.filter((model) => model.id === bestModel.id);
+	if (sameModel.length <= 1) {
+		return bestModel;
+	}
+
+	const preferenceMap = buildProviderPreferenceMap(preferredProviders);
+	return sameModel.reduce((best, current) => {
+		return getProviderPriority(preferenceMap, best.provider) <=
+			getProviderPriority(preferenceMap, current.provider)
+			? best
+			: current;
+	});
+}
+
+/**
+ * Find all candidates that tie at the best score for the first matching tier.
+ *
+ * Resolution cascade:
+ * 1. Exact ID match
+ * 2. Case-insensitive ID match
+ * 3. Normalized ID match (strips separators)
+ * 4. Provider/ID exact match
+ * 5. Token overlap scoring
+ * 6. Raw substring match
+ * 7. Normalized substring match
+ *
+ * @param query - Human-friendly query
+ * @param modelSource - Optional injected model source
+ * @returns Tied candidates from the first matching tier
+ */
+function findCandidates(query: string, modelSource?: ModelSource): CandidateModel[] {
+	const models = modelSource ? modelSource() : getAllModels();
+	if (models.length === 0) return [];
+
+	const trimmed = query.trim();
+	if (trimmed.length === 0) return [];
+
+	const lower = trimmed.toLowerCase();
+	const normalized = normalize(trimmed);
+
+	const exact = models.filter((model) => model.id === trimmed);
+	if (exact.length > 0) return exact;
+
+	const caseInsensitive = models.filter((model) => model.id.toLowerCase() === lower);
+	if (caseInsensitive.length > 0) return caseInsensitive;
+
+	const normalizedId = models.filter((model) => normalize(model.id) === normalized);
+	if (normalizedId.length > 0) return normalizedId;
+
+	if (trimmed.includes("/")) {
+		const slashIndex = trimmed.indexOf("/");
+		const provider = trimmed.slice(0, slashIndex).toLowerCase();
+		const id = trimmed.slice(slashIndex + 1).toLowerCase();
+		const providerMatch = models.filter(
+			(model) => model.provider.toLowerCase() === provider && model.id.toLowerCase() === id
+		);
+		if (providerMatch.length > 0) return providerMatch;
+	}
+
+	const queryTokens = tokenize(trimmed);
+	if (queryTokens.length > 0) {
+		let bestScore = 0;
+		let bestMatches: CandidateModel[] = [];
+		for (const model of models) {
+			const idName = `${model.id} ${model.name}`.toLowerCase();
+			const providerText = model.provider.toLowerCase();
+			let score = 0;
+			for (const token of queryTokens) {
+				if (idName.includes(token)) score += 2;
+				else if (providerText.includes(token)) score += 1;
+			}
+			if (score > bestScore) {
+				bestScore = score;
+				bestMatches = [model];
+			} else if (score === bestScore && score > 0) {
+				bestMatches.push(model);
+			}
+		}
+		if (bestMatches.length > 0) return bestMatches;
+	}
+
+	const substring = models.filter(
+		(model) => model.id.toLowerCase().includes(lower) || model.name.toLowerCase().includes(lower)
+	);
+	if (substring.length > 0) return substring;
+
+	return models.filter(
+		(model) =>
+			normalize(model.id).includes(normalized) || normalize(model.name).includes(normalized)
+	);
+}
+
+/**
+ * Resolve a fuzzy model query to one best match.
+ *
+ * @param query - Human-friendly model query
+ * @param modelSource - Optional injected model source for deterministic tests
+ * @param preferredProviders - Optional provider preference ordering
+ * @returns Best matching model or undefined
+ */
+export function resolveModelFuzzy(
+	query: string,
+	modelSource?: ModelSource,
+	preferredProviders?: string[]
+): ResolvedModel | undefined {
+	const candidates = findCandidates(query, modelSource);
+	if (candidates.length === 0) return undefined;
+	return toResolved(pickBest(candidates, preferredProviders));
+}
+
+/**
+ * Resolve a fuzzy model query to all tied candidates.
+ *
+ * @param query - Human-friendly model query
+ * @param modelSource - Optional injected model source for deterministic tests
+ * @returns Candidate matches
+ */
+export function resolveModelCandidates(query: string, modelSource?: ModelSource): ResolvedModel[] {
+	return findCandidates(query, modelSource).map(toResolved);
+}
+
+/**
+ * List available provider/model identifiers.
+ *
+ * @param modelSource - Optional injected model source for deterministic tests
+ * @returns Provider/model identifier strings
+ */
+export function listAvailableModels(modelSource?: ModelSource): string[] {
+	const models = modelSource ? modelSource() : getAllModels();
+	return models.map((model) => `${model.provider}/${model.id}`);
+}

package/extensions/tasks/__tests__/state-ui.test.ts

@@ -114,10 +114,10 @@ describe("tasks ui helpers", () => {
 		expect(visibleWidth(truncated)).toBe(3);
 	});
 
-	it("mergeSideBySide bottom-aligns right column and keeps width bounds", () => {
+	it("mergeSideBySide top-aligns right column and keeps width bounds", () => {
 		const merged = mergeSideBySide(["left1", "left2", "left3"], ["right"], 6, " | ", 16);
 		expect(merged).toHaveLength(3);
-		expect(merged[0]).toBe("left1  | ");
-		expect(merged[2]).toContain("right");
+		expect(merged[0]).toContain("right");
+		expect(merged[2]).toBe("left3  | ");
 	});
 });

package/extensions/tasks/__tests__/widget-subagents.test.ts

@@ -406,7 +406,7 @@ describe("tasks widget subagent sections", () => {
 			expectLinesWithinWidth(stackedNarrow, 55);
 			expectLinesWithinWidth(stackedWide, 95);
 
-			const sideBySideNarrow = renderWidget(fixture.captured, 124);
+			const sideBySideNarrow = renderWidget(fixture.captured, 144);
 			const sideBySideWide = renderWidget(fixture.captured, 180);
 			const sideBySideNarrowPreview = extractPreview(sideBySideNarrow, "seg01");
 			const sideBySideWidePreview = extractPreview(sideBySideWide, "seg01");
@@ -417,7 +417,7 @@ describe("tasks widget subagent sections", () => {
 			expect(visibleWidth(sideBySideWidePreview)).toBeGreaterThan(
 				visibleWidth(sideBySideNarrowPreview)
 			);
-			expectLinesWithinWidth(sideBySideNarrow, 124);
+			expectLinesWithinWidth(sideBySideNarrow, 144);
 			expectLinesWithinWidth(sideBySideWide, 180);
 		} finally {
 			await shutdownFixture(fixture);

package/extensions/tasks/commands/register-tasks-extension.ts

@@ -685,7 +685,7 @@ export function registerTasksExtension(
 				const useSideBySide = width >= MIN_SIDE_BY_SIDE_WIDTH && hasTasks && hasRightColumn;
 
 				if (useSideBySide) {
-					// Side-by-side: tasks on left, subagents + bg tasks on right (bottom-aligned)
+					// Side-by-side: tasks on left, subagents + bg tasks on right
 					const separator = "\x1b[38;2;60;60;70m  │  \x1b[0m"; // Dark gray
 					const separatorWidth = 5; // "  │  " is 5 visible chars
 					const leftColumnWidth = Math.floor((width - separatorWidth) / 2);
@@ -2168,15 +2168,15 @@ Before calling manage_tasks complete/update, call manage_tasks list first so ind
 		updateAgentBar(ctx);
 	}
 
-	pi.on("session_start", async (_event, ctx) => {
-		restoreSessionState(ctx);
-	});
-
-	pi.on("session_switch", async (_event, ctx) => {
-		restoreSessionState(ctx);
-	});
-
-	// Cleanup on session end
+	pi.on("session_start", async (_event, ctx) => restoreSessionState(ctx));
+	(
+		pi as unknown as {
+			on: (
+				event: string,
+				handler: (event: unknown, ctx: ExtensionContext) => Promise<void>
+			) => void;
+		}
+	).on("session_switch", async (_event, ctx) => restoreSessionState(ctx));
 	pi.on("session_shutdown", async () => {
 		emitInteropEvent(pi.events, INTEROP_EVENT_NAMES.backgroundTasksPresenterState, {
 			active: false,

package/extensions/tasks/state/index.ts

@@ -38,7 +38,7 @@ export const LEGACY_TEAMS_DIR = getTallowPath("teams");
 export const TEAM_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
 
 /** Minimum width for side-by-side layout (tasks left, subagents right). */
-export const MIN_SIDE_BY_SIDE_WIDTH = 120;
+export const MIN_SIDE_BY_SIDE_WIDTH = 140;
 
 /** Prefix used for session-scoped shared task-group directories. */
 const SESSION_TASK_GROUP_PREFIX = "task-group";

package/extensions/tasks/ui/index.ts

@@ -45,7 +45,7 @@ export function padToWidth(line: string, targetWidth: number): string {
 }
 
 /**
- * Merge two column arrays into side-by-side lines, with right column bottom-aligned.
+ * Merge two column arrays into side-by-side lines with top-aligned rows.
  *
  * Both columns are truncated to their allotted widths to prevent overflow.
  *
@@ -68,14 +68,9 @@ export function mergeSideBySide(
 	const maxRows = Math.max(leftLines.length, rightLines.length);
 	const result: string[] = [];
 
-	// Bottom-align: pad right column at the top
-	const rightPadding = maxRows - rightLines.length;
-
 	for (let i = 0; i < maxRows; i++) {
 		const left = leftLines[i] ?? "";
-		const rightIndex = i - rightPadding;
-		const rawRight = rightIndex >= 0 ? (rightLines[rightIndex] ?? "") : "";
-		// Truncate right column to prevent overflow
+		const rawRight = rightLines[i] ?? "";
 		const right =
 			rightWidth > 0 && visibleWidth(rawRight) > rightWidth
 				? truncateToWidth(rawRight, rightWidth, "")

package/extensions/teams-tool/tools/register-extension.ts

@@ -20,7 +20,7 @@
  */
 
 import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
-import { Key, Loader, Text, type TUI } from "@mariozechner/pi-tui";
+import { Key, Text, type TUI } from "@mariozechner/pi-tui";
 import { Type } from "@sinclair/typebox";
 import { INTEROP_EVENT_NAMES, onInteropEvent } from "../../_shared/interop-events.js";
 import {
@@ -248,7 +248,6 @@ export function registerTeamsToolExtension(pi: ExtensionAPI): void {
 		dashboardEnabled = true;
 		setDashboardFlag(true);
 		startDashboardTicker();
-		ctx.ui.setWorkingMessage(Loader.HIDE);
 		ctx.ui.setStatus("team-dashboard", "Team dashboard active");
 		ctx.ui.setEditorComponent((tui, editorTheme, keybindings) => {
 			enterDashboardViewport(tui);
@@ -322,7 +321,6 @@ export function registerTeamsToolExtension(pi: ExtensionAPI): void {
 
 	pi.on("turn_start", async (_event, ctx) => {
 		if (!dashboardEnabled || !ctx.hasUI) return;
-		ctx.ui.setWorkingMessage(Loader.HIDE);
 	});
 
 	// Archive all teams on session shutdown (preserves tasks for future recovery)

package/extensions/web-search-tool/index.ts

@@ -12,9 +12,10 @@
  */
 
 import type { ExtensionAPI, ThemeColor } from "@mariozechner/pi-coding-agent";
-import { hyperlink, Text } from "@mariozechner/pi-tui";
+import { Text } from "@mariozechner/pi-tui";
 import { Type } from "@sinclair/typebox";
 import { getIcon } from "../_icons/index.js";
+import { hyperlink } from "../_shared/terminal-links.js";
 import { formatToolVerb, renderLines } from "../tool-display/index.js";
 import { BraveSearchProvider } from "./providers/brave.js";
 import { SearchError, type SearchProvider, type SearchResult } from "./providers/interface.js";

package/extensions/write-tool-enhanced/__tests__/write-tool-enhanced.test.ts

@@ -68,6 +68,21 @@ function stubContext(): ExtensionContext {
 	} as unknown as ExtensionContext;
 }
 
+/**
+ * Resolve the registered write tool from a loaded harness.
+ *
+ * @param harness - Extension harness with write-tool-enhanced loaded
+ * @returns Registered write tool definition
+ * @throws {Error} When the write tool is unavailable
+ */
+function getWriteTool(harness: ExtensionHarness) {
+	const tool = harness.tools.get("write");
+	if (!tool) {
+		throw new Error("write tool not registered");
+	}
+	return tool;
+}
+
 // ── Tests ─────────────────────────────────────────────────────────────────────
 
 describe("write-tool-enhanced", () => {
@@ -109,7 +124,7 @@ describe("write-tool-enhanced", () => {
 			const harness = ExtensionHarness.create();
 			await harness.loadExtension(writePreview);
 
-			const tool = harness.tools.get("write")!;
+			const tool = getWriteTool(harness);
 			const content = "const x = 1;\nconst y = 2;";
 
 			const result = await tool.execute(
@@ -128,7 +143,7 @@ describe("write-tool-enhanced", () => {
 			const harness = ExtensionHarness.create();
 			await harness.loadExtension(writePreview);
 
-			const tool = harness.tools.get("write")!;
+			const tool = getWriteTool(harness);
 			const content = "line1\nline2\nline3"; // 3 lines
 
 			const result = await tool.execute(
@@ -148,7 +163,7 @@ describe("write-tool-enhanced", () => {
 			const harness = ExtensionHarness.create();
 			await harness.loadExtension(writePreview);
 
-			const tool = harness.tools.get("write")!;
+			const tool = getWriteTool(harness);
 			// 1200 chars → 1200/1024 ≈ 1.171875 → toFixed(1) = "1.2"
 			const content = "a".repeat(1200);
 			const expectedKb = (content.length / 1024).toFixed(1);
@@ -170,7 +185,7 @@ describe("write-tool-enhanced", () => {
 			const harness = ExtensionHarness.create();
 			await harness.loadExtension(writePreview);
 
-			const tool = harness.tools.get("write")!;
+			const tool = getWriteTool(harness);
 			const content = "hello\nworld"; // 2 lines, 11 chars
 
 			const result = await tool.execute(
@@ -190,7 +205,7 @@ describe("write-tool-enhanced", () => {
 			const harness = ExtensionHarness.create();
 			await harness.loadExtension(writePreview);
 
-			const tool = harness.tools.get("write")!;
+			const tool = getWriteTool(harness);
 
 			const result = await tool.execute(
 				"test-id",
@@ -211,7 +226,7 @@ describe("write-tool-enhanced", () => {
 			const harness = ExtensionHarness.create();
 			await harness.loadExtension(writePreview);
 
-			const tool = harness.tools.get("write")!;
+			const tool = getWriteTool(harness);
 
 			await expect(
 				tool.execute(

package/extensions/write-tool-enhanced/index.ts

@@ -2,8 +2,9 @@
  * Enhanced write tool — shows full written content with summary footer.
  */
 import { createWriteTool, type ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { fileLink, Text } from "@mariozechner/pi-tui";
+import { Text } from "@mariozechner/pi-tui";
 import { getIcon } from "../_icons/index.js";
+import { fileLink } from "../_shared/terminal-links.js";
 import {
 	appendSection,
 	dimProcessOutputLine,