gsd-pi 2.80.0-dev.4ea7d80e7 → 2.80.0-dev.7582bf37a

package/packages/pi-coding-agent/src/core/compaction-threshold.test.ts

@@ -0,0 +1,121 @@
+// pi-coding-agent / Regression tests for compaction threshold percent (#5475)
+
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+
+import { shouldCompact, type CompactionSettings } from "./compaction/compaction.js";
+import { SettingsManager } from "./settings-manager.js";
+
+const REGISTRY_DEFAULTS: CompactionSettings = {
+	enabled: true,
+	reserveTokens: 16_384,
+	keepRecentTokens: 20_000,
+};
+
+describe("shouldCompact — thresholdPercent (#5475)", () => {
+	it("uses absolute reserveTokens when thresholdPercent is unset (legacy behavior)", () => {
+		// 200K window, 16384 reserve → fires at 183_617 tokens
+		assert.equal(shouldCompact(183_616, 200_000, REGISTRY_DEFAULTS), false);
+		assert.equal(shouldCompact(183_617, 200_000, REGISTRY_DEFAULTS), true);
+	});
+
+	it("uses thresholdPercent when set, ignoring reserveTokens", () => {
+		const settings: CompactionSettings = { ...REGISTRY_DEFAULTS, thresholdPercent: 0.7 };
+		// 200K * 0.7 = 140_000 → fires above that
+		assert.equal(shouldCompact(140_000, 200_000, settings), false);
+		assert.equal(shouldCompact(140_001, 200_000, settings), true);
+		// reserveTokens-based math would have said false at 183_616 — the percent override changes that
+		assert.equal(shouldCompact(150_000, 200_000, settings), true);
+	});
+
+	it("falls back to reserveTokens when thresholdPercent is out of range", () => {
+		// Defense in depth: reject 0, 1, negative, NaN, Infinity
+		for (const bad of [0, 1, -0.1, 1.5, Number.NaN, Number.POSITIVE_INFINITY]) {
+			const settings: CompactionSettings = { ...REGISTRY_DEFAULTS, thresholdPercent: bad };
+			assert.equal(
+				shouldCompact(183_616, 200_000, settings),
+				false,
+				`bad=${bad} should fall back to reserveTokens math`,
+			);
+			assert.equal(shouldCompact(183_617, 200_000, settings), true, `bad=${bad}`);
+		}
+	});
+
+	it("respects enabled=false regardless of thresholdPercent", () => {
+		const settings: CompactionSettings = {
+			...REGISTRY_DEFAULTS,
+			enabled: false,
+			thresholdPercent: 0.5,
+		};
+		assert.equal(shouldCompact(199_999, 200_000, settings), false);
+	});
+
+	it("scales with contextWindow — same percent, different windows", () => {
+		const settings: CompactionSettings = { ...REGISTRY_DEFAULTS, thresholdPercent: 0.8 };
+		// 100K window: fires above 80_000
+		assert.equal(shouldCompact(80_000, 100_000, settings), false);
+		assert.equal(shouldCompact(80_001, 100_000, settings), true);
+		// 1M window: fires above 800_000
+		assert.equal(shouldCompact(800_000, 1_000_000, settings), false);
+		assert.equal(shouldCompact(800_001, 1_000_000, settings), true);
+	});
+});
+
+describe("SettingsManager — compaction threshold override (#5475)", () => {
+	it("getCompactionThresholdPercent returns undefined by default", () => {
+		const sm = SettingsManager.inMemory({});
+		assert.equal(sm.getCompactionThresholdPercent(), undefined);
+		assert.equal(sm.getCompactionSettings().thresholdPercent, undefined);
+	});
+
+	it("setCompactionThresholdOverride applies in-memory and is exposed via getCompactionSettings", () => {
+		const sm = SettingsManager.inMemory({});
+		sm.setCompactionThresholdOverride(0.7);
+		assert.equal(sm.getCompactionThresholdPercent(), 0.7);
+		assert.equal(sm.getCompactionSettings().thresholdPercent, 0.7);
+	});
+
+	it("setCompactionThresholdOverride(undefined) clears a prior override", () => {
+		const sm = SettingsManager.inMemory({});
+		sm.setCompactionThresholdOverride(0.7);
+		sm.setCompactionThresholdOverride(undefined);
+		assert.equal(sm.getCompactionThresholdPercent(), undefined);
+		assert.equal(sm.getCompactionSettings().thresholdPercent, undefined);
+	});
+
+	it("setCompactionThresholdOverride preserves other compaction fields (enabled, reserveTokens)", () => {
+		const sm = SettingsManager.inMemory({
+			compaction: { enabled: true, reserveTokens: 30_000, keepRecentTokens: 25_000 },
+		});
+		sm.setCompactionThresholdOverride(0.6);
+		const settings = sm.getCompactionSettings();
+		assert.equal(settings.enabled, true);
+		assert.equal(settings.reserveTokens, 30_000);
+		assert.equal(settings.keepRecentTokens, 25_000);
+		assert.equal(settings.thresholdPercent, 0.6);
+	});
+
+	it("setCompactionThresholdOverride works when no compaction config exists yet", () => {
+		const sm = SettingsManager.inMemory({});
+		sm.setCompactionThresholdOverride(0.85);
+		assert.equal(sm.getCompactionThresholdPercent(), 0.85);
+		// Other compaction fields fall back to their defaults
+		const settings = sm.getCompactionSettings();
+		assert.equal(settings.enabled, true);
+		assert.equal(typeof settings.reserveTokens, "number");
+		assert.equal(typeof settings.keepRecentTokens, "number");
+	});
+});
+
+describe("end-to-end — getCompactionSettings + shouldCompact (#5475)", () => {
+	it("70% threshold on a 200K window fires at the documented bug-report value (140_001 not 183_617)", () => {
+		const sm = SettingsManager.inMemory({});
+		sm.setCompactionThresholdOverride(0.7);
+		const settings = sm.getCompactionSettings();
+
+		assert.equal(shouldCompact(140_000, 200_000, settings), false);
+		assert.equal(shouldCompact(140_001, 200_000, settings), true);
+		// Pre-fix behavior would have required 183_617 — verify we no longer wait that long
+		assert.equal(shouldCompact(150_000, 200_000, settings), true);
+	});
+});

package/packages/pi-coding-agent/src/core/db-snapshot.test.ts

@@ -0,0 +1,32 @@
+import assert from "node:assert/strict";
+import { describe, it, afterEach } from "node:test";
+import { existsSync, mkdtempSync, readFileSync, readdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { atomicWriteDbSnapshotSync } from "./db-snapshot.js";
+
+describe("atomicWriteDbSnapshotSync", () => {
+	let dir: string;
+
+	afterEach(() => {
+		if (dir) {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("writes the full snapshot and leaves no temp file after success", () => {
+		dir = mkdtempSync(join(tmpdir(), "gsd-db-snapshot-test-"));
+		const dbPath = join(dir, "agent.db");
+		const snapshot = new Uint8Array([0x53, 0x51, 0x4c, 0x69, 0x74, 0x65]);
+
+		atomicWriteDbSnapshotSync(dbPath, snapshot);
+
+		assert.deepEqual(readFileSync(dbPath), Buffer.from(snapshot));
+		assert.equal(existsSync(`${dbPath}.tmp`), false);
+		assert.deepEqual(
+			readdirSync(dir).filter((entry) => entry.includes("agent.db") && entry.includes(".tmp")),
+			[],
+		);
+	});
+});

package/packages/pi-coding-agent/src/core/db-snapshot.ts

@@ -0,0 +1,66 @@
+import { randomUUID } from "node:crypto";
+import { closeSync, fsyncSync, openSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+
+export type DbSnapshot = Buffer | Uint8Array;
+
+function closeBestEffort(fd: number | null): void {
+	if (fd === null) return;
+	try {
+		closeSync(fd);
+	} catch {
+		// Preserve the original write/rename failure when cleaning up.
+	}
+}
+
+function fsyncDirectoryBestEffort(dirPath: string): void {
+	let fd: number | null = null;
+	try {
+		fd = openSync(dirPath, "r");
+		fsyncSync(fd);
+	} catch {
+		// Directory fsync is unsupported on some platforms/filesystems.
+	} finally {
+		closeBestEffort(fd);
+	}
+}
+
+/**
+ * Persist a sql.js database export without exposing callers to a torn live file.
+ *
+ * The snapshot is written to a unique temp file in the same directory, flushed,
+ * then renamed over the target. A hard kill during the temp write leaves the
+ * previous target intact; after rename, readers see the complete new snapshot.
+ *
+ * The rename replaces the target inode: existing file mode/ownership is not
+ * preserved, and a symlink at dbPath is replaced rather than written through.
+ * Agent DB snapshots are owned runtime files, so this trade-off favors a
+ * private 0600 replacement over retaining prior target metadata.
+ */
+export function atomicWriteDbSnapshotSync(dbPath: string, snapshot: DbSnapshot): void {
+	const dirPath = dirname(dbPath);
+	const tmpPath = join(dirPath, `.${basename(dbPath)}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`);
+	let fd: number | null = null;
+	let renamed = false;
+
+	try {
+		fd = openSync(tmpPath, "wx", 0o600);
+		writeFileSync(fd, Buffer.from(snapshot));
+		fsyncSync(fd);
+		closeSync(fd);
+		fd = null;
+
+		renameSync(tmpPath, dbPath);
+		renamed = true;
+		fsyncDirectoryBestEffort(dirPath);
+	} finally {
+		closeBestEffort(fd);
+		if (!renamed) {
+			try {
+				unlinkSync(tmpPath);
+			} catch {
+				// The temp file may not have been created yet.
+			}
+		}
+	}
+}

package/packages/pi-coding-agent/src/core/extensions/loader.ts

@@ -415,6 +415,8 @@ export function createExtensionRuntime(): ExtensionRuntime {
 		getActiveTools: notInitialized,
 		getAllTools: notInitialized,
 		setActiveTools: notInitialized,
+		getVisibleSkills: notInitialized,
+		setVisibleSkills: notInitialized,
 		// registerTool() is valid during extension load; refresh is only needed post-bind.
 		refreshTools: () => {},
 		getCommands: notInitialized,
@@ -566,6 +568,14 @@ function createExtensionAPI(
 			runtime.setActiveTools(toolNames);
 		},
 
+		getVisibleSkills(): string[] | undefined {
+			return runtime.getVisibleSkills();
+		},
+
+		setVisibleSkills(skillNames: string[] | undefined): void {
+			runtime.setVisibleSkills(skillNames);
+		},
+
 		getCommands() {
 			return runtime.getCommands();
 		},

package/packages/pi-coding-agent/src/core/extensions/runner.test.ts

@@ -141,6 +141,7 @@ describe("ExtensionRunner.emitToolCall", () => {
 			getContextUsage: () => undefined,
 			compact: () => {},
 			getSystemPrompt: () => "",
+			setCompactionThresholdOverride: () => {},
 		});
 
 		const errors: any[] = [];
@@ -159,7 +160,7 @@ describe("ExtensionRunner.emitToolCall", () => {
 });
 
 describe("ExtensionRunner.createContext", () => {
-	it("uses the live process cwd instead of the constructor cwd", (t) => {
+	it("uses the constructor workspace root instead of ambient process cwd", (t) => {
 		const originalCwd = process.cwd();
 		const dir = mkdtempSync(join(tmpdir(), "runner-test-"));
 		const projectDir = join(dir, "project");
@@ -178,8 +179,8 @@ describe("ExtensionRunner.createContext", () => {
 		const realProjectDir = realpathSync(projectDir);
 		process.chdir(realProjectDir);
 
-		assert.equal(runner.createContext().cwd, realProjectDir);
-		assert.equal(runner.createCommandContext().cwd, realProjectDir);
+		assert.equal(runner.createContext().cwd, originalCwd);
+		assert.equal(runner.createCommandContext().cwd, originalCwd);
 	});
 
 	it("does not let lifecycle event handlers close the TUI", async (t) => {
@@ -220,6 +221,7 @@ describe("ExtensionRunner.createContext", () => {
 			getContextUsage: () => undefined,
 			compact: () => {},
 			getSystemPrompt: () => "",
+			setCompactionThresholdOverride: () => {},
 		});
 
 		const errors: any[] = [];

package/packages/pi-coding-agent/src/core/extensions/runner.ts

@@ -173,6 +173,8 @@ export type ExtensionErrorListener = (error: ExtensionError) => void;
 export type NewSessionHandler = (options?: {
 	parentSession?: string;
 	setup?: (sessionManager: SessionManager) => Promise<void>;
+	/** Explicit workspace root for the new session/tool runtime. */
+	workspaceRoot?: string;
 	/** See ExtensionCommandContext.newSession for docs (#3731). */
 	abortSignal?: AbortSignal;
 }) => Promise<{ cancelled: boolean }>;
@@ -235,6 +237,7 @@ export class ExtensionRunner {
 	private getContextUsageFn: () => ContextUsage | undefined = () => undefined;
 	private compactFn: (options?: CompactOptions) => void = () => {};
 	private getSystemPromptFn: () => string = () => "";
+	private setCompactionThresholdOverrideFn: (percent: number | undefined) => void = () => {};
 	private newSessionHandler: NewSessionHandler = async () => {
 		throw new Error("Command context not yet bound: newSession is unavailable during early lifecycle");
 	};
@@ -274,11 +277,7 @@ export class ExtensionRunner {
 	}
 
 	private currentCwd(): string {
-		try {
-			return process.cwd();
-		} catch {
-			return this.cwd;
-		}
+		return this.cwd;
 	}
 
 	/**
@@ -413,6 +412,8 @@ export class ExtensionRunner {
 		this.runtime.getActiveTools = actions.getActiveTools;
 		this.runtime.getAllTools = actions.getAllTools;
 		this.runtime.setActiveTools = actions.setActiveTools;
+		this.runtime.getVisibleSkills = actions.getVisibleSkills;
+		this.runtime.setVisibleSkills = actions.setVisibleSkills;
 		this.runtime.refreshTools = actions.refreshTools;
 		this.runtime.getCommands = actions.getCommands;
 		this.runtime.setModel = actions.setModel;
@@ -428,6 +429,7 @@ export class ExtensionRunner {
 		this.getContextUsageFn = contextActions.getContextUsage;
 		this.compactFn = contextActions.compact;
 		this.getSystemPromptFn = contextActions.getSystemPrompt;
+		this.setCompactionThresholdOverrideFn = contextActions.setCompactionThresholdOverride;
 
 		// Flush provider registrations queued during extension loading
 		for (const { name, config } of this.runtime.pendingProviderRegistrations) {
@@ -714,6 +716,7 @@ export class ExtensionRunner {
 			getContextUsage: () => this.getContextUsageFn(),
 			compact: (options) => this.compactFn(options),
 			getSystemPrompt: () => this.getSystemPromptFn(),
+			setCompactionThresholdOverride: (percent) => this.setCompactionThresholdOverrideFn(percent),
 		};
 	}
 

package/packages/pi-coding-agent/src/core/extensions/types.ts

@@ -69,6 +69,7 @@ import type {
 	LsToolInput,
 	ReadToolDetails,
 	ReadToolInput,
+	WriteToolDetails,
 	WriteToolInput,
 } from "../tools/index.js";
 
@@ -289,6 +290,12 @@ export interface ExtensionContext {
 	compact(options?: CompactOptions): void;
 	/** Get the current effective system prompt. */
 	getSystemPrompt(): string;
+	/**
+	 * Set or clear an in-memory compaction threshold-percent override (0 < value < 1).
+	 * Pass `undefined` to clear. The override is not persisted; host integrations
+	 * are expected to re-apply on each session_start.
+	 */
+	setCompactionThresholdOverride(percent: number | undefined): void;
 }
 
 /**
@@ -303,10 +310,13 @@ export interface ExtensionCommandContext extends ExtensionContext {
 	newSession(options?: {
 		parentSession?: string;
 		setup?: (sessionManager: SessionManager) => Promise<void>;
+		/** Explicit workspace root for the new session/tool runtime.
+		 *  When omitted, newSession() captures process.cwd() for backwards compatibility. */
+		workspaceRoot?: string;
 		/** When aborted before the session is fully configured, newSession() returns
 		 *  early without rebuilding the tool runtime. Used by runUnit() to discard
 		 *  a late-resolving newSession() after the session-creation timeout fires,
-		 *  preventing the tool runtime from being rebuilt with the wrong cwd (#3731). */
+		 *  preventing the tool runtime from being rebuilt with a stale workspace root (#3731). */
 		abortSignal?: AbortSignal;
 	}): Promise<{ cancelled: boolean }>;
 
@@ -842,6 +852,13 @@ export interface BeforeModelSelectResult {
 	modelId: string;
 }
 
+export interface AdjustToolSetRequestCustomMessage {
+	/** Index in the post-transform AgentMessage context. */
+	index: number;
+	/** Custom message type only; prompt/content text is intentionally omitted. */
+	customType: string;
+}
+
 /**
  * Fired after model selection to allow extensions to adjust the active tool set (ADR-005 Phase 4).
  * Extensions can add, remove, or reorder tools based on the selected model's provider capabilities.
@@ -858,6 +875,12 @@ export interface AdjustToolSetEvent {
 	activeToolNames: string[];
 	/** Tools already filtered by provider compatibility */
 	filteredTools: string[];
+	/**
+	 * Custom message metadata in the current request tail, measured from the
+	 * latest assistant message. This is metadata-only so extensions can scope
+	 * queued custom-message turns without seeing raw prompt content.
+	 */
+	requestCustomMessages?: AdjustToolSetRequestCustomMessage[];
 }
 
 /** Result from adjust_tool_set event handler. Return { toolNames } to override tool set. */
@@ -1009,7 +1032,7 @@ export interface EditToolResultEvent extends ToolResultEventBase {
 
 export interface WriteToolResultEvent extends ToolResultEventBase {
 	toolName: "write";
-	details: undefined;
+	details: WriteToolDetails | undefined;
 }
 
 export interface GrepToolResultEvent extends ToolResultEventBase {
@@ -1480,6 +1503,20 @@ export interface ExtensionAPI {
 	/** Set the active tools by name. */
 	setActiveTools(toolNames: string[]): void;
 
+	/**
+	 * Get the prompt-only skill catalog filter, if one is active.
+	 * Undefined means all loaded skills remain visible in <available_skills>.
+	 */
+	getVisibleSkills(): string[] | undefined;
+
+	/**
+	 * Set or clear the prompt-only skill catalog filter.
+	 *
+	 * This changes which loaded skills are advertised in <available_skills>;
+	 * it does not unload skills or disable the Skill tool.
+	 */
+	setVisibleSkills(skillNames: string[] | undefined): void;
+
 	/** Get available slash commands in the current session. */
 	getCommands(): SlashCommandInfo[];
 
@@ -1721,6 +1758,8 @@ export interface ExtensionActions {
 	getActiveTools: () => string[];
 	getAllTools: () => ToolInfo[];
 	setActiveTools: (toolNames: string[]) => void;
+	getVisibleSkills: () => string[] | undefined;
+	setVisibleSkills: (skillNames: string[] | undefined) => void;
 	refreshTools: () => void;
 	getCommands: () => SlashCommandInfo[];
 	setModel: (model: Model<any>, options?: { persist?: boolean }) => Promise<boolean>;
@@ -1741,6 +1780,7 @@ export interface ExtensionContextActions {
 	getContextUsage: () => ContextUsage | undefined;
 	compact: (options?: CompactOptions) => void;
 	getSystemPrompt: () => string;
+	setCompactionThresholdOverride: (percent: number | undefined) => void;
 }
 
 /**
@@ -1752,6 +1792,8 @@ export interface ExtensionCommandContextActions {
 	newSession: (options?: {
 		parentSession?: string;
 		setup?: (sessionManager: SessionManager) => Promise<void>;
+		/** See ExtensionCommandContext.newSession for docs. */
+		workspaceRoot?: string;
 		/** See ExtensionCommandContext.newSession for docs (#3731). */
 		abortSignal?: AbortSignal;
 	}) => Promise<{ cancelled: boolean }>;

package/packages/pi-coding-agent/src/core/hooks-runner.test.ts

@@ -38,6 +38,8 @@ function stubRuntime(): ExtensionRuntime {
     getActiveTools: () => [],
     getAllTools: () => [],
     setActiveTools: () => {},
+    getVisibleSkills: () => undefined,
+    setVisibleSkills: () => {},
     refreshTools: () => {},
     getCommands: () => [],
     setModel: async () => false,

package/packages/pi-coding-agent/src/core/sdk-tool-filter.test.ts

@@ -0,0 +1,60 @@
+// Project/App: GSD-2
+// File Purpose: Tests final provider request-time tool compatibility filtering.
+
+import assert from "node:assert/strict";
+import test from "node:test";
+import { Type } from "@sinclair/typebox";
+import type { AgentTool } from "@gsd/pi-agent-core";
+import { filterToolsForProviderRequest, getAdjustToolSetRequestCustomMessages } from "./sdk.js";
+import { registerToolCompatibility, resetToolCompatibilityRegistry } from "./tools/tool-compatibility-registry.js";
+
+function tool(name: string): AgentTool {
+	return {
+		name,
+		label: name,
+		description: name,
+		parameters: Type.Object({}),
+		execute: async () => ({ content: [], details: undefined }),
+	};
+}
+
+test("filterToolsForProviderRequest removes provider-incompatible tools", () => {
+	resetToolCompatibilityRegistry();
+	try {
+		registerToolCompatibility("image_result_tool", { producesImages: true });
+		registerToolCompatibility("complex_schema_tool", { schemaFeatures: ["patternProperties"] });
+
+		const result = filterToolsForProviderRequest(
+			[tool("bash"), tool("image_result_tool"), tool("complex_schema_tool")],
+			{ api: "google-generative-ai", provider: "google" },
+		);
+
+		assert.deepEqual(result.compatible.map((entry) => entry.name), ["bash", "image_result_tool"]);
+		assert.deepEqual(result.filtered.map((entry) => entry.name), ["complex_schema_tool"]);
+	} finally {
+		resetToolCompatibilityRegistry();
+	}
+});
+
+test("filterToolsForProviderRequest enforces provider-specific hard caps at send time", () => {
+	const result = filterToolsForProviderRequest(
+		Array.from({ length: 130 }, (_, index) => tool(`tool_${index}`)),
+		{ api: "openai-completions", provider: "groq" },
+	);
+
+	assert.equal(result.compatible.length, 128);
+	assert.deepEqual(result.filtered.map((entry) => entry.name), ["tool_128", "tool_129"]);
+});
+
+test("getAdjustToolSetRequestCustomMessages only reports custom messages in the current request tail", () => {
+	const messages = [
+		{ role: "custom", customType: "gsd-run", content: "old workflow", display: false, timestamp: 1 },
+		{ role: "assistant", content: [{ type: "text", text: "done" }], timestamp: 2 },
+		{ role: "user", content: [{ type: "text", text: "normal prompt" }], timestamp: 3 },
+		{ role: "custom", customType: "gsd-doctor-heal", content: "current workflow", display: false, timestamp: 4 },
+	] as any[];
+
+	assert.deepEqual(getAdjustToolSetRequestCustomMessages(messages), [
+		{ index: 3, customType: "gsd-doctor-heal" },
+	]);
+});

package/packages/pi-coding-agent/src/core/sdk.ts

@@ -1,3 +1,4 @@
+// GSD2 - Coding agent session factory and runtime wiring
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 
@@ -38,8 +39,53 @@ export function canRestoreSessionModel(
 ): boolean {
 	return modelRegistry.isProviderRequestReady(model.provider);
 }
-import { Agent, type AgentMessage, type ThinkingLevel } from "@gsd/pi-agent-core";
-import type { Message, Model } from "@gsd/pi-ai";
+
+const PROVIDER_TOOL_LIMITS: Record<string, number> = {
+	groq: 128,
+};
+
+function resolveProviderToolLimit(
+	providerCaps: ReturnType<typeof getProviderCapabilities>,
+	provider: string | undefined,
+): number {
+	if (provider && PROVIDER_TOOL_LIMITS[provider]) {
+		return PROVIDER_TOOL_LIMITS[provider];
+	}
+	return providerCaps.maxTools > 0 ? providerCaps.maxTools : 0;
+}
+
+export function filterToolsForProviderRequest(
+	tools: AgentTool[],
+	model: Pick<Model<any>, "api" | "provider">,
+): { compatible: AgentTool[]; filtered: AgentTool[] } {
+	const providerCaps = getProviderCapabilities(model.api);
+	if (!providerCaps.toolCalling) {
+		return { compatible: [], filtered: tools };
+	}
+
+	const compatible: AgentTool[] = [];
+	const filtered: AgentTool[] = [];
+	for (const tool of tools) {
+		const compat = getToolCompatibility(tool.name);
+		if (
+			(compat?.producesImages && !providerCaps.imageToolResults) ||
+			compat?.schemaFeatures?.some((feature) => providerCaps.unsupportedSchemaFeatures.includes(feature))
+		) {
+			filtered.push(tool);
+		} else {
+			compatible.push(tool);
+		}
+	}
+
+	const toolLimit = resolveProviderToolLimit(providerCaps, model.provider);
+	if (toolLimit > 0 && compatible.length > toolLimit) {
+		filtered.push(...compatible.splice(toolLimit));
+	}
+
+	return { compatible, filtered };
+}
+import { Agent, maybeLogProviderPayloadAudit, type AgentMessage, type AgentTool, type ThinkingLevel } from "@gsd/pi-agent-core";
+import { getProviderCapabilities, type Message, type Model } from "@gsd/pi-ai";
 import { getAgentDir, getDocsPath } from "../config.js";
 import { AgentSession } from "./agent-session.js";
 import { AuthStorage } from "./auth-storage.js";
@@ -82,6 +128,22 @@ import {
 	type ToolName,
 	writeTool,
 } from "./tools/index.js";
+import { getToolCompatibility } from "./tools/tool-compatibility-registry.js";
+
+export function getAdjustToolSetRequestCustomMessages(
+	messages: readonly AgentMessage[] | undefined,
+): Array<{ index: number; customType: string }> {
+	if (!messages) return [];
+	const requestMessages: Array<{ index: number; customType: string }> = [];
+	for (let index = messages.length - 1; index >= 0; index--) {
+		const message = messages[index] as { role?: unknown; customType?: unknown };
+		if (message?.role === "assistant") break;
+		if (message?.role === "custom" && typeof message.customType === "string") {
+			requestMessages.push({ index, customType: message.customType });
+		}
+	}
+	return requestMessages.reverse();
+}
 
 export interface CreateAgentSessionOptions {
 	/** Working directory for project-local discovery. Default: process.cwd() */
@@ -378,6 +440,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	};
 
 	const extensionRunnerRef: { current?: ExtensionRunner } = {};
+	const workspaceRootRef: { current: string } = { current: cwd };
 
 	agent = new Agent({
 		initialState: {
@@ -390,9 +453,12 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		onPayload: async (payload, currentModel) => {
 			const runner = extensionRunnerRef.current;
 			if (!runner?.hasHandlers("before_provider_request")) {
+				maybeLogProviderPayloadAudit(payload, "before_provider_request:unchanged");
 				return payload;
 			}
-			return runner.emitBeforeProviderRequest(payload, currentModel);
+			const nextPayload = await runner.emitBeforeProviderRequest(payload, currentModel);
+			maybeLogProviderPayloadAudit(nextPayload, "before_provider_request:after");
+			return nextPayload;
 		},
 		sessionId: sessionManager.getSessionId(),
 		transformContext: async (messages) => {
@@ -400,6 +466,24 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			if (!runner) return messages;
 			return runner.emitContext(messages);
 		},
+		filterTools: async (tools, _signal, messages) => {
+			const currentModel = agent.state.activeInferenceModel ?? agent.state.model ?? model;
+			if (!currentModel) return tools;
+			const providerFiltered = filterToolsForProviderRequest(tools, currentModel);
+			const runner = extensionRunnerRef.current;
+			if (!runner?.hasHandlers("adjust_tool_set")) return providerFiltered.compatible;
+			const result = await runner.emitAdjustToolSet({
+				selectedModelApi: currentModel.api,
+				selectedModelProvider: currentModel.provider,
+				selectedModelId: currentModel.id,
+				activeToolNames: providerFiltered.compatible.map((tool) => tool.name),
+				filteredTools: providerFiltered.filtered.map((tool) => tool.name),
+				requestCustomMessages: getAdjustToolSetRequestCustomMessages(messages),
+			});
+			if (!result?.toolNames) return providerFiltered.compatible;
+			const allowedNames = new Set(result.toolNames);
+			return providerFiltered.compatible.filter((tool) => allowedNames.has(tool.name));
+		},
 		steeringMode: settingsManager.getSteeringMode(),
 		followUpMode: settingsManager.getFollowUpMode(),
 		transport: settingsManager.getTransport(),
@@ -409,8 +493,11 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		getProviderOptions: async (currentModel) => {
 			if (currentModel.provider !== "claude-code") return undefined;
 			const runner = extensionRunnerRef.current;
-			if (!runner?.hasUI()) return undefined;
+			if (!runner?.hasUI()) {
+				return { cwd: workspaceRootRef.current };
+			}
 			return {
+				cwd: workspaceRootRef.current,
 				extensionUIContext: runner.getUIContext(),
 			};
 		},
@@ -554,6 +641,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		modelRegistry,
 		initialActiveToolNames,
 		extensionRunnerRef,
+		workspaceRootRef,
 		isClaudeCodeReady: options.isClaudeCodeReady,
 	});
 	const extensionsResult = resourceLoader.getExtensions();