gsd-pi 2.80.0-dev.42bd34838 → 2.80.0-dev.488219eb6

package/packages/pi-coding-agent/dist/resources/extensions/memory/storage-safety-guard.test.js

@@ -1,10 +1,28 @@
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { lstatSync, mkdtempSync, readFileSync, rmSync, symlinkSync } from "node:fs";
+import { tmpdir } from "node:os";
 import { join } from "node:path";
 import test from "node:test";
-test("MemoryStorage persists sql.js snapshots through the atomic DB snapshot writer", () => {
-    const src = readFileSync(join(process.cwd(), "packages", "pi-coding-agent", "src", "resources", "extensions", "memory", "storage.ts"), "utf-8");
-    assert.match(src, /atomicWriteDbSnapshotSync\(/, "storage must use atomic DB snapshot writes");
-    assert.doesNotMatch(src, /writeFileSync\(this\.dbPath/, "direct live DB overwrite is forbidden");
+import { MemoryStorage } from "./storage.js";
+test("MemoryStorage replaces a symlinked DB path instead of overwriting the symlink target", async (t) => {
+    const dir = mkdtempSync(join(tmpdir(), "memory-storage-atomic-"));
+    t.after(() => rmSync(dir, { recursive: true, force: true }));
+    const canaryPath = join(dir, "canary.txt");
+    const dbPath = join(dir, "memory.db");
+    const canaryStorage = await MemoryStorage.create(canaryPath);
+    canaryStorage.close();
+    const originalCanary = readFileSync(canaryPath);
+    symlinkSync(canaryPath, dbPath);
+    const storage = await MemoryStorage.create(dbPath);
+    storage.upsertThreads([{
+            threadId: "thread-1",
+            filePath: join(dir, "thread.jsonl"),
+            fileSize: 1,
+            fileMtime: 1,
+            cwd: dir,
+        }]);
+    storage.close();
+    assert.deepEqual(readFileSync(canaryPath), originalCanary);
+    assert.equal(lstatSync(dbPath).isSymbolicLink(), false, "atomic snapshot write should replace the symlink");
 });
 //# sourceMappingURL=storage-safety-guard.test.js.map

package/packages/pi-coding-agent/dist/resources/extensions/memory/storage-safety-guard.test.js.map

@@ -1 +1 @@
-{"version":3,"file":"storage-safety-guard.test.js","sourceRoot":"","sources":["../../../../src/resources/extensions/memory/storage-safety-guard.test.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,oBAAoB,CAAC;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,IAAI,MAAM,WAAW,CAAC;AAE7B,IAAI,CAAC,+EAA+E,EAAE,GAAG,EAAE;IAC1F,MAAM,GAAG,GAAG,YAAY,CACvB,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,UAAU,EAAE,iBAAiB,EAAE,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,QAAQ,EAAE,YAAY,CAAC,EAC5G,OAAO,CACP,CAAC;IAEF,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,6BAA6B,EAAE,4CAA4C,CAAC,CAAC;IAC/F,MAAM,CAAC,YAAY,CAAC,GAAG,EAAE,6BAA6B,EAAE,uCAAuC,CAAC,CAAC;AAClG,CAAC,CAAC,CAAC","sourcesContent":["import assert from \"node:assert/strict\";\nimport { readFileSync } from \"node:fs\";\nimport { join } from \"node:path\";\nimport test from \"node:test\";\n\ntest(\"MemoryStorage persists sql.js snapshots through the atomic DB snapshot writer\", () => {\n\tconst src = readFileSync(\n\t\tjoin(process.cwd(), \"packages\", \"pi-coding-agent\", \"src\", \"resources\", \"extensions\", \"memory\", \"storage.ts\"),\n\t\t\"utf-8\",\n\t);\n\n\tassert.match(src, /atomicWriteDbSnapshotSync\\(/, \"storage must use atomic DB snapshot writes\");\n\tassert.doesNotMatch(src, /writeFileSync\\(this\\.dbPath/, \"direct live DB overwrite is forbidden\");\n});\n"]}
+{"version":3,"file":"storage-safety-guard.test.js","sourceRoot":"","sources":["../../../../src/resources/extensions/memory/storage-safety-guard.test.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,oBAAoB,CAAC;AACxC,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AACpF,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AACjC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAE7C,IAAI,CAAC,sFAAsF,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE;IACxG,MAAM,GAAG,GAAG,WAAW,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,wBAAwB,CAAC,CAAC,CAAC;IAClE,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;IAE7D,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,EAAE,YAAY,CAAC,CAAC;IAC3C,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC;IACtC,MAAM,aAAa,GAAG,MAAM,aAAa,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;IAC7D,aAAa,CAAC,KAAK,EAAE,CAAC;IACtB,MAAM,cAAc,GAAG,YAAY,CAAC,UAAU,CAAC,CAAC;IAChD,WAAW,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;IAEhC,MAAM,OAAO,GAAG,MAAM,aAAa,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IACnD,OAAO,CAAC,aAAa,CAAC,CAAC;YACtB,QAAQ,EAAE,UAAU;YACpB,QAAQ,EAAE,IAAI,CAAC,GAAG,EAAE,cAAc,CAAC;YACnC,QAAQ,EAAE,CAAC;YACX,SAAS,EAAE,CAAC;YACZ,GAAG,EAAE,GAAG;SACR,CAAC,CAAC,CAAC;IACJ,OAAO,CAAC,KAAK,EAAE,CAAC;IAEhB,MAAM,CAAC,SAAS,CAAC,YAAY,CAAC,UAAU,CAAC,EAAE,cAAc,CAAC,CAAC;IAC3D,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,cAAc,EAAE,EAAE,KAAK,EAAE,kDAAkD,CAAC,CAAC;AAC7G,CAAC,CAAC,CAAC","sourcesContent":["import assert from \"node:assert/strict\";\nimport { lstatSync, mkdtempSync, readFileSync, rmSync, symlinkSync } from \"node:fs\";\nimport { tmpdir } from \"node:os\";\nimport { join } from \"node:path\";\nimport test from \"node:test\";\nimport { MemoryStorage } from \"./storage.js\";\n\ntest(\"MemoryStorage replaces a symlinked DB path instead of overwriting the symlink target\", async (t) => {\n\tconst dir = mkdtempSync(join(tmpdir(), \"memory-storage-atomic-\"));\n\tt.after(() => rmSync(dir, { recursive: true, force: true }));\n\n\tconst canaryPath = join(dir, \"canary.txt\");\n\tconst dbPath = join(dir, \"memory.db\");\n\tconst canaryStorage = await MemoryStorage.create(canaryPath);\n\tcanaryStorage.close();\n\tconst originalCanary = readFileSync(canaryPath);\n\tsymlinkSync(canaryPath, dbPath);\n\n\tconst storage = await MemoryStorage.create(dbPath);\n\tstorage.upsertThreads([{\n\t\tthreadId: \"thread-1\",\n\t\tfilePath: join(dir, \"thread.jsonl\"),\n\t\tfileSize: 1,\n\t\tfileMtime: 1,\n\t\tcwd: dir,\n\t}]);\n\tstorage.close();\n\n\tassert.deepEqual(readFileSync(canaryPath), originalCanary);\n\tassert.equal(lstatSync(dbPath).isSymbolicLink(), false, \"atomic snapshot write should replace the symlink\");\n});\n"]}

package/packages/pi-coding-agent/src/core/agent-session-tool-refresh.test.ts

@@ -130,4 +130,29 @@ describe("#3616 — newSession() restores narrowed tool set when cwd unchanged",
 			"cwd-changed branch must rebuild with includeAllExtensionTools: true",
 		);
 	});
+
+	it("uses explicit workspaceRoot option instead of process.cwd() when rebuilding runtime", async () => {
+		const session = await createSession();
+		const explicitWorkspaceRoot = mkdtempSync(join(testDir, "explicit-workspace-"));
+		(session as any)._cwd = process.cwd();
+
+		let buildRuntimeCalled = false;
+		let capturedBuildOptions: { includeAllExtensionTools?: boolean } | undefined;
+		const originalBuild = (session as any)._buildRuntime.bind(session);
+		(session as any)._buildRuntime = (options?: { includeAllExtensionTools?: boolean }) => {
+			buildRuntimeCalled = true;
+			capturedBuildOptions = options;
+			return originalBuild(options);
+		};
+
+		const ok = await session.newSession({ workspaceRoot: explicitWorkspaceRoot });
+		assert.equal(ok, true);
+		assert.equal((session as any)._cwd, explicitWorkspaceRoot);
+		assert.ok(buildRuntimeCalled, "explicit workspace root differing from prior root must rebuild runtime");
+		assert.strictEqual(
+			capturedBuildOptions?.includeAllExtensionTools,
+			true,
+			"explicit workspaceRoot rebuild must pass includeAllExtensionTools: true",
+		);
+	});
 });

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

@@ -305,6 +305,8 @@ export class AgentSession {
 
 	// Base system prompt (without extension appends) - used to apply fresh appends each turn
 	private _baseSystemPrompt = "";
+	// Optional prompt-only skill catalog filter. Skills remain loaded and invocable by name.
+	private _visibleSkillNames: Set<string> | undefined = undefined;
 
 	constructor(config: AgentSessionConfig) {
 		this.agent = config.agent;
@@ -867,6 +869,25 @@ export class AgentSession {
 		this.agent.setSystemPrompt(this._baseSystemPrompt);
 	}
 
+	/**
+	 * Set or clear a prompt-only filter for the <available_skills> catalog.
+	 *
+	 * This does not unload skills or disable the Skill tool. It only controls
+	 * which loaded skills are advertised in the system prompt on rebuild.
+	 */
+	setVisibleSkillsByName(skillNames: string[] | undefined): void {
+		this._visibleSkillNames = skillNames === undefined
+			? undefined
+			: new Set(skillNames.map((name) => name.trim().toLowerCase()).filter(Boolean));
+		this._baseSystemPrompt = this._rebuildSystemPrompt(this.getActiveToolNames());
+		this.agent.setSystemPrompt(this._baseSystemPrompt);
+	}
+
+	/** Get the current prompt-only skill catalog filter, if one is active. */
+	getVisibleSkillNames(): string[] | undefined {
+		return this._visibleSkillNames ? [...this._visibleSkillNames] : undefined;
+	}
+
 	/** Whether compaction or branch summarization is currently running */
 	get isCompacting(): boolean {
 		return this._compactionOrchestrator.isCompacting;
@@ -1045,6 +1066,9 @@ export class AgentSession {
 		return buildSystemPrompt({
 			cwd: this._cwd,
 			skills: loadedSkills,
+			skillFilter: this._visibleSkillNames
+				? (skill) => this._visibleSkillNames!.has(skill.name.trim().toLowerCase())
+				: undefined,
 			contextFiles: loadedContextFiles,
 			customPrompt: loaderSystemPrompt,
 			appendSystemPrompt,
@@ -1645,6 +1669,8 @@ export class AgentSession {
 	async newSession(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<boolean> {
@@ -1666,10 +1692,10 @@ export class AgentSession {
 		try {
 			await this._settleCurrentTurnForSessionTransition();
 
-			// #3731: If the caller aborted (e.g. runUnit() timed out and restored cwd to
-			// project root), discard this session before capturing process.cwd() and
-			// rebuilding the tool runtime. Without this check, the late newSession()
-			// would rebuild tools with root cwd, breaking worktree isolation.
+			// #3731: If the caller aborted (e.g. runUnit() timed out while the
+			// worktree was being torn down), discard this session before rebuilding
+			// the tool runtime. Without this check, the late newSession() could
+			// rebuild tools with a stale workspace root.
 			if (options?.abortSignal?.aborted) {
 				return false;
 			}
@@ -1679,15 +1705,18 @@ export class AgentSession {
 		} finally {
 			this._sessionSwitchPending = false;
 		}
-		// Update cwd to current process directory — auto-mode may have chdir'd
-		// into a worktree since the original session was created.
+		// Update the workspace root for the new tool runtime. Auto-mode passes
+		// this explicitly so session routing does not depend on global
+		// process.cwd() after worktree merge/teardown. Other callers keep the
+		// historical default.
 		const previousCwd = this._cwd;
-		this._cwd = process.cwd();
+		this._cwd = options?.workspaceRoot ?? process.cwd();
 		this.sessionManager.newSession({ parentSession: options?.parentSession });
 		this.agent.sessionId = this.sessionManager.getSessionId();
 		this._steeringMessages = [];
 		this._followUpMessages = [];
 		this._pendingNextTurnMessages = [];
+		this._visibleSkillNames = undefined;
 
 		this.sessionManager.appendThinkingLevelChange(this.thinkingLevel);
 
@@ -2185,6 +2214,8 @@ export class AgentSession {
 				getActiveTools: () => this.getActiveToolNames(),
 				getAllTools: () => this.getAllTools(),
 				setActiveTools: (toolNames) => this.setActiveToolsByName(toolNames),
+				getVisibleSkills: () => this.getVisibleSkillNames(),
+				setVisibleSkills: (skillNames) => this.setVisibleSkillsByName(skillNames),
 				refreshTools: () => this._refreshToolRegistry(),
 				getCommands,
 				setModel: async (model, options) => {
@@ -2353,6 +2384,7 @@ export class AgentSession {
 		this.settingsManager.reload();
 		resetApiProviders();
 		await this._resourceLoader.reload();
+		this._visibleSkillNames = undefined;
 		this._buildRuntime({
 			activeToolNames: this.getActiveToolNames(),
 			flagValues: previousFlagValues,
@@ -2542,6 +2574,7 @@ export class AgentSession {
 		this._steeringMessages = [];
 		this._followUpMessages = [];
 		this._pendingNextTurnMessages = [];
+		this._visibleSkillNames = undefined;
 
 		// Set new session
 		this.sessionManager.setSessionFile(sessionPath);

package/packages/pi-coding-agent/src/core/chat-controller-ordering.test.ts

@@ -1049,7 +1049,9 @@ test("chat-controller rolls up only contiguous low-signal tool runs on message_e
 	assert.equal(host.chatContainer.children[1]?.constructor?.name, "AssistantMessageComponent");
 	assert.equal(host.chatContainer.children[2]?.constructor?.name, "ToolPhaseSummaryComponent");
 	assert.match(host.chatContainer.children[0].render(120).join("\n"), /Setup \/ shell 2 actions/);
-	assert.match(host.chatContainer.children[2].render(120).join("\n"), /Context reads 2 actions/);
+	const readSummary = host.chatContainer.children[2].render(120).join("\n");
+	assert.match(readSummary, /Context reads · 2 files/);
+	assert.match(readSummary, /\/tmp\/a · \/tmp\/b/);
 	assert.equal(host.chatContainer._prevRender, null, "summary reposition must invalidate the chat container render cache");
 });
 

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

@@ -160,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");
@@ -179,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) => {

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 }>;
@@ -275,11 +277,7 @@ export class ExtensionRunner {
 	}
 
 	private currentCwd(): string {
-		try {
-			return process.cwd();
-		} catch {
-			return this.cwd;
-		}
+		return this.cwd;
 	}
 
 	/**
@@ -414,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;

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";
 
@@ -309,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 }>;
 
@@ -848,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.
@@ -864,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. */
@@ -1015,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 {
@@ -1486,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[];
 
@@ -1727,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>;
@@ -1759,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

@@ -38,8 +38,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 +127,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() */
@@ -390,9 +451,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 +464,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(),

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

@@ -1,3 +1,6 @@
+// Project/App: GSD-2
+// File Purpose: Tests skill invocation and prompt-only skill visibility behavior.
+
 import assert from "node:assert/strict";
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
@@ -86,4 +89,29 @@ describe("Skill tool", () => {
 		assert.match(message, /^Skill "nonexistent" not found\. Available skills: /);
 		assert.match(message, /swift-testing/);
 	});
+
+	it("filters skill catalog without unloading skills or disabling Skill tool", async () => {
+		writeSkill(testDir, "alpha", "Use alpha.");
+		writeSkill(testDir, "beta", "Use beta.");
+		const session = await createSession();
+
+		assert.match(session.systemPrompt, /<name>alpha<\/name>/);
+		assert.match(session.systemPrompt, /<name>beta<\/name>/);
+
+		session.setVisibleSkillsByName(["alpha"]);
+		assert.deepEqual(session.getVisibleSkillNames(), ["alpha"]);
+		assert.match(session.systemPrompt, /<name>alpha<\/name>/);
+		assert.doesNotMatch(session.systemPrompt, /<name>beta<\/name>/);
+
+		const tool = session.state.tools.find((entry) => entry.name === "Skill");
+		assert.ok(tool, "Skill tool should remain active");
+		const result = await tool.execute("call-3", { skill: "beta" });
+		const text = result.content[0]?.type === "text" ? result.content[0].text : "";
+		assert.match(text, /<skill name="beta"/);
+
+		session.setVisibleSkillsByName(undefined);
+		assert.equal(session.getVisibleSkillNames(), undefined);
+		assert.match(session.systemPrompt, /<name>alpha<\/name>/);
+		assert.match(session.systemPrompt, /<name>beta<\/name>/);
+	});
 });

package/packages/pi-coding-agent/src/core/system-prompt.ts

@@ -59,13 +59,12 @@ export interface BuildSystemPromptOptions {
 	 * Append a `Current date and time: <toLocaleString>` line to the system
 	 * prompt. Default: `false`.
 	 *
-	 * Anthropic prompt caching matches on byte-for-byte prefix equality.
-	 * Embedding a per-call timestamp in the system prompt invalidates the
-	 * cache on every request, forcing a full re-write that costs *more*
-	 * than an uncached call (cache-write premium). Most agentic flows do
-	 * not need wall-clock awareness in the system prompt — opt in only
-	 * when the consumer genuinely needs it (e.g. a clock-sensitive agent),
-	 * and inject it via a non-cached channel (user message) when possible.
+	 * Provider prompt caches generally depend on stable prompt prefixes.
+	 * Embedding a per-call timestamp in the system prompt invalidates that
+	 * stability on every request, often forcing full prompt reprocessing.
+	 * Most agentic flows do not need wall-clock awareness in the system
+	 * prompt — opt in only when the consumer genuinely needs it, and inject
+	 * it via a non-cached channel (user message) when possible.
 	 */
 	includeDateTime?: boolean;
 }
@@ -86,9 +85,8 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 	} = options;
 	const resolvedCwd = toPosixPath(cwd ?? process.cwd());
 
-	// Per-call timestamps invalidate Anthropic prompt caching (the cache
-	// matches on byte-for-byte prefix equality). Compute lazily and only
-	// when explicitly opted in via `includeDateTime`.
+	// Per-call timestamps invalidate provider prompt cache stability. Compute
+	// lazily and only when explicitly opted in via `includeDateTime`.
 	const dateTimeLine = includeDateTime
 		? `\nCurrent date and time: ${new Date().toLocaleString("en-US", {
 			weekday: "long",