@agentuity/coder-tui 3.0.0-alpha.6 → 3.0.0-beta.0

package/src/hub-overlay-state.ts

@@ -1,3 +1,5 @@
+import { formatToolDisplay } from './agentuity-cli.ts';
+
 export interface StreamBuffer {
 	output: string;
 	thinking: string;
@@ -78,7 +80,8 @@ export function buildProjectionFromEntries(
 		const type = typeof entry.type === 'string' ? entry.type : '';
 		if (type === 'tool_call') {
 			const toolName = typeof entry.toolName === 'string' ? entry.toolName : 'tool';
-			append('output', `[tool_call] ${toolName}\n\n`, entry.taskId);
+			const display = formatToolDisplay(toolName, entry.toolArgs);
+			append('output', `[tool_call] ${display.fullLabel}\n\n`, entry.taskId);
 			continue;
 		}
 

package/src/hub-overlay.ts

@@ -10,6 +10,7 @@ import {
 	type StreamProjectionSource,
 } from './hub-overlay-state.ts';
 import { applyCoderAuthHeaders } from './auth.ts';
+import { formatToolDisplay } from './agentuity-cli.ts';
 import { truncateToWidth } from './renderers.ts';
 import type {
 	ConversationEntry as HubConversationEntry,
@@ -2128,6 +2129,13 @@ export class HubOverlay implements Component, Focusable {
 						? data.toolName
 						: 'tool';
 			const input = data?.args ?? data?.input;
+			const display = formatToolDisplay(
+				name,
+				typeof input === 'string' || (input && typeof input === 'object')
+					? (input as string | Record<string, unknown>)
+					: undefined
+			);
+			if (display.branded) return `tool_call ${display.fullLabel}`;
 			const summarized = summarizeToolCall(name, input);
 			if (summarized) return summarized;
 			const argsPreview = summarizeArgs(input, 90);
@@ -2171,15 +2179,18 @@ export class HubOverlay implements Component, Focusable {
 				const failed = data?.isError === true || details?.error === true;
 				return `${header}\n${failed ? 'failed' : `done${duration}`}`;
 			}
-			return `tool_result ${name}`;
+			const display = formatToolDisplay(name, input);
+			return `tool_result ${display.toolName}`;
 		}
 
 		if (eventName === 'agent_progress') {
 			const agent = typeof data?.agentName === 'string' ? data.agentName : 'agent';
 			const status = typeof data?.status === 'string' ? data.status : 'progress';
-			const toolName = typeof data?.currentTool === 'string' ? data.currentTool : '';
+			const rawToolName = typeof data?.currentTool === 'string' ? data.currentTool : '';
 			const toolArgsRaw = typeof data?.currentToolArgs === 'string' ? data.currentToolArgs : '';
-			const toolArgs = toolArgsRaw ? truncateToWidth(normalize(toolArgsRaw), 80) : '';
+			const display = formatToolDisplay(rawToolName, toolArgsRaw || undefined);
+			const toolName = display.toolName;
+			const toolArgs = display.toolArgs ? truncateToWidth(normalize(display.toolArgs), 80) : '';
 
 			// Deltas are already represented in rendered stream mode; skip them in event mode
 			// to avoid noisy, low-signal token lines.

package/src/index.ts

@@ -1,4 +1,5 @@
-import type {
+import {
+	createBashToolDefinition,
 	AgentToolResult,
 	ExtensionAPI,
 	ExtensionContext,
@@ -13,6 +14,7 @@ import { processActions } from './handlers.ts';
 import { getToolRenderers } from './renderers.ts';
 import { setupCoderFooter, type ObserverState } from './footer.ts';
 import { setupTitlebar } from './titlebar.ts';
+import { setupStartupLogo } from './startup-logo.ts';
 import { registerAgentCommands } from './commands.ts';
 import { AgentManagerOverlay } from './overlay.ts';
 import { ChainEditorOverlay, type ChainResult } from './chain-preview.ts';
@@ -22,6 +24,10 @@ import { setNativeRemoteExtensionContext } from './native-remote-ui-context.ts';
 import { handleRemoteUiRequest } from './remote-ui-handler.ts';
 import { buildInboundRpcPromptText, getInboundRpcDeliverAs } from './inbound-rpc.ts';
 import { applyCoderAuthHeaders, getCoderAuthCurlArgs } from './auth.ts';
+import { formatToolDisplay } from './agentuity-cli.ts';
+import { setupAIGateway } from './aigateway.ts';
+import { adaptInitMessageForLocalTui } from './local-init-filter.ts';
+import { selectSubAgentToolNames } from './subagent-tool-selection.ts';
 import type {
 	HubAction,
 	HubResponse,
@@ -275,6 +281,15 @@ async function fetchInitMessage(hubUrl: string, agentRole?: string): Promise<Ini
 }
 
 export function agentuityCoderHub(pi: ExtensionAPI) {
+	process.env.AGENTUITY_AGENT_MODE = 'coder'; // let the agentuity cli know we're inside coder
+
+	// Register the startup header before Hub bootstrap so `pi -e .` works for
+	// local visual testing without Agentuity Coder environment variables.
+	setupStartupLogo(pi);
+
+	// Register the AI Gateway
+	setupAIGateway(pi);
+
 	const hubUrl = process.env[HUB_URL_ENV];
 	if (!hubUrl) return;
 
@@ -283,6 +298,7 @@ export function agentuityCoderHub(pi: ExtensionAPI) {
 	// to an existing sandbox session. The full UI is set up (tools, commands, /hub)
 	// but user input is relayed to the remote sandbox instead of the local Pi agent.
 	const remoteSessionId = process.env[REMOTE_SESSION_ENV] || null;
+	const isRemoteSession = Boolean(remoteSessionId);
 	const isNativeRemote = !!process.env[NATIVE_REMOTE_ENV];
 	if (remoteSessionId) {
 		log(`Remote mode: will connect as controller to session ${remoteSessionId}`);
@@ -298,7 +314,10 @@ export function agentuityCoderHub(pi: ExtensionAPI) {
 	// This is how we discover what tools/agents the server provides.
 	// ══════════════════════════════════════════════
 
-	const initMsg = fetchInitMessageSync(hubUrl, agentRole);
+	const initialInitMsg = fetchInitMessageSync(hubUrl, agentRole);
+	const initMsg = initialInitMsg
+		? adaptInitMessageForLocalTui(initialInitMsg, { isRemoteSession })
+		: null;
 
 	if (!initMsg) {
 		log('Hub not reachable — no tools or agents registered');
@@ -411,6 +430,18 @@ export function agentuityCoderHub(pi: ExtensionAPI) {
 	// Titlebar: branding + spinner (registers its own event handlers)
 	setupTitlebar(pi);
 
+	// Override Pi's built-in bash call-row rendering so local transcript rows
+	// can brand Agentuity CLI invocations without changing bash execution/result behavior.
+	const hasBashTool = serverTools.some((tool) => tool.name === 'bash');
+	const localBashRenderers = hasBashTool ? getToolRenderers('bash') : undefined;
+	if (hasBashTool && localBashRenderers?.renderCall) {
+		const bashToolDefinition = createBashToolDefinition(process.cwd());
+		pi.registerTool({
+			...bashToolDefinition,
+			renderCall: localBashRenderers.renderCall as ToolDefinition['renderCall'],
+		});
+	}
+
 	// ══════════════════════════════════════════════
 	// WebSocket client for runtime communication (tool execution + events)
 	// ══════════════════════════════════════════════
@@ -453,9 +484,10 @@ export function agentuityCoderHub(pi: ExtensionAPI) {
 	}
 
 	function applyInitMessage(nextInit: InitMessage): void {
-		cachedInitMessage = nextInit;
-		if (nextInit.sessionId) currentSessionId = nextInit.sessionId;
-		if (nextInit.config) hubConfig = nextInit.config;
+		const effectiveInit = adaptInitMessageForLocalTui(nextInit, { isRemoteSession });
+		cachedInitMessage = effectiveInit;
+		if (effectiveInit.sessionId) currentSessionId = effectiveInit.sessionId;
+		if (effectiveInit.config) hubConfig = effectiveInit.config;
 	}
 
 	client.onInitMessage = (nextInit) => {
@@ -1448,7 +1480,7 @@ export function agentuityCoderHub(pi: ExtensionAPI) {
 		}
 
 		// Set up Coder footer (powerline: model or active agent > branch > status + observer count)
-		setupCoderFooter(ctx, getHubUiStatus, getObserverState);
+		setupCoderFooter(pi, ctx, getHubUiStatus, getObserverState);
 
 		// Fire-and-forget: fetch session snapshot for label + initial observer count.
 		// Uses the Hub REST endpoint — non-blocking, best-effort.
@@ -1755,13 +1787,7 @@ async function runSubAgent(
 	const { piSdk, piAi } = await loadPiSdk();
 	// Runtime-resolved dynamic imports — exact types unavailable statically
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	const {
-		createAgentSession,
-		DefaultResourceLoader,
-		SessionManager,
-		createCodingTools,
-		createReadOnlyTools,
-	} = piSdk as any;
+	const { createAgentSession, DefaultResourceLoader, getAgentDir, SessionManager } = piSdk as any;
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	const { getModel } = piAi as any;
 
@@ -1783,13 +1809,16 @@ async function runSubAgent(
 	// Sub-agents get Hub tools (memory, context7, etc.) via extensionFactories
 	// so they work in both driver and TUI mode.
 	const hubTools = agentConfig.hubTools ?? [];
+	const cwd = process.cwd();
+	const agentDir = getAgentDir();
 
 	// Resource loader — no extensions (prevents recursive task tool registration),
 	// no skills, agent's system prompt injected directly.
 	// Hub tools are injected via extensionFactories so sub-agents can use
 	// memory_recall, context7_search, etc.
 	const subLoader = new DefaultResourceLoader({
-		cwd: process.cwd(),
+		cwd,
+		agentDir,
 		noExtensions: true,
 		extensionFactories:
 			hubTools.length > 0
@@ -1808,9 +1837,12 @@ async function runSubAgent(
 	});
 	await subLoader.reload();
 
-	// Select tools based on readOnly flag
-	const cwd = process.cwd();
-	const tools = agentConfig.readOnly ? createReadOnlyTools(cwd) : createCodingTools(cwd);
+	// Pi v0.68.x uses a name allowlist for both built-in and extension/custom tools.
+	const builtInToolNames = selectSubAgentToolNames(agentConfig);
+	const hubToolNames = hubTools
+		.map((tool) => (typeof tool.name === 'string' ? tool.name.trim() : ''))
+		.filter((name): name is string => name.length > 0);
+	const tools = Array.from(new Set([...builtInToolNames, ...hubToolNames]));
 
 	const { session } = await createAgentSession({
 		// subModel is already untyped (from dynamic import) — createAgentSession is also dynamically imported
@@ -1824,7 +1856,8 @@ async function runSubAgent(
 			| 'xhigh',
 		tools,
 		resourceLoader: subLoader,
-		sessionManager: SessionManager.inMemory('/tmp'),
+		// Pi now tracks cwd per session, so bind in-memory sub-agents to the actual repo cwd.
+		sessionManager: SessionManager.inMemory(cwd),
 	});
 	await session.bindExtensions({});
 
@@ -1860,25 +1893,19 @@ async function runSubAgent(
 
 					if (evt.type === 'tool_execution_start') {
 						const toolName = evt.toolName || evt.name || evt.tool || 'unknown';
-						let toolArgs = '';
-						if (evt.args && typeof evt.args === 'object') {
-							const args = evt.args as Record<string, unknown>;
-							if (args.command) toolArgs = String(args.command).slice(0, 60);
-							else if (args.filePath || args.path)
-								toolArgs = String(args.filePath || args.path);
-							else if (args.pattern) toolArgs = String(args.pattern).slice(0, 40);
-							else {
-								const first = Object.values(args)[0];
-								if (first) toolArgs = String(first).slice(0, 40);
-							}
-						}
+						const display = formatToolDisplay(
+							toolName,
+							typeof evt.args === 'string' || (evt.args && typeof evt.args === 'object')
+								? (evt.args as string | Record<string, unknown>)
+								: undefined
+						);
 
 						onProgress({
 							agentName: agentConfig.name,
 							status: 'tool_start',
 							toolCallId: typeof evt.toolCallId === 'string' ? evt.toolCallId : undefined,
-							currentTool: toolName,
-							currentToolArgs: toolArgs,
+							currentTool: display.toolName,
+							currentToolArgs: display.toolArgs,
 							elapsed,
 						});
 					} else if (evt.type === 'tool_execution_end') {

package/src/local-init-filter.ts

@@ -0,0 +1,54 @@
+import type { AgentDefinition, HubToolDefinition, InitMessage } from './protocol.ts';
+
+const LOCAL_TUI_HIDDEN_HUB_TOOL_NAMES = new Set(['sandbox_exec']);
+
+function filterHubToolsForLocalTui(tools?: HubToolDefinition[]): HubToolDefinition[] | undefined {
+	if (!tools) return tools;
+
+	const filtered = tools.filter((tool) => !LOCAL_TUI_HIDDEN_HUB_TOOL_NAMES.has(tool.name));
+	return filtered.length === tools.length ? tools : filtered;
+}
+
+function filterAgentHubToolsForLocalTui(agents?: AgentDefinition[]): AgentDefinition[] | undefined {
+	if (!agents) return agents;
+
+	let changed = false;
+	const filteredAgents = agents.map((agent) => {
+		const filteredHubTools = filterHubToolsForLocalTui(agent.hubTools);
+		if (filteredHubTools === agent.hubTools) {
+			return agent;
+		}
+
+		changed = true;
+		return {
+			...agent,
+			hubTools: filteredHubTools && filteredHubTools.length > 0 ? filteredHubTools : undefined,
+		};
+	});
+
+	return changed ? filteredAgents : agents;
+}
+
+export function adaptInitMessageForLocalTui(
+	init: InitMessage,
+	options: {
+		isRemoteSession: boolean;
+	}
+): InitMessage {
+	if (options.isRemoteSession) {
+		return init;
+	}
+
+	const tools = filterHubToolsForLocalTui(init.tools);
+	const agents = filterAgentHubToolsForLocalTui(init.agents);
+
+	if (tools === init.tools && agents === init.agents) {
+		return init;
+	}
+
+	return {
+		...init,
+		tools,
+		agents,
+	};
+}

package/src/protocol.ts

@@ -75,6 +75,7 @@ export type HubAction =
 export interface AgentDefinition {
 	name: string;
 	displayName?: string;
+	source?: 'builtin' | 'custom';
 	description: string;
 	systemPrompt: string;
 	model?: string;
@@ -84,6 +85,7 @@ export interface AgentDefinition {
 	readOnly?: boolean;
 	hubTools?: HubToolDefinition[];
 	capabilities?: string[];
+	strictToolSelection?: boolean;
 	status?: 'available' | 'busy' | 'offline';
 }
 

package/src/remote-session.ts

@@ -23,6 +23,7 @@ import {
 	type RemoteLifecycleState,
 } from './remote-lifecycle.ts';
 import { resolveCoderOrgId } from './auth.ts';
+import { formatToolDisplay } from './agentuity-cli.ts';
 
 const DEBUG = !!process.env['AGENTUITY_DEBUG'];
 
@@ -1001,18 +1002,23 @@ export async function setupRemoteMode(
 				break;
 
 			case 'tool_execution_start': {
-				const tool = (event as { toolName?: string }).toolName ?? 'tool';
-				currentTool = tool;
+				const rawTool = (event as { toolName?: string }).toolName ?? 'tool';
+				const rawArgs = (event as { args?: string | Record<string, unknown> }).args;
+				const display = formatToolDisplay(rawTool, rawArgs);
+				currentTool = display.toolName;
 				if (extensionCtxRef?.hasUI) {
-					setNonLifecycleWorkingMessage(`Running ${tool}...`);
-					extensionCtxRef.ui.setStatus('remote_activity', `Running ${tool}...`);
+					setNonLifecycleWorkingMessage(`Running ${display.fullLabel}...`);
+					extensionCtxRef.ui.setStatus('remote_activity', `Running ${display.fullLabel}...`);
 				}
-				log(`Tool: ${tool}`);
+				log(`Tool: ${display.fullLabel}`);
 				break;
 			}
 
 			case 'tool_execution_end': {
-				const tool = (event as { toolName?: string }).toolName ?? currentTool ?? 'tool';
+				const rawTool = (event as { toolName?: string }).toolName ?? currentTool ?? 'tool';
+				const rawArgs = (event as { args?: string | Record<string, unknown> }).args;
+				const display = rawArgs ? formatToolDisplay(rawTool, rawArgs) : null;
+				const tool = display?.fullLabel ?? currentTool ?? rawTool;
 				currentTool = null;
 				if (extensionCtxRef?.hasUI) {
 					clearWorkingMessage();

package/src/renderers.ts

@@ -12,6 +12,7 @@ import type {
 	AgentToolResult,
 } from '@mariozechner/pi-coding-agent';
 import { Box, Text, Container, type Component } from '@mariozechner/pi-tui';
+import { formatToolDisplay } from './agentuity-cli.ts';
 
 // ──────────────────────────────────────────────
 // Line-safety helper — must be declared before SimpleText so
@@ -125,6 +126,32 @@ function truncate(str: string, max: number): string {
 	return str.slice(0, max - 1) + '\u2026';
 }
 
+function toSingleLinePreview(value: string): string {
+	return value.replace(/\s+/g, ' ').trim();
+}
+
+function isCommandToolName(toolName: string): boolean {
+	const normalized = toolName.trim().toLowerCase();
+	return normalized === 'bash' || normalized === 'execute_command' || normalized.includes('shell');
+}
+
+function getCommandArg(args: Record<string, unknown>): string | undefined {
+	const value = args['command'] ?? args['cmd'];
+	return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+
+function getCommandTimeoutLabel(args: Record<string, unknown>): string | undefined {
+	const timeout = args['timeout'];
+	if (typeof timeout === 'number' && Number.isFinite(timeout) && timeout > 0) {
+		return `${timeout}s`;
+	}
+	if (typeof timeout === 'string' && timeout.trim()) {
+		const value = timeout.trim();
+		return /s$/i.test(value) ? value : `${value}s`;
+	}
+	return undefined;
+}
+
 // ──────────────────────────────────────────────
 // Individual tool renderers
 // ──────────────────────────────────────────────
@@ -709,6 +736,37 @@ function parallelTasksRenderers(): ToolRenderers {
 	};
 }
 
+function commandToolRenderers(toolName: string): ToolRenderers {
+	return {
+		renderCall(args, theme) {
+			const display = formatToolDisplay(toolName, args);
+			const timeout = getCommandTimeoutLabel(args);
+
+			if (display.branded) {
+				let text = theme.fg('toolTitle', theme.bold(display.toolName));
+				if (display.toolArgs) {
+					text += theme.fg('accent', ` ${display.toolArgs}`);
+				}
+				if (timeout) {
+					text += theme.fg('dim', ` (timeout ${timeout})`);
+				}
+				return new SimpleText(text);
+			}
+
+			let text = theme.fg('toolTitle', theme.bold('$ '));
+			const commandPreview = getCommandArg(args);
+			text += theme.fg(
+				'accent',
+				truncate(commandPreview ? toSingleLinePreview(commandPreview) : display.toolName, 80)
+			);
+			if (timeout) {
+				text += theme.fg('dim', ` (timeout ${timeout})`);
+			}
+			return new SimpleText(text);
+		},
+	};
+}
+
 // ──────────────────────────────────────────────
 
 const RENDERERS: Record<string, () => ToolRenderers> = {
@@ -736,5 +794,7 @@ const RENDERERS: Record<string, () => ToolRenderers> = {
  */
 export function getToolRenderers(toolName: string): ToolRenderers | undefined {
 	const factory = RENDERERS[toolName];
-	return factory?.();
+	if (factory) return factory();
+	if (isCommandToolName(toolName)) return commandToolRenderers(toolName);
+	return undefined;
 }