@dungle-scrubs/tallow 0.8.13 → 0.8.15

package/extensions/plan-mode-tool/utils.ts

@@ -3,6 +3,66 @@
  * Extracted for testability — no extension API dependencies.
  */
 
+// ── Natural language plan intent detection ──────────────────────────────
+
+/**
+ * Curated patterns that unambiguously express "enter planning mode".
+ * Each pattern uses word boundaries to avoid matching plan-as-noun usage
+ * (e.g. "make a plan for X") or questions about plan mode.
+ */
+export const PLAN_INTENT_PATTERNS: readonly RegExp[] = [
+	// Composite patterns first — avoids partial stripping of overlapping phrases
+	/\bthis\s+is\s+plan(ning)?(\s+only)?\b/i,
+	/\bplan[\s-]only\b/i,
+	/\bjust\s+plan\b/i,
+	/\bonly\s+plan\b/i,
+	/\bplan\s+mode\b(?!\s*(\?|do|work|mean))/i,
+	/\bplanning\s+mode\b(?!\s*(\?|do|work|mean))/i,
+	/\bdon['\u2019]?t\s+(implement|code|execute|make\s+changes)\b/i,
+	/\bdo\s+not\s+(implement|code|execute|make\s+changes)\b/i,
+	/\bno\s+(implementation|changes|coding)\s+(yet|first|for\s+now)\b/i,
+	/\bread[\s-]only\s+mode\b/i,
+	/\bplan\s+(first|before)\b/i,
+];
+
+/**
+ * Detects whether user input contains a strong planning-intent directive.
+ *
+ * Only matches unambiguous directives like "plan only" or "don't implement".
+ * Does NOT match noun usage ("the plan is…") or questions ("what does plan mode do?").
+ *
+ * @param text - Raw user input
+ * @returns true when any plan-intent pattern matches
+ */
+export function detectPlanIntent(text: string): boolean {
+	return PLAN_INTENT_PATTERNS.some((pattern) => pattern.test(text));
+}
+
+/**
+ * Strips plan-intent phrases from user input, preserving the actual request.
+ *
+ * If stripping leaves an empty string (the entire message was just "plan only"),
+ * returns the original text so the model has something to work with.
+ *
+ * @param text - Raw user input
+ * @returns Cleaned text with plan-intent phrases removed, or original if nothing remains
+ */
+export function stripPlanIntent(text: string): string {
+	let stripped = text;
+	for (const pattern of PLAN_INTENT_PATTERNS) {
+		stripped = stripped.replace(pattern, "");
+	}
+	// Clean up artifacts: leading/trailing punctuation, double spaces, dangling commas
+	stripped = stripped
+		.replace(/^[\s,.\-—;:]+/, "")
+		.replace(/[\s,.\-—;:]+$/, "")
+		.replace(/\s{2,}/g, " ")
+		.trim();
+	return stripped || text;
+}
+
+// ── Bash safety ─────────────────────────────────────────────────────────
+
 /** Patterns for destructive commands that are blocked in plan mode */
 const DESTRUCTIVE_PATTERNS = [
 	/\brm\b/i,

package/extensions/web-fetch-tool/__tests__/adaptive-cap.test.ts

@@ -0,0 +1,148 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { ExtensionHarness } from "../../../test-utils/extension-harness.js";
+import {
+	CONTEXT_BUDGET_API_CHANNELS,
+	type ContextBudgetEnvelope,
+} from "../../_shared/context-budget-interop.js";
+import webFetchExtension, { type CapResolutionInput, resolveAdaptiveCap } from "../index.js";
+
+/** Build a CapResolutionInput with test defaults. */
+function makeInput(overrides: Partial<CapResolutionInput> = {}): CapResolutionInput {
+	return {
+		defaultMaxBytes: 32 * 1024,
+		envelope: undefined,
+		policyMax: 512 * 1024,
+		policyMin: 4 * 1024,
+		userMaxBytes: undefined,
+		...overrides,
+	};
+}
+
+/** Build a planner envelope. */
+function makeEnvelope(maxBytes: number, batchSize = 1): ContextBudgetEnvelope {
+	return { batchSize, maxBytes };
+}
+
+const originalFetch = globalThis.fetch;
+
+afterEach(() => {
+	globalThis.fetch = originalFetch;
+});
+
+describe("resolveAdaptiveCap", () => {
+	test("uses strict fallback when no envelope exists", () => {
+		const result = resolveAdaptiveCap(makeInput());
+		expect(result.effectiveMaxBytes).toBe(32 * 1024);
+		expect(result.budgetLimited).toBe(false);
+		expect(result.budgetReason).toContain("strict fallback");
+		expect(result.batchSize).toBe(1);
+	});
+
+	test("marks budgetLimited when envelope reduces cap", () => {
+		const result = resolveAdaptiveCap(makeInput({ envelope: makeEnvelope(8 * 1024, 3) }));
+		expect(result.effectiveMaxBytes).toBe(8 * 1024);
+		expect(result.budgetLimited).toBe(true);
+		expect(result.batchSize).toBe(3);
+	});
+
+	test("clamps envelope to policy max", () => {
+		const result = resolveAdaptiveCap(makeInput({ envelope: makeEnvelope(900 * 1024) }));
+		expect(result.effectiveMaxBytes).toBe(512 * 1024);
+		expect(result.budgetReason).toContain("policy max");
+	});
+
+	test("user maxBytes is a hard upper bound", () => {
+		const result = resolveAdaptiveCap(
+			makeInput({
+				envelope: makeEnvelope(20 * 1024),
+				userMaxBytes: 2 * 1024,
+			})
+		);
+		expect(result.effectiveMaxBytes).toBe(2 * 1024);
+		expect(result.budgetReason).toContain("user maxBytes");
+	});
+});
+
+describe("web_fetch planner handshake", () => {
+	test("requests planner API and consumes envelope by toolCallId", async () => {
+		const harness = ExtensionHarness.create();
+		const takeCalls: string[] = [];
+		const envelopes = new Map<string, ContextBudgetEnvelope>([["tc-1", makeEnvelope(7 * 1024, 2)]]);
+
+		harness.eventBus.on(CONTEXT_BUDGET_API_CHANNELS.budgetApiRequest, () => {
+			harness.eventBus.emit(CONTEXT_BUDGET_API_CHANNELS.budgetApi, {
+				api: {
+					take(toolCallId: string): ContextBudgetEnvelope | undefined {
+						takeCalls.push(toolCallId);
+						const envelope = envelopes.get(toolCallId);
+						envelopes.delete(toolCallId);
+						return envelope;
+					},
+				},
+			});
+		});
+
+		globalThis.fetch = async () =>
+			new Response("x".repeat(20 * 1024), {
+				headers: { "content-type": "text/html" },
+				status: 200,
+			});
+
+		await harness.loadExtension(webFetchExtension);
+		const tool = harness.tools.get("web_fetch");
+		if (!tool) throw new Error("web_fetch tool missing");
+
+		const result = await tool.execute("tc-1", { url: "https://example.com" }, undefined, () => {});
+		const details = result.details as {
+			effectiveMaxBytes?: number;
+			batchSize?: number;
+			budgetLimited?: boolean;
+		};
+
+		expect(takeCalls).toEqual(["tc-1"]);
+		expect(details.effectiveMaxBytes).toBe(7 * 1024);
+		expect(details.batchSize).toBe(2);
+		expect(details.budgetLimited).toBe(true);
+	});
+
+	test("consumed envelope falls back on next call", async () => {
+		const harness = ExtensionHarness.create();
+		const envelopes = new Map<string, ContextBudgetEnvelope>([["tc-1", makeEnvelope(6 * 1024, 2)]]);
+
+		harness.eventBus.on(CONTEXT_BUDGET_API_CHANNELS.budgetApiRequest, () => {
+			harness.eventBus.emit(CONTEXT_BUDGET_API_CHANNELS.budgetApi, {
+				api: {
+					take(toolCallId: string): ContextBudgetEnvelope | undefined {
+						const envelope = envelopes.get(toolCallId);
+						envelopes.delete(toolCallId);
+						return envelope;
+					},
+				},
+			});
+		});
+
+		globalThis.fetch = async () =>
+			new Response("x".repeat(80 * 1024), {
+				headers: { "content-type": "text/html" },
+				status: 200,
+			});
+
+		await harness.loadExtension(webFetchExtension);
+		const tool = harness.tools.get("web_fetch");
+		if (!tool) throw new Error("web_fetch tool missing");
+
+		const first = await tool.execute("tc-1", { url: "https://example.com/1" }, undefined, () => {});
+		const second = await tool.execute(
+			"tc-1",
+			{ url: "https://example.com/2" },
+			undefined,
+			() => {}
+		);
+
+		const firstDetails = first.details as { effectiveMaxBytes?: number };
+		const secondDetails = second.details as { effectiveMaxBytes?: number; budgetReason?: string };
+		expect(firstDetails.effectiveMaxBytes).toBe(6 * 1024);
+		expect(secondDetails.effectiveMaxBytes).toBe(32 * 1024);
+		expect(secondDetails.budgetReason).toContain("strict fallback");
+	});
+});

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

@@ -1,28 +1,135 @@
 /**
  * WebFetch Extension for Pi
  *
- * Fetches web content via plain HTTP. Returns page text truncated to 50KB.
+ * Fetches web content via plain HTTP. Returns page text truncated by context-budget caps.
  * For JS-rendered pages, full-page scraping, or structured extraction,
  * use a dedicated scraping tool (e.g. Firecrawl) instead.
+ *
+ * Supports adaptive context-budget caps when a planner extension publishes
+ * envelopes via the shared context-budget interop.
  */
 
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { Text } from "@mariozechner/pi-tui";
 import { Type } from "@sinclair/typebox";
 import { getIcon } from "../_icons/index.js";
+import {
+	CONTEXT_BUDGET_DEFAULTS,
+	type ContextBudgetEnvelope,
+	subscribeToBudgetApi,
+} from "../_shared/context-budget-interop.js";
 import { renderLines } from "../tool-display/index.js";
 
-const DEFAULT_MAX_BYTES = 50_000;
+/** Strict fallback cap when no planner envelope is available. */
+const DEFAULT_MAX_BYTES = CONTEXT_BUDGET_DEFAULTS.unknownUsageFallbackCapBytes;
+
+/** Policy floor — planner/tool logic should never allocate below this by default. */
+const POLICY_MIN_BYTES = CONTEXT_BUDGET_DEFAULTS.minPerToolBytes;
+
+/** Policy ceiling — never exceed this regardless of envelope. */
+const POLICY_MAX_BYTES = CONTEXT_BUDGET_DEFAULTS.maxPerToolBytes;
+
+// ── Adaptive cap resolution (pure, exported for tests) ──────────────
+
+/** Input parameters for resolving the effective byte cap. */
+export interface CapResolutionInput {
+	/** Explicit maxBytes from the user's tool-call parameters. */
+	userMaxBytes: number | undefined;
+	/** Budget envelope consumed for this tool call (undefined = no planner). */
+	envelope: ContextBudgetEnvelope | undefined;
+	/** Hard policy floor in bytes. */
+	policyMin: number;
+	/** Hard policy ceiling in bytes. */
+	policyMax: number;
+	/** Fallback cap when no envelope is present. */
+	defaultMaxBytes: number;
+}
+
+/** Resolved cap with diagnostics. */
+export interface CapResolutionResult {
+	/** Final byte cap to apply to the fetch response. */
+	effectiveMaxBytes: number;
+	/** True when the planner envelope reduced the cap below what the user would have gotten. */
+	budgetLimited: boolean;
+	/** Human-readable explanation of how the cap was chosen. */
+	budgetReason: string;
+	/** Batch size from the envelope (1 when no envelope). */
+	batchSize: number;
+}
+
+/**
+ * Resolve the effective maxBytes cap from all inputs.
+ *
+ * Priority chain:
+ * 1. Start from envelope maxBytes (or defaultMaxBytes when absent).
+ * 2. User maxBytes is a hard upper bound — cap cannot exceed it.
+ * 3. Clamp into [policyMin, policyMax].
+ *
+ * @param input - Cap resolution parameters
+ * @returns Resolved cap with diagnostic metadata
+ */
+export function resolveAdaptiveCap(input: CapResolutionInput): CapResolutionResult {
+	const { userMaxBytes, envelope, policyMin, policyMax, defaultMaxBytes } = input;
+
+	const batchSize = envelope?.batchSize ?? 1;
+	const userCap = userMaxBytes ?? Number.POSITIVE_INFINITY;
+
+	// Step 1: base cap comes from planner envelope or strict fallback.
+	const base = envelope?.maxBytes ?? defaultMaxBytes;
+	let reason = envelope
+		? `planner envelope (${base} bytes, batch ${batchSize})`
+		: `strict fallback (${defaultMaxBytes} bytes)`;
+
+	// Step 2: clamp planner/fallback cap into policy bounds.
+	let effective = Math.min(policyMax, Math.max(policyMin, base));
+	if (effective !== base) {
+		reason +=
+			effective < base
+				? ` → capped by policy max (${policyMax})`
+				: ` → raised to policy min (${policyMin})`;
+	}
+
+	// Step 3: explicit user maxBytes is a hard upper bound.
+	if (Number.isFinite(userCap) && effective > userCap) {
+		effective = userCap;
+		reason += ` → capped by user maxBytes (${userCap})`;
+	}
+
+	const withoutEnvelope = Number.isFinite(userCap)
+		? Math.min(userCap, Math.min(policyMax, Math.max(policyMin, defaultMaxBytes)))
+		: Math.min(policyMax, Math.max(policyMin, defaultMaxBytes));
+	const budgetLimited = envelope !== undefined && effective < withoutEnvelope;
+
+	return { effectiveMaxBytes: effective, budgetLimited, budgetReason: reason, batchSize };
+}
+
+/**
+ * Truncate text to a maximum UTF-8 byte length.
+ *
+ * @param text - Source text
+ * @param maxBytes - Maximum number of UTF-8 bytes to keep
+ * @returns Truncated text at a valid character boundary
+ */
+function truncateTextToBytes(text: string, maxBytes: number): string {
+	if (Buffer.byteLength(text, "utf-8") <= maxBytes) return text;
+	let end = Math.min(text.length, maxBytes);
+	while (end > 0 && Buffer.byteLength(text.slice(0, end), "utf-8") > maxBytes) {
+		end -= 1;
+	}
+	return text.slice(0, end);
+}
 
 /**
  * Registers the web_fetch tool.
  * @param pi - Extension API for registering tools
  */
 export default function (pi: ExtensionAPI) {
+	const getBudgetApi = subscribeToBudgetApi(pi.events);
+
 	pi.registerTool({
 		name: "web_fetch",
 		label: "web_fetch",
-		description: `Fetch content from a URL. Returns the page text, truncated to 50KB by default.
+		description: `Fetch content from a URL. Returns page text truncated by context-budget policy (conservative fallback when budget is unknown).
 
 WHEN TO USE:
 - Need to read web page content
@@ -31,7 +138,10 @@ WHEN TO USE:
 		parameters: Type.Object({
 			url: Type.String({ description: "URL to fetch" }),
 			maxBytes: Type.Optional(
-				Type.Number({ description: "Max bytes before truncation (default 50KB)" })
+				Type.Number({
+					description:
+						"Max bytes before truncation (hard upper bound; may be reduced by context budget)",
+				})
 			),
 			format: Type.Optional(
 				Type.Union([Type.Literal("text"), Type.Literal("markdown"), Type.Literal("html")], {
@@ -40,8 +150,20 @@ WHEN TO USE:
 			),
 		}),
 
-		async execute(_toolCallId, params, signal, _onUpdate) {
-			const maxBytes = params.maxBytes ?? DEFAULT_MAX_BYTES;
+		async execute(toolCallId, params, signal, _onUpdate) {
+			// ── Adaptive cap ────────────────────────────────────
+			const budgetApi = getBudgetApi();
+			const envelope = budgetApi?.take(toolCallId) ?? undefined;
+
+			const { effectiveMaxBytes, budgetLimited, budgetReason, batchSize } = resolveAdaptiveCap({
+				userMaxBytes: params.maxBytes,
+				envelope,
+				policyMin: POLICY_MIN_BYTES,
+				policyMax: POLICY_MAX_BYTES,
+				defaultMaxBytes: DEFAULT_MAX_BYTES,
+			});
+
+			const maxBytes = effectiveMaxBytes;
 
 			try {
 				const response = await fetch(params.url, {
@@ -62,10 +184,10 @@ WHEN TO USE:
 
 				const contentType = response.headers.get("content-type") || "";
 				const fullText = await response.text();
-				const totalBytes = new TextEncoder().encode(fullText).length;
+				const totalBytes = Buffer.byteLength(fullText, "utf-8");
 				const truncated = totalBytes > maxBytes;
 
-				let content = truncated ? fullText.slice(0, maxBytes) : fullText;
+				let content = truncated ? truncateTextToBytes(fullText, maxBytes) : fullText;
 
 				if (truncated) {
 					content += `\n\n[Truncated: showing ${(maxBytes / 1024).toFixed(1)}KB of ${(totalBytes / 1024).toFixed(1)}KB]`;
@@ -79,6 +201,10 @@ WHEN TO USE:
 						contentType,
 						totalBytes,
 						truncated,
+						effectiveMaxBytes,
+						budgetLimited,
+						budgetReason,
+						batchSize,
 					},
 				};
 			} catch (error: unknown) {
@@ -106,6 +232,10 @@ WHEN TO USE:
 						isError?: boolean;
 						totalBytes?: number;
 						truncated?: boolean;
+						effectiveMaxBytes?: number;
+						budgetLimited?: boolean;
+						budgetReason?: string;
+						batchSize?: number;
 				  }
 				| undefined;
 			if (!details) {
@@ -120,10 +250,11 @@ WHEN TO USE:
 			} else {
 				const size = details.totalBytes ? ` (${(details.totalBytes / 1024).toFixed(1)}KB)` : "";
 				const truncNote = details.truncated ? " [truncated]" : "";
+				const budgetNote = details.budgetLimited ? " [budget-limited]" : "";
 				footer =
 					theme.fg("success", `${getIcon("success")} `) +
 					theme.fg("dim", details.url ?? "") +
-					theme.fg("muted", size + truncNote);
+					theme.fg("muted", size + truncNote + budgetNote);
 			}
 
 			// Expanded: content preview first, footer last

package/extensions/wezterm-pane-control/__tests__/index.test.ts

@@ -5,6 +5,8 @@ import weztermPaneControl, {
 	buildWeztermPaneGuidance,
 	executeWeztermAction,
 	filterPanesToCurrentTab,
+	hasExplicitPaneRequest,
+	isPaneCreatingAction,
 	type WeztermCliResult,
 	type WeztermPaneInfo,
 } from "../index.js";
@@ -91,17 +93,36 @@ describe("wezterm-pane-control registration", () => {
 });
 
 describe("buildWeztermPaneGuidance", () => {
-	it("includes privacy and manual-monitoring guidance", () => {
+	it("includes privacy and explicit-pane-request guidance", () => {
 		const guidance = buildWeztermPaneGuidance(116);
 		expect(guidance).toContain("Do not run or read commands likely to reveal private secrets");
+		expect(guidance).toContain("Do not split panes or spawn tabs unless the user explicitly asks");
+		expect(guidance).toContain("prefer bg_bash in the current session");
 		expect(guidance).toContain("Default behavior: if you prefill a command");
 		expect(guidance).toContain("Only leave a command unexecuted");
-		expect(guidance).toContain("user wants to monitor output themselves");
+		expect(guidance).toContain("user explicitly asks to monitor output in another pane");
 		expect(guidance).toContain("newline (\\n) via send_text");
 		expect(guidance).toContain("WezTerm pane 116");
 	});
 });
 
+describe("explicit pane-request guards", () => {
+	it("detects explicit pane/tab intent in prompt text", () => {
+		expect(hasExplicitPaneRequest("split a pane to the right and run pnpm dev")).toBe(true);
+		expect(hasExplicitPaneRequest("open a new tab for logs")).toBe(true);
+		expect(hasExplicitPaneRequest("start dev server")).toBe(false);
+		expect(hasExplicitPaneRequest("run tests in background")).toBe(false);
+	});
+
+	it("identifies pane-creating actions", () => {
+		expect(isPaneCreatingAction("split")).toBe(true);
+		expect(isPaneCreatingAction("spawn_tab")).toBe(true);
+		expect(isPaneCreatingAction("move_to_tab")).toBe(true);
+		expect(isPaneCreatingAction("read_text")).toBe(false);
+		expect(isPaneCreatingAction(undefined)).toBe(false);
+	});
+});
+
 describe("filterPanesToCurrentTab", () => {
 	it("returns only panes from the active tab", () => {
 		const panes = [

package/extensions/wezterm-pane-control/index.ts

@@ -110,6 +110,50 @@ const DIRECTIONS: readonly WeztermDirection[] = [
 
 const ZOOM_STATES: readonly WeztermZoomState[] = ["zoom", "unzoom", "toggle"] as const;
 
+const PANE_CREATING_ACTIONS: readonly WeztermAction[] = [
+	"split",
+	"spawn_tab",
+	"move_to_tab",
+] as const;
+
+const EXPLICIT_PANE_REQUEST_PATTERNS: readonly RegExp[] = [
+	/\bwezterm\b/i,
+	/\bpane(?:s)?\b/i,
+	/\btab(?:s)?\b/i,
+	/\bsplit\b/i,
+	/\bspawn\b/i,
+	/\bwindow\b/i,
+	/\bleft\b/i,
+	/\bright\b/i,
+	/\btop\b/i,
+	/\bbottom\b/i,
+] as const;
+
+/**
+ * Check whether an action creates or rehomes panes/tabs.
+ *
+ * @param action - Candidate action string
+ * @returns True when action can open/split/move panes or tabs
+ */
+export function isPaneCreatingAction(action: unknown): action is WeztermAction {
+	if (typeof action !== "string") return false;
+	return PANE_CREATING_ACTIONS.includes(action as WeztermAction);
+}
+
+/**
+ * Determine whether the user explicitly requested pane/tab management.
+ *
+ * This acts as a conservative guardrail: opening/splitting panes should only
+ * happen when the current turn clearly references pane/tab/window controls.
+ *
+ * @param prompt - Current user prompt text
+ * @returns True when prompt contains explicit pane/tab intent
+ */
+export function hasExplicitPaneRequest(prompt: string): boolean {
+	if (prompt.trim().length === 0) return false;
+	return EXPLICIT_PANE_REQUEST_PATTERNS.some((pattern) => pattern.test(prompt));
+}
+
 /**
  * Parse WEZTERM_PANE to a valid pane ID.
  *
@@ -405,9 +449,11 @@ export function buildWeztermPaneGuidance(currentPaneId: number): string {
 		"",
 		"Use best judgment before controlling panes:",
 		"- Do not run or read commands likely to reveal private secrets (keys, tokens, credentials) unless the user explicitly asks.",
+		"- Do not split panes or spawn tabs unless the user explicitly asks for pane/tab management.",
+		"- For long-running commands (dev servers, watchers), prefer bg_bash in the current session unless the user explicitly asks to run them in another pane/tab.",
 		"- Default behavior: if you prefill a command for the user, execute it automatically by sending Enter (newline, \\n).",
 		"- Only leave a command unexecuted when the user explicitly asks to review/edit it before running.",
-		"- If the user wants to monitor output themselves, you can still execute the command and let them watch the pane output directly.",
+		"- If the user explicitly asks to monitor output in another pane, execute the command and let them watch there.",
 		"- Enter can be pressed by sending a newline (\\n) via send_text (either appended to the command or as a second send_text call).",
 	].join("\n");
 }
@@ -597,6 +643,23 @@ export default function weztermPaneControl(pi: ExtensionAPI): void {
 	}
 
 	const runCli = createWeztermRunner(weztermExecutable);
+	let currentTurnPrompt = "";
+
+	pi.on("tool_call", async (event) => {
+		if (event.toolName !== "wezterm_pane") return;
+
+		const input = (event.input ?? {}) as Record<string, unknown>;
+		const action = input.action;
+		if (!isPaneCreatingAction(action)) return;
+		if (hasExplicitPaneRequest(currentTurnPrompt)) return;
+
+		return {
+			block: true,
+			reason:
+				"Opening/splitting WezTerm panes requires an explicit pane/tab request. " +
+				"Use bg_bash for dev servers/watchers unless the user asks for another pane.",
+		};
+	});
 
 	pi.registerTool({
 		name: "wezterm_pane",
@@ -648,6 +711,7 @@ export default function weztermPaneControl(pi: ExtensionAPI): void {
 	});
 
 	pi.on("before_agent_start", async (event) => {
+		currentTurnPrompt = event.prompt;
 		return {
 			systemPrompt: `${event.systemPrompt}\n\n${buildWeztermPaneGuidance(currentPaneId)}`,
 		};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@dungle-scrubs/tallow",
-	"version": "0.8.13",
+	"version": "0.8.15",
 	"description": "An opinionated coding agent. Built on pi.",
 	"piConfig": {
 		"name": "tallow",
@@ -67,7 +67,7 @@
 	"dependencies": {
 		"@clack/prompts": "^1.0.0",
 		"@dungle-scrubs/synapse": "0.1.6",
-		"@mariozechner/pi-coding-agent": "^0.55.1",
+		"@mariozechner/pi-coding-agent": "^0.55.4",
 		"@sinclair/typebox": "0.34.48",
 		"ai": "^6.0.86",
 		"commander": "^14.0.3",
@@ -76,8 +76,8 @@
 	},
 	"devDependencies": {
 		"@biomejs/biome": "2.4.2",
-		"@mariozechner/pi-agent-core": "^0.55.1",
-		"@mariozechner/pi-ai": "^0.55.1",
+		"@mariozechner/pi-agent-core": "^0.55.4",
+		"@mariozechner/pi-ai": "^0.55.4",
 		"@mariozechner/pi-tui": "workspace:*",
 		"@types/node": "25.2.3",
 		"husky": "^9.1.7",

package/skills/tallow-expert/SKILL.md

@@ -87,6 +87,7 @@ Extensions export a default function receiving `ExtensionAPI` (conventionally na
 - `setModel(model: Model<any>)` — Set the current model.
 - `getThinkingLevel()` — Get current thinking level.
 - `setThinkingLevel(level: ThinkingLevel)` — Set thinking level (clamped to model capabilities).
+- `unregisterProvider(name: string)` — Unregister a previously registered provider.
 - `events` — Shared event bus for extension communication.
 
 ### Events (`pi.on(event, handler)`)