gsd-pi 2.80.0-dev.c5f2443b3 → 2.80.0-dev.d4fc28e6b

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 {
@@ -32,6 +39,7 @@ export interface RetrySettings {
 export interface TerminalSettings {
 	showImages?: boolean; // default: true (only relevant if terminal supports images)
 	clearOnShrink?: boolean; // default: false (clear empty rows when content shrinks)
+	adaptiveMode?: AdaptiveTuiMode; // default: "auto"
 }
 
 export interface ImageSettings {
@@ -149,6 +157,7 @@ export interface HooksSettings {
 }
 
 export type TransportSetting = Transport;
+export type AdaptiveTuiMode = "auto" | "chat" | "workflow" | "validation" | "debug" | "compact";
 
 /**
  * Package source for npm/git packages.
@@ -810,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(),
 		};
 	}
 
@@ -978,6 +1018,16 @@ export class SettingsManager {
 		this.setNestedGlobalSetting("terminal", "clearOnShrink", enabled);
 	}
 
+	getAdaptiveMode(): AdaptiveTuiMode {
+		const mode = this.settings.terminal?.adaptiveMode;
+		const valid: AdaptiveTuiMode[] = ["auto", "chat", "workflow", "validation", "debug", "compact"];
+		return mode && valid.includes(mode) ? mode : "auto";
+	}
+
+	setAdaptiveMode(mode: AdaptiveTuiMode): void {
+		this.setNestedGlobalSetting("terminal", "adaptiveMode", mode);
+	}
+
 	getImageAutoResize(): boolean {
 		return this.settings.images?.autoResize ?? true;
 	}

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/slash-commands.ts

@@ -38,5 +38,6 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 	{ name: "thinking", description: "Set thinking level (off/minimal/low/medium/high/xhigh)" },
 	{ name: "edit-mode", description: "Toggle edit mode (standard/hashline)" },
 	{ name: "terminal", description: "Run a shell command directly (e.g. /terminal ping -c3 1.1.1.1)" },
+	{ name: "tui", description: "Configure TUI layout mode (e.g. /tui mode workflow)" },
 	{ name: "quit", description: "Quit pi" },
 ];

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/modes/interactive/components/__tests__/chat-frame-compaction-tone.test.ts

@@ -1,3 +1,4 @@
+// GSD2 TUI Tests - Chat frame card visual contract coverage.
 import { test, describe } from "node:test";
 import assert from "node:assert/strict";
 import stripAnsi from "strip-ansi";
@@ -8,12 +9,12 @@ initTheme("dark", false);
 
 // Regression tests for the "compaction" tone added to renderChatFrame.
 // The compaction notice shares the same visual frame as user / assistant
-// messages (top rule, `• label` header, `│ ` body prefix) but uses the
+// messages (top rule, label header, `│ ` body prefix) but uses the
 // purple `customMessageLabel` color key so it is visually distinct from
 // conversation turns.
 
 describe("renderChatFrame — compaction tone", () => {
-	test("produces a top rule, `• compaction` header row, and a │ body margin", () => {
+	test("produces a top rule, compaction header row, and a │ body margin", () => {
 		const lines = renderChatFrame(
 			["Compacted from 1,224,262 tokens (ctrl+o to expand)"],
 			60,
@@ -33,11 +34,12 @@ describe("renderChatFrame — compaction tone", () => {
 		// Top rule is a solid horizontal bar
 		assert.match(plain[0], /^─+$/, "first line should be the solid top rule");
 
-		// Header row contains `• compaction`
+		// Header row contains `compaction`
 		assert.ok(
-			plain[1].includes("• compaction"),
-			`expected header to contain "• compaction", got ${JSON.stringify(plain[1])}`,
+			plain[1].includes("compaction"),
+			`expected header to contain "compaction", got ${JSON.stringify(plain[1])}`,
 		);
+		assert.ok(!plain[1].includes("•"), `header should not render a bullet prefix, got ${JSON.stringify(plain[1])}`);
 
 		// Body line(s) start with `│ `
 		assert.ok(

package/packages/pi-coding-agent/src/modes/interactive/components/__tests__/tool-execution.test.ts

@@ -1,7 +1,8 @@
+// GSD-2 Interactive Tool Execution Rendering Tests
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
 import stripAnsi from "strip-ansi";
-import { ToolExecutionComponent } from "../tool-execution.js";
+import { ToolExecutionComponent, ToolPhaseSummaryComponent, type ToolExecutionPhase } from "../tool-execution.js";
 import { initTheme } from "../../theme/theme.js";
 
 initTheme("dark", false);
@@ -50,25 +51,85 @@ function renderToolCollapsed(
 }
 
 describe("ToolExecutionComponent", () => {
-	test("renders framed header with Running status while tool is partial", () => {
+	test("renders framed header with running status while tool is partial", () => {
 		const rendered = renderToolCollapsed("mcp__demo__do_thing", { ok: true });
 
-		assert.match(rendered, /Tool demo\u00b7do_thing/);
-		assert.match(rendered, /Running/);
+		assert.match(rendered, /demo\u00b7do_thing/);
+		assert.doesNotMatch(rendered, /Tool demo\u00b7do_thing/);
+		assert.match(rendered, /running/);
+		assert.match(rendered, /running · \d+(ms|s)/);
 	});
 
-	test("renders framed header with Error status for failed tool result", () => {
+	test("renders framed header with failed status for failed tool result", () => {
 		const rendered = renderTool(
 			"mcp__demo__do_thing",
 			{ ok: true },
 			{ content: [{ type: "text", text: "boom" }], isError: true },
 		);
 
-		assert.match(rendered, /Tool demo\u00b7do_thing/);
-		assert.match(rendered, /Error/);
+		assert.match(rendered, /demo\u00b7do_thing/);
+		assert.doesNotMatch(rendered, /Tool demo\u00b7do_thing/);
+		assert.match(rendered, /failed/);
+		assert.match(rendered, /failed · \d+(ms|s)/);
 		assert.match(rendered, /boom/);
 	});
 
+	test("collapses successful low-signal tool cards by default", () => {
+		const rendered = renderToolCollapsed(
+			"mcp__demo__noop",
+			{ ok: true },
+			{ content: [], isError: false },
+		);
+
+		assert.match(rendered, /success · \d+(ms|s)/);
+		assert.match(rendered, /demo\u00b7noop/);
+		assert.doesNotMatch(rendered, /Completed/);
+		assert.doesNotMatch(rendered, /ok=true/);
+	});
+
+	test("exposes phase metadata for successful low-signal tool rows", () => {
+		const component = new ToolExecutionComponent(
+			"gsd_requirement_update",
+			{ id: "R001" },
+			{},
+			{ label: "Update Requirement" } as any,
+			{ requestRender() {} } as any,
+		);
+		component.updateResult({ content: [], isError: false });
+
+		assert.deepEqual(component.getRollupPhase()?.label, "Requirement writes");
+	});
+
+	test("exposes phase metadata for collapsed output-bearing generic tools", () => {
+		const component = new ToolExecutionComponent(
+			"mcp__demo__do_thing",
+			{ ok: true },
+			{},
+			undefined,
+			{ requestRender() {} } as any,
+		);
+		component.updateResult({ content: [{ type: "text", text: "important output" }], isError: false });
+
+		assert.deepEqual(component.getRollupPhase()?.label, "Other tool actions");
+	});
+
+	test("renders phase-based summaries for rolled-up tool executions", () => {
+		const phases: ToolExecutionPhase[] = [
+			{ label: "Setup / shell", count: 6, durationMs: 12 },
+			{ label: "Context reads", count: 4, durationMs: 6 },
+			{ label: "Requirement writes", count: 4, durationMs: 4 },
+			{ label: "Memory lookups", count: 4, durationMs: 4 },
+			{ label: "Finalization", count: 1, durationMs: 1 },
+		];
+		const rendered = stripAnsi(new ToolPhaseSummaryComponent(phases).render(120).join("\n"));
+
+		assert.match(rendered, /Setup \/ shell 6 actions\s+success · 12ms/);
+		assert.match(rendered, /Context reads 4 actions\s+success · 6ms/);
+		assert.match(rendered, /Requirement writes 4 actions\s+success · 4ms/);
+		assert.match(rendered, /Memory lookups 4 actions\s+success · 4ms/);
+		assert.match(rendered, /Finalization 1 action\s+success · 1ms/);
+	});
+
 	test("passes failed result status to custom result renderers", () => {
 		const rendered = renderTool(
 			"gsd_requirement_save",
@@ -85,7 +146,7 @@ describe("ToolExecutionComponent", () => {
 			},
 		);
 
-		assert.match(rendered, /Error/);
+		assert.match(rendered, /failed/);
 		assert.match(rendered, /custom saw error/);
 		assert.doesNotMatch(rendered, /custom saw success/);
 	});
@@ -148,14 +209,16 @@ describe("ToolExecutionComponent", () => {
 			{ label: "Complete Slice" },
 		);
 
-		assert.match(rendered, /Tool Complete Slice/);
+		assert.match(rendered, /Complete Slice/);
+		assert.doesNotMatch(rendered, /Tool Complete Slice/);
 		assert.doesNotMatch(rendered, /gsd_slice_complete/);
 	});
 
 	test("frame header strips gsd_ prefix and title-cases when no label is registered", () => {
 		const rendered = renderToolCollapsed("gsd_requirement_update", { id: "R005" });
 
-		assert.match(rendered, /Tool Requirement Update/);
+		assert.match(rendered, /Requirement Update/);
+		assert.doesNotMatch(rendered, /Tool Requirement Update/);
 		assert.doesNotMatch(rendered, /gsd_requirement_update/);
 	});
 
@@ -184,7 +247,7 @@ describe("ToolExecutionComponent", () => {
 		assert.doesNotMatch(rendered, /…/);
 	});
 
-	test("generic fallback truncates long output when collapsed", () => {
+	test("generic fallback collapses successful output rows until expanded", () => {
 		const longOutput = Array.from({ length: 25 }, (_, i) => `line ${i + 1}`).join("\n");
 		const rendered = renderToolCollapsed(
 			"mcp__demo__do_thing",
@@ -192,10 +255,10 @@ describe("ToolExecutionComponent", () => {
 			{ content: [{ type: "text", text: longOutput }], isError: false },
 		);
 
-		assert.match(rendered, /line 1\b/);
-		assert.match(rendered, /line 10\b/);
-		assert.doesNotMatch(rendered, /line 20\b/);
-		assert.match(rendered, /\(15 more lines/);
+		assert.match(rendered, /demo\u00b7do_thing/);
+		assert.match(rendered, /success · \d+(ms|s)/);
+		assert.doesNotMatch(rendered, /line 1\b/);
+		assert.doesNotMatch(rendered, /\(15 more lines/);
 	});
 
 	test("generic fallback falls back to truncated JSON for complex args", () => {

package/packages/pi-coding-agent/src/modes/interactive/components/adaptive-layout.test.ts

@@ -0,0 +1,59 @@
+// GSD2 - Runtime tests for adaptive terminal layout rendering
+
+import assert from "node:assert/strict";
+import { describe, it, before } from "node:test";
+import stripAnsi from "strip-ansi";
+import { AdaptiveLayoutComponent } from "./adaptive-layout.js";
+import { initTheme } from "../theme/theme.js";
+
+before(() => {
+	initTheme("dark", false);
+});
+
+function render(component: AdaptiveLayoutComponent, width: number): string {
+	return component.render(width).map(stripAnsi).join("\n");
+}
+
+describe("AdaptiveLayoutComponent", () => {
+	it("renders workflow command center and inspector on wide terminals", () => {
+		const component = new AdaptiveLayoutComponent(() => ({
+			override: "workflow",
+			activeToolCount: 2,
+			gsdPhase: "executing milestone M001",
+			sessionName: "demo",
+			cwd: "/tmp/demo",
+		}));
+
+		const output = render(component, 132);
+		assert.match(output, /GSD Command Center/);
+		assert.match(output, /signals/);
+		assert.match(output, /2 running/);
+	});
+
+	it("falls back to a single compact row for narrow workflow terminals", () => {
+		const component = new AdaptiveLayoutComponent(() => ({
+			override: "workflow",
+			activeToolCount: 1,
+			gsdPhase: "executing milestone M001",
+			cwd: "/tmp/demo",
+		}));
+
+		const output = render(component, 68);
+		assert.match(output, /GSD compact/);
+		assert.doesNotMatch(output, /signals/);
+	});
+
+	it("renders blocking failure context in debug mode", () => {
+		const component = new AdaptiveLayoutComponent(() => ({
+			override: "auto",
+			activeToolCount: 0,
+			lastError: "Cannot find module @gsd/native",
+			cwd: "/tmp/demo",
+		}));
+
+		const output = render(component, 120);
+		assert.match(output, /blocking failure/);
+		assert.match(output, /Cannot find module/);
+		assert.match(output, /inspect the failed output/);
+	});
+});