gsd-pi 2.80.0-dev.8b3a59f5c → 2.80.0-dev.b0acf17e9

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

@@ -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/settings-manager.ts

@@ -15,6 +15,13 @@ export interface CompactionSettings {
 	enabled?: boolean; // default: true
 	reserveTokens?: number; // default: 16384
 	keepRecentTokens?: number; // default: 20000
+	/**
+	 * Optional percent-of-context-window trigger (0 < value < 1). When set,
+	 * compaction fires at `contextWindow * thresholdPercent` and overrides
+	 * `reserveTokens`. Typically set as a runtime override by host integrations
+	 * (see `setCompactionThresholdOverride`) and not persisted by users directly.
+	 */
+	thresholdPercent?: number;
 }
 
 export interface BranchSummarySettings {
@@ -812,11 +819,42 @@ export class SettingsManager {
 		return this.settings.compaction?.keepRecentTokens ?? COMPACTION_KEEP_RECENT_TOKENS;
 	}
 
-	getCompactionSettings(): { enabled: boolean; reserveTokens: number; keepRecentTokens: number } {
+	getCompactionThresholdPercent(): number | undefined {
+		return this.settings.compaction?.thresholdPercent;
+	}
+
+	/**
+	 * Set or clear an in-memory compaction threshold-percent override.
+	 *
+	 * Applied to `this.settings` only; never persisted to disk. Pass `undefined`
+	 * to clear a previously set override (necessary for idempotent re-sync from
+	 * host integrations whose preference may have been removed).
+	 *
+	 * Direct mutation is used instead of `applyOverrides()` because deep-merge
+	 * semantics skip `undefined` values, which would prevent clearing.
+	 */
+	setCompactionThresholdOverride(percent: number | undefined): void {
+		if (!this.settings.compaction) {
+			this.settings.compaction = {};
+		}
+		if (percent === undefined) {
+			delete this.settings.compaction.thresholdPercent;
+		} else {
+			this.settings.compaction.thresholdPercent = percent;
+		}
+	}
+
+	getCompactionSettings(): {
+		enabled: boolean;
+		reserveTokens: number;
+		keepRecentTokens: number;
+		thresholdPercent?: number;
+	} {
 		return {
 			enabled: this.getCompactionEnabled(),
 			reserveTokens: this.getCompactionReserveTokens(),
 			keepRecentTokens: this.getCompactionKeepRecentTokens(),
+			thresholdPercent: this.getCompactionThresholdPercent(),
 		};
 	}
 

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",

package/packages/pi-coding-agent/src/core/tools/bash-spawn-windows.test.ts

@@ -19,76 +19,32 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 import { spawn } from "node:child_process";
+import { createBashTool } from "./bash.js";
 
-// Verify the spawn option pattern used across the codebase.
-// This is a static/structural test — it reads the source files and asserts
-// they use the platform-guarded detached flag.
-import { existsSync, readFileSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-function findRepoRoot(): string {
-	const requiredFiles = [
-		"packages/pi-coding-agent/src/core/tools/bash.ts",
-		"packages/pi-coding-agent/src/core/bash-executor.ts",
-		"packages/pi-coding-agent/src/utils/shell.ts",
-	];
-	const candidates = [
-		resolve(__dirname, "../../../../../"),
-		resolve(__dirname, "../../../../../../"),
-	];
-	for (const candidate of candidates) {
-		if (requiredFiles.every((file) => existsSync(join(candidate, file)))) {
-			return candidate;
-		}
-	}
-	throw new Error(`Unable to resolve repository root from ${__dirname}`);
-}
-
-const REPO_ROOT = findRepoRoot();
-
-const SPAWN_FILES = [
-	join(REPO_ROOT, "packages/pi-coding-agent/src/core/tools/bash.ts"),
-	join(REPO_ROOT, "packages/pi-coding-agent/src/core/bash-executor.ts"),
-	join(REPO_ROOT, "packages/pi-coding-agent/src/utils/shell.ts"),
-];
-
-test("spawn calls use platform-guarded detached flag (no unconditional detached: true)", () => {
-	for (const file of SPAWN_FILES) {
-		const content = readFileSync(file, "utf-8");
-		const lines = content.split("\n");
-
-		for (let i = 0; i < lines.length; i++) {
-			const line = lines[i]!;
-			// Skip comments
-			if (line.trim().startsWith("//") || line.trim().startsWith("*")) continue;
-			// Check for unconditional `detached: true`
-			if (/detached:\s*true\b/.test(line)) {
-				assert.fail(
-					`${file}:${i + 1} has unconditional 'detached: true' — ` +
-					`must use 'detached: process.platform !== "win32"' ` +
-					`to prevent EINVAL on Windows (ConPTY / VSCode terminal)`,
-				);
-			}
-		}
-	}
-});
+test("bash tool delegates command execution through operations without forcing process detachment", async () => {
+	const calls: Array<{ command: string; cwd: string; env?: NodeJS.ProcessEnv }> = [];
+	const tool = createBashTool(process.cwd(), {
+		operations: {
+			async exec(command, cwd, options) {
+				calls.push({ command, cwd, env: options.env });
+				options.onData(Buffer.from("ok\n"));
+				return { exitCode: 0 };
+			},
+		},
+	});
 
-test("killProcessTree does not use detached: true for taskkill on Windows", () => {
-	const shellFile = join(REPO_ROOT, "packages/pi-coding-agent/src/utils/shell.ts");
-	const content = readFileSync(shellFile, "utf-8");
+	const result = await tool.execute("tool-call", { command: "echo ok" });
+	const firstContent = result.content[0];
 
-	// Find the taskkill spawn call and ensure it doesn't have detached: true
-	const taskkillRegion = content.match(/spawn\("taskkill"[\s\S]*?\}\)/);
-	if (taskkillRegion) {
-		assert.ok(
-			!/detached:\s*true/.test(taskkillRegion[0]),
-			"taskkill spawn should not use detached: true — " +
-			"it can cause EINVAL on Windows and is unnecessary for a utility process",
-		);
+	assert.ok(firstContent);
+	if (firstContent.type !== "text") {
+		assert.fail(`Expected text content, got ${firstContent.type}`);
 	}
+	assert.equal(firstContent.text, "ok\n");
+	assert.deepEqual(calls.map((call) => ({ command: call.command, cwd: call.cwd })), [
+		{ command: "echo ok", cwd: process.cwd() },
+	]);
+	assert.ok(calls[0]?.env, "default bash context should provide an execution environment");
 });
 
 // Smoke test: spawn with platform-guarded detached flag actually works

package/packages/pi-coding-agent/src/core/tools/bash.ts

@@ -116,6 +116,7 @@ const bashSchema = Type.Object({
 export type BashToolInput = Static<typeof bashSchema>;
 
 export interface BashToolDetails {
+	cwd?: string;
 	truncation?: TruncationResult;
 	fullOutputPath?: string;
 	artifactId?: string;
@@ -384,6 +385,7 @@ export function createBashTool(cwd: string, options?: BashToolOptions): AgentToo
 						onUpdate({
 							content: [{ type: "text", text: truncation.content || "" }],
 							details: {
+								cwd: spawnContext.cwd,
 								truncation: truncation.truncated ? truncation : undefined,
 								fullOutputPath: spillFilePath,
 							},
@@ -412,10 +414,11 @@ export function createBashTool(cwd: string, options?: BashToolOptions): AgentToo
 						let outputText = truncation.content || "(no output)";
 
 						// Build details with truncation info
-						let details: BashToolDetails | undefined;
+						let details: BashToolDetails | undefined = { cwd: spawnContext.cwd };
 
 						if (truncation.truncated) {
 							details = {
+								...details,
 								truncation,
 								fullOutputPath: spillFilePath,
 								...(spillArtifactId ? { artifactId: spillArtifactId } : {}),

package/packages/pi-coding-agent/src/core/tools/edit.ts

@@ -13,6 +13,7 @@ import {
 } from "./edit-diff.js";
 import { notifyFileChanged } from "../lsp/client.js";
 import { resolveToCwd } from "./path-utils.js";
+import { createToolTarget, type ToolTargetMetadata } from "./tool-target.js";
 
 const editSchema = Type.Object({
 	path: Type.String({ description: "Path to the file to edit (relative or absolute)" }),
@@ -27,6 +28,7 @@ export interface EditToolDetails {
 	diff: string;
 	/** Line number of the first change in the new file (for editor navigation) */
 	firstChangedLine?: number;
+	target?: ToolTargetMetadata;
 }
 
 /**
@@ -208,7 +210,17 @@ export function createEditTool(cwd: string, options?: EditToolOptions): AgentToo
 									text: `Successfully replaced text in ${path}.`,
 								},
 							],
-							details: { diff: diffResult.diff, firstChangedLine: diffResult.firstChangedLine },
+							details: {
+								diff: diffResult.diff,
+								firstChangedLine: diffResult.firstChangedLine,
+								target: createToolTarget({
+									kind: "file",
+									action: "edit",
+									inputPath: path,
+									resolvedPath: absolutePath,
+									line: diffResult.firstChangedLine,
+								}),
+							},
 						});
 					} catch (error: any) {
 						// Clean up abort handler