pi-ui-extend 1.0.41 → 1.0.42

package/external/pi-tools-suite/src/async-subagents/core/state.ts

@@ -1,10 +1,12 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { activityFromProgressRecord } from "./activity.js";
 import { hasLaunchedAgentPrompt, isDir } from "./paths.js";
 import { readStructuredResult } from "./structured-result.js";
 import type { AgentResult, AgentState, RpcEventRecord, RunState } from "./types.js";
 
 const MAX_RPC_EVENT_LINE_CHARS = 1024 * 1024;
+const LAST_ACTIVITY_TAIL_BYTES = 64 * 1024;
 
 interface AgentStateReadOptions {
 	includeLineCounts?: boolean;
@@ -67,6 +69,9 @@ export function getAgentState(
 		state.finishedAt = fs.readFileSync(finishedAtFile, "utf-8").trim();
 	}
 
+	const lastActivity = readLastActivity(path.join(agentDir, "progress.jsonl"));
+	if (lastActivity) state.lastActivity = lastActivity;
+
 	const retryPendingFile = path.join(agentDir, "retry_pending");
 	const stopRequestedFile = path.join(agentDir, "stop_requested");
 	if (fs.existsSync(retryPendingFile) && !fs.existsSync(stopRequestedFile) && state.status !== "running" && state.status !== "done") {
@@ -109,6 +114,41 @@ function readPid(pidFile: string): number | undefined {
 	return isNaN(pid) ? undefined : pid;
 }
 
+function readLastActivity(filePath: string): AgentState["lastActivity"] | undefined {
+	if (!fs.existsSync(filePath)) return undefined;
+	let fd: number | undefined;
+	try {
+		fd = fs.openSync(filePath, "r");
+		const size = fs.fstatSync(fd).size;
+		if (size <= 0) return undefined;
+		const start = Math.max(0, size - LAST_ACTIVITY_TAIL_BYTES);
+		const buffer = Buffer.allocUnsafe(size - start);
+		const bytesRead = fs.readSync(fd, buffer, 0, buffer.length, start);
+		if (bytesRead <= 0) return undefined;
+		const lines = buffer.toString("utf-8", 0, bytesRead).split(/\r?\n/);
+		if (start > 0) {
+			const previousByte = Buffer.allocUnsafe(1);
+			const previousBytesRead = fs.readSync(fd, previousByte, 0, 1, start - 1);
+			if (previousBytesRead === 1 && previousByte[0] !== 0x0a) lines.shift();
+		}
+		for (let index = lines.length - 1; index >= 0; index--) {
+			const line = lines[index]?.trim();
+			if (!line) continue;
+			try {
+				const activity = activityFromProgressRecord(JSON.parse(line) as unknown);
+				if (activity) return activity;
+			} catch {
+				// Ignore malformed or partially written tail lines and keep scanning.
+			}
+		}
+	} catch {
+		return undefined;
+	} finally {
+		if (fd !== undefined) fs.closeSync(fd);
+	}
+	return undefined;
+}
+
 function hasRpcPromptFailure(eventsFile: string): boolean {
 	if (!fs.existsSync(eventsFile)) return false;
 	let fd: number | undefined;

package/external/pi-tools-suite/src/async-subagents/core/types.ts

@@ -39,6 +39,13 @@ export interface AgentState {
 	eventLines?: number;
 	/** How many times this agent has been retried (0 = first attempt). */
 	retryCount?: number;
+	/** Most recent user-visible activity observed from the sub-agent RPC stream. */
+	lastActivity?: AgentActivity;
+}
+
+export interface AgentActivity {
+	label: string;
+	at: string;
 }
 
 /** Retry configuration for failed agents. */

package/external/pi-tools-suite/src/async-subagents/index.ts

@@ -7,6 +7,7 @@ import {
 	getRunState,
 	getRunRoot,
 	getSubagentRegistryPath,
+	filterSubagentConfigForParentModel,
 	isBlindModelRef,
 	loadSubagentConfig,
 	listSubagentSessionRecords,
@@ -14,9 +15,11 @@ import {
 	removeSubagentRunsFromRegistry,
 	stopAgents,
 	type AgentCompletionHandler,
+	type RpcEventRecord,
 	type StopSignal,
 	type SubagentSessionRecord,
 } from "./lib.js";
+import { activityFromRpcEvent } from "./core/activity.js";
 import { buildUltraworkPrompt, isUltraworkEnvEnabled, registerCommands } from "./commands.js";
 import { agentStrategyPrompt, appendAgentStrategyPrompt } from "./core/agent-strategy.js";
 import { buildSubagentCatalogPrompt } from "./core/agent-catalog.js";
@@ -41,6 +44,7 @@ function isTerminalAgentStatus(status: AgentState["status"]): boolean {
 
 const SUBAGENTS_LIVE_COUNT_EVENT = "pi-tools-suite:async-subagents:live-count";
 const SUBAGENTS_LIVE_STATE_EVENT = "pi-tools-suite:async-subagents:live-state";
+export const SUBAGENTS_CATALOG_STATE_EVENT = "pi-tools-suite:async-subagents:catalog";
 const SESSION_SHUTDOWN_KILL_GRACE_MS = 500;
 const COMPLETION_WATCH_INTERVAL_MS = 2_000;
 
@@ -54,6 +58,14 @@ interface ShutdownPlan {
 	runDirsToDelete: string[];
 }
 
+interface SubagentCatalogStateEvent {
+	version: 1;
+	sessionId?: string;
+	sessionFile?: string;
+	model?: string;
+	types: string[];
+}
+
 function createLiveStatePayload(
 	liveAgents: Map<string, Map<string, LiveAgent>>,
 	sessionFile: string | undefined,
@@ -65,7 +77,13 @@ function createLiveStatePayload(
 		if (matchingLiveAgents.length === 0) continue;
 		const agentIds = matchingLiveAgents.map((agent) => agent.agentId);
 		const state = getRunState(runDir, agentIds, { includeLineCounts: false, checkRpcPromptFailure: false });
-		const activeAgents = state.agents.filter((agent) => !isTerminalAgentStatus(agent.status));
+		const liveAgentsById = new Map(matchingLiveAgents.map((agent) => [agent.agentId, agent]));
+		const activeAgents = state.agents
+			.filter((agent) => !isTerminalAgentStatus(agent.status))
+			.map((agent) => {
+				const lastActivity = liveAgentsById.get(agent.id)?.lastActivity;
+				return lastActivity ? { ...agent, lastActivity } : agent;
+			});
 		if (activeAgents.length === 0) continue;
 		count += activeAgents.length;
 		const tasks = matchingLiveAgents.map((agent) => agent.preview).filter((preview): preview is NonNullable<typeof preview> => Boolean(preview));
@@ -84,6 +102,25 @@ function createLiveStatePayload(
 	};
 }
 
+function createSubagentCatalogState(ctx: unknown): SubagentCatalogStateEvent {
+	const cwd = (ctx as { cwd?: string } | undefined)?.cwd ?? process.cwd();
+	const model = modelRefFromContext(ctx);
+	const config = safeLoadSubagentConfig(cwd);
+	const effective = config ? filterSubagentConfigForParentModel(config, model) : undefined;
+	const sessionManager = (ctx as {
+		sessionManager?: { getSessionId?: () => string; getSessionFile?: () => string | undefined };
+	} | undefined)?.sessionManager;
+	const sessionId = typeof sessionManager?.getSessionId === "function" ? sessionManager.getSessionId() : undefined;
+	const sessionFile = typeof sessionManager?.getSessionFile === "function" ? sessionManager.getSessionFile() : undefined;
+	return {
+		version: 1,
+		...(sessionId ? { sessionId } : {}),
+		...(sessionFile ? { sessionFile } : {}),
+		...(model ? { model } : {}),
+		types: Object.keys(effective?.types ?? {}).sort(),
+	};
+}
+
 function agentMatchesSession(agent: LiveAgent, sessionFile: string | undefined): boolean {
 	if (!sessionFile) return true;
 	return agent.parentSession !== undefined && pathsEqual(sessionFile, agent.parentSession);
@@ -106,6 +143,12 @@ export default function (pi: ExtensionAPI) {
 	let completionWatchTimer: ReturnType<typeof setInterval> | undefined;
 	publishSubagentPresetsStartupSection();
 
+	function publishSubagentCatalogState(ctx: unknown): void {
+		const state = createSubagentCatalogState(ctx);
+		pi.events?.emit?.(SUBAGENTS_CATALOG_STATE_EVENT, state);
+		publishRpcSessionState(ctx as Parameters<typeof publishRpcSessionState>[0], SUBAGENTS_CATALOG_STATE_EVENT, state);
+	}
+
 	function refreshSubagentOverlay(): void {
 		try {
 			reconcileLiveAgentCompletions();
@@ -165,7 +208,16 @@ export default function (pi: ExtensionAPI) {
 		refreshSubagentOverlay();
 	};
 
-	registerSubagentsTool(pi, liveAgents, handleAgentCompletion, refreshSubagentOverlay);
+	function handleAgentRpcEvent(runDir: string, agentId: string, event: RpcEventRecord): void {
+		const activity = activityFromRpcEvent(event);
+		if (!activity) return;
+		const liveAgent = liveAgents.get(runDir)?.get(agentId);
+		if (!liveAgent) return;
+		liveAgent.lastActivity = activity;
+		refreshSubagentOverlay();
+	}
+
+	registerSubagentsTool(pi, liveAgents, handleAgentCompletion, refreshSubagentOverlay, handleAgentRpcEvent);
 	registerCommands(pi);
 
 	pi.on("session_start", async (_event, ctx) => {
@@ -173,6 +225,7 @@ export default function (pi: ExtensionAPI) {
 			sawAutoUltraworkCandidate = false;
 			currentSessionFile = sessionFileFromContext(ctx);
 			currentSessionStateContext = ctx;
+			publishSubagentCatalogState(ctx);
 			subagentOverlay.restoreRunningAgents(ctx.cwd, currentSessionFile);
 			refreshSubagentOverlay();
 		} catch (error) {
@@ -180,6 +233,14 @@ export default function (pi: ExtensionAPI) {
 		}
 	});
 
+	pi.on("model_select", (_event, ctx) => {
+		try {
+			publishSubagentCatalogState(ctx);
+		} catch (error) {
+			ignoreStaleExtensionContextError(error);
+		}
+	});
+
 	pi.on("tool_execution_end", async (event) => {
 		if (event.toolName !== "subagents" && !event.toolName.startsWith("async_subagents_")) return;
 		refreshSubagentOverlay();
@@ -192,7 +253,10 @@ export default function (pi: ExtensionAPI) {
 		});
 		const visionPrompt = visionCapabilityPrompt(event, ctx);
 		const catalogPrompt = selectedToolsInclude(event, "subagents")
-			? subagentCatalogPrompt((ctx as { cwd?: string } | undefined)?.cwd ?? process.cwd())
+			? subagentCatalogPrompt(
+				(ctx as { cwd?: string } | undefined)?.cwd ?? process.cwd(),
+				modelRefFromContext(ctx),
+			)
 			: undefined;
 		if (!strategyPrompt && !visionPrompt && !catalogPrompt) return undefined;
 		let systemPrompt = event.systemPrompt ?? "";
@@ -286,9 +350,9 @@ function safeLoadSubagentConfig(cwd: string) {
 	}
 }
 
-function subagentCatalogPrompt(cwd: string): string | undefined {
+function subagentCatalogPrompt(cwd: string, parentModelRef?: string): string | undefined {
 	const config = safeLoadSubagentConfig(cwd);
-	return config ? buildSubagentCatalogPrompt(config) : undefined;
+	return config ? buildSubagentCatalogPrompt(config, parentModelRef) : undefined;
 }
 
 function startupSubagentPresetList(cwd = process.cwd()): string {

package/external/pi-tools-suite/src/async-subagents/lib.ts

@@ -1,4 +1,5 @@
 export type {
+	AgentActivity,
 	AgentCompletionHandler,
 	AgentResult,
 	AgentState,
@@ -12,21 +13,19 @@ export type {
 } from "./core/types.js";
 
 export { createRunDir, getRunRoot, hasAgentPrompt, hasLaunchedAgentPrompt, hasQueuedAgentPrompt, resolveRunDir, validateBasename } from "./core/paths.js";
-export type { CopySubagentConfigSampleResult, ModelByParentEntry, ResolvedAgentTaskConfig, ResolvedSubagentRoutingConfig, ResolveAgentTaskOptions, SubagentConfig, SubagentPreset, SubagentRoutingConfig, SubagentTypeConfig, SubagentVisionConfig } from "./core/config.js";
+export type { ModelByParentEntry, ResolvedAgentTaskConfig, ResolvedSubagentRoutingConfig, ResolveAgentTaskOptions, SubagentConfig, SubagentPreset, SubagentRoutingConfig, SubagentTypeConfig, SubagentVisionConfig } from "./core/config.js";
 export {
-	configFiles,
-	copySubagentConfigSample,
 	currentModelRef,
 	defaultSubagentType,
 	DEFAULT_MAX_CONCURRENT,
 	DEFAULT_RETRY_CONFIG,
 	DEFAULT_ROUTING_CONFIG,
-	existingSubagentConfigFiles,
-	getDefaultSubagentConfigPath,
+	filterSubagentConfigForParentModel,
 	getBuiltinSubagentDefinitionsDir,
-	getSubagentConfigInitTargetPath,
-	getSubagentConfigSamplePath,
+	getBuiltinSubagentPresetsPath,
+	getProjectSubagentPresetsPath,
 	isBlindModelRef,
+	isSubagentTypeAvailableForParent,
 	loadSubagentConfig,
 	resolveAgentTaskConfig,
 	resolveRetryConfig,
@@ -37,7 +36,7 @@ export {
 export { routeSubagentTasks, SubagentRoutingError } from "./core/routing.js";
 export { BROWSER_QA_RUNNER_ENV, getBrowserQaRunnerPath } from "./core/browser-qa.js";
 export type { RoutedSubagentTasks, SubagentRoutingContext } from "./core/routing.js";
-export { agentDefinitionFiles, agentNameFromFilename, parseAgentMarkdown, projectAgentDefinitionFiles, readAgentDefinitionsFromDir, readProjectAgentDefinitions } from "./core/agents-dir.js";
+export { agentDefinitionFiles, agentNameFromFilename, parseAgentMarkdown, projectAgentDefinitionFiles, projectAgentsDir, readAgentDefinitionsFromDir, readProjectAgentDefinitions } from "./core/agents-dir.js";
 export type { AgentDefinition, ProjectAgentDefinition } from "./core/agents-dir.js";
 export { buildSubagentCatalogPrompt } from "./core/agent-catalog.js";
 export type { SubagentPresetSelectionState } from "./core/presets.js";

package/external/pi-tools-suite/src/async-subagents/tools/spawn.ts

@@ -7,7 +7,7 @@ import { ASYNC_SUBAGENT_TOOL_DESCRIPTIONS } from "../../tool-descriptions.js";
 import { SUBAGENT_TYPE_SELECTION_GUIDANCE } from "../core/agent-catalog.js";
 import { selectAvailableAgentModels } from "../core/model-selection.js";
 import { SubagentModelSelectionError } from "../core/config.js";
-import type { AgentCompletionHandler, AgentTask, ResolvedAgentTaskConfig, Semaphore, SpawnedAgent } from "../lib.js";
+import type { AgentCompletionHandler, AgentTask, ResolvedAgentTaskConfig, RpcEventRecord, Semaphore, SpawnedAgent } from "../lib.js";
 import {
 	createRunDir,
 	createSemaphore,
@@ -52,6 +52,7 @@ interface LaunchQueuedAgentOptions {
 	onCancelled: (reason: string) => void;
 	onLaunchError: (error: unknown) => void;
 	onUpdate: () => void;
+	onRpcEvent?: (event: RpcEventRecord) => void;
 }
 
 const PROJECT_SEMAPHORES = new Map<string, Semaphore>();
@@ -71,7 +72,7 @@ function normalizedLimit(limit: number): number {
 }
 
 async function launchQueuedAgent(options: LaunchQueuedAgentOptions): Promise<void> {
-	const { resolved, runDir, cwd, parentSession, semaphore, signal, onResult, onComplete, onCancelled, onLaunchError, onUpdate } = options;
+	const { resolved, runDir, cwd, parentSession, semaphore, signal, onResult, onComplete, onCancelled, onLaunchError, onUpdate, onRpcEvent } = options;
 	let slotAcquired = false;
 	try {
 		await semaphore.acquire(signal);
@@ -111,13 +112,14 @@ async function launchQueuedAgent(options: LaunchQueuedAgentOptions): Promise<voi
 					extraArgs: resolved.extraArgs,
 					fallbackModels: resolved.fallbackModels,
 					signal,
+					onRpcEvent,
 					...spawnOptions,
 				},
 			);
 			onResult(retryResult.initial);
 			retryResult.done.catch(onLaunchError);
 		} else {
-			const result = spawnAgent(runDir, resolved.task, cwd, resolved.extraArgs, undefined, completionHandler, spawnOptions);
+			const result = spawnAgent(runDir, resolved.task, cwd, resolved.extraArgs, onRpcEvent, completionHandler, spawnOptions);
 			onResult(result);
 		}
 		onUpdate();
@@ -195,6 +197,7 @@ export function registerSpawnTool(
 	liveAgents: Map<string, Map<string, LiveAgent>>,
 	handleAgentCompletion: AgentCompletionHandler,
 	onLiveAgentsChange?: () => void,
+	onAgentRpcEvent?: (runDir: string, agentId: string, event: RpcEventRecord) => void,
 ): void {
 	pi.registerTool({
 		...ASYNC_SUBAGENT_TOOL_DESCRIPTIONS.spawnAction,
@@ -226,7 +229,7 @@ export function registerSpawnTool(
 			const activePreset = activePresetName ? config.presets?.[activePresetName] : undefined;
 			if (getSessionSubagentPresetOverride() && !activePreset) {
 				return {
-					content: [{ type: "text", text: `AGENTS_PRESET=${activePresetName} does not match any preset in asyncSubagents config.` }],
+					content: [{ type: "text", text: `AGENTS_PRESET=${activePresetName} does not match any available sub-agent preset.` }],
 					details: {},
 					isError: true,
 				};
@@ -342,6 +345,7 @@ export function registerSpawnTool(
 							details: partialDetails,
 						});
 					},
+					onRpcEvent: (event) => onAgentRpcEvent?.(runDir, task.id, event),
 				});
 			}
 

package/external/pi-tools-suite/src/async-subagents/tools/subagents.ts

@@ -4,7 +4,7 @@ import { Text } from "@earendil-works/pi-tui";
 import { asyncSubagentToolDescriptions } from "../../tool-descriptions.js";
 import { SUBAGENT_TYPE_SELECTION_GUIDANCE } from "../core/agent-catalog.js";
 import { hasIndexedProjectRoot } from "../../lib/project.js";
-import type { AgentCompletionHandler } from "../lib.js";
+import type { AgentCompletionHandler, RpcEventRecord } from "../lib.js";
 import { DEFAULT_SPAWN_WATCH_SECONDS, INLINE_RENDERING } from "../constants.js";
 import { renderSubagentSpawnPrompts } from "../render.js";
 import { emptyToolSlot } from "../ui.js";
@@ -73,10 +73,11 @@ export function registerSubagentsTool(
 	liveAgents: Map<string, Map<string, LiveAgent>>,
 	handleAgentCompletion: AgentCompletionHandler,
 	onLiveAgentsChange?: () => void,
+	onAgentRpcEvent?: (runDir: string, agentId: string, event: RpcEventRecord) => void,
 ): void {
 	const toolDescriptions = asyncSubagentToolDescriptions(hasIndexedProjectRoot());
 	const collector = new ToolCollector();
-	registerSpawnTool(collector as any, liveAgents, handleAgentCompletion, onLiveAgentsChange);
+	registerSpawnTool(collector as any, liveAgents, handleAgentCompletion, onLiveAgentsChange, onAgentRpcEvent);
 	registerStatusTool(collector as any);
 	registerStopTool(collector as any, liveAgents, onLiveAgentsChange);
 	registerWaitTool(collector as any);

package/external/pi-tools-suite/src/async-subagents/types.ts

@@ -6,6 +6,7 @@ export interface LiveAgent {
 	preview?: AgentTaskPreview;
 	/** Parent pi session that spawned/adopted this sub-agent, when known. */
 	parentSession?: string;
+	lastActivity?: AgentState["lastActivity"];
 	completed: Promise<void>;
 }
 

package/external/pi-tools-suite/src/config.ts

@@ -12,6 +12,16 @@ export interface PiToolsSuiteConfig {
 	todoThinkingOverrides: Record<string, TodoThinkingLevel>;
 	/** Vision-capable model used by the coding-discipline lookup tool; unset disables lookup. */
 	lookupModel?: string;
+	resourceRegistry: ResourceRegistryConfig;
+}
+
+export interface ResourceRegistryConfig {
+	/** Git remote containing reusable skills/agents and project-scoped state under projects/. */
+	remote?: string;
+	/** Branch used for installs, updates, and pushes. */
+	branch: string;
+	/** Optional explicit project key for project-scoped registry state when Git remote discovery is unavailable or should be overridden. */
+	projectKey?: string;
 }
 
 type MutableConfig = {
@@ -20,6 +30,7 @@ type MutableConfig = {
 	todoThinking: boolean;
 	todoThinkingOverrides: Map<string, TodoThinkingLevel>;
 	lookupModel: string | undefined;
+	resourceRegistry: ResourceRegistryConfig;
 };
 
 const TODO_THINKING_OVERRIDE_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
@@ -35,8 +46,9 @@ const ENABLED_LIST_KEYS = ["enabledModules", "enabledExtensions"];
 const MODULE_MAP_KEYS = ["modules", "extensions"];
 const DEFAULT_DISABLED_MODULES = new Set<string>(["credential-firewall", "truncation-metadata-normalizer"]);
 const DEFAULT_TODO_THINKING_OVERRIDES = new Map<string, TodoThinkingLevel>([["zai/glm-5.3", "max"]]);
+const DEFAULT_RESOURCE_REGISTRY_BRANCH = "main";
 
-export function getPiToolsSuiteUserConfigPath(homeDir = homedir()): string {
+export function getPiToolsSuiteUserConfigPath(homeDir = process.env.HOME?.trim() || homedir()): string {
 	return join(homeDir, ".config", "pi", "pi-tools-suite.jsonc");
 }
 
@@ -68,6 +80,24 @@ function normalizeLookupModel(raw: unknown): string | undefined {
 	return trimmed ? trimmed : undefined;
 }
 
+function normalizeNonEmptyString(raw: unknown): string | undefined {
+	if (typeof raw !== "string") return undefined;
+	const trimmed = raw.trim();
+	return trimmed ? trimmed : undefined;
+}
+
+function mergeResourceRegistry(config: MutableConfig, raw: unknown): void {
+	if (!isRecord(raw)) return;
+	if (Object.prototype.hasOwnProperty.call(raw, "remote")) {
+		config.resourceRegistry.remote = normalizeNonEmptyString(raw.remote);
+	}
+	const branch = normalizeNonEmptyString(raw.branch);
+	if (branch) config.resourceRegistry.branch = branch;
+	if (Object.prototype.hasOwnProperty.call(raw, "projectKey")) {
+		config.resourceRegistry.projectKey = normalizeNonEmptyString(raw.projectKey);
+	}
+}
+
 function isTodoThinkingLevel(raw: unknown): raw is TodoThinkingLevel {
 	return TODO_THINKING_OVERRIDE_LEVELS.includes(raw as TodoThinkingLevel);
 }
@@ -145,6 +175,7 @@ function mergeConfigLayer(config: MutableConfig, raw: Record<string, unknown>, k
 	if (typeof raw.todoThinking === "boolean") config.todoThinking = raw.todoThinking;
 	mergeTodoThinkingOverrides(config, raw.todoThinkingOverrides);
 	if (Object.prototype.hasOwnProperty.call(raw, "lookupModel")) config.lookupModel = normalizeLookupModel(raw.lookupModel);
+	mergeResourceRegistry(config, raw.resourceRegistry);
 
 	for (const key of DISABLED_LIST_KEYS) addDisabled(config, raw[key], knownModules);
 	for (const key of ENABLED_LIST_KEYS) removeDisabled(config, raw[key], knownModules);
@@ -191,6 +222,13 @@ function applyEnv(config: MutableConfig, env: Env, knownModules: ReadonlySet<str
 	const todoThinking = boolFromEnv(env.PI_TOOLS_SUITE_TODO_THINKING);
 	if (todoThinking !== undefined) config.todoThinking = todoThinking;
 
+	const registryRemote = normalizeNonEmptyString(env.PI_RESOURCE_REGISTRY_REMOTE);
+	if (registryRemote) config.resourceRegistry.remote = registryRemote;
+	const registryBranch = normalizeNonEmptyString(env.PI_RESOURCE_REGISTRY_BRANCH);
+	if (registryBranch) config.resourceRegistry.branch = registryBranch;
+	const registryProjectKey = normalizeNonEmptyString(env.PI_RESOURCE_REGISTRY_PROJECT_KEY);
+	if (registryProjectKey) config.resourceRegistry.projectKey = registryProjectKey;
+
 	return config;
 }
 
@@ -203,6 +241,7 @@ export function loadPiToolsSuiteConfig(moduleNames: readonly string[], options:
 		todoThinking: false,
 		todoThinkingOverrides: new Map(DEFAULT_TODO_THINKING_OVERRIDES),
 		lookupModel: undefined,
+		resourceRegistry: { branch: DEFAULT_RESOURCE_REGISTRY_BRANCH },
 	};
 	const userConfigPath = getPiToolsSuiteUserConfigPath(options.homeDir);
 
@@ -223,5 +262,6 @@ export function loadPiToolsSuiteConfig(moduleNames: readonly string[], options:
 		todoThinking: config.todoThinking,
 		todoThinkingOverrides: Object.fromEntries(config.todoThinkingOverrides),
 		...(config.lookupModel ? { lookupModel: config.lookupModel } : {}),
+		resourceRegistry: { ...config.resourceRegistry },
 	};
 }

package/external/pi-tools-suite/src/context-gateway/config.ts

@@ -7,6 +7,7 @@ import type {
 	ContextGatewayBudgets,
 	ContextGatewayMode,
 	ContextGatewayResolvedConfig,
+	ContextGatewayToolClass,
 } from "./types.js";
 
 export const DEFAULT_CONTEXT_GATEWAY_BUDGETS: Readonly<ContextGatewayBudgets> = Object.freeze({
@@ -17,8 +18,16 @@ export const DEFAULT_CONTEXT_GATEWAY_BUDGETS: Readonly<ContextGatewayBudgets> =
 	maxSearchMatches: 12,
 });
 
-export const CONTEXT_GATEWAY_ENFORCE_UNAVAILABLE =
-	"Context Gateway enforce is unavailable in P01; mode unchanged until capture/store/result-stage integration is implemented.";
+export function contextGatewayBudgetForClass(
+	toolClass: ContextGatewayToolClass,
+	budgets: ContextGatewayBudgets,
+): number {
+	if (toolClass === "code-read") return budgets.maxExactReadBytes;
+	if (["repo-search", "repo-ast", "repo-structure", "ast-grep"].includes(toolClass)) {
+		return budgets.maxSearchBytes;
+	}
+	return budgets.maxResultBytes;
+}
 
 const MODES = new Set<ContextGatewayMode>(["off", "observe", "enforce"]);
 const MAX_BYTE_BUDGET = 64 * 1024 * 1024;

package/external/pi-tools-suite/src/context-gateway/enforcement.ts

@@ -0,0 +1,102 @@
+import type { ShellCommandClassification } from "../shell-command-policy.js";
+import { parseTestBuildOutput, planProspectiveTestOutputDelivery } from "./test-output-parser.js";
+import type { ContextGatewayToolClass } from "./types.js";
+
+type ResultContent = unknown;
+
+export interface ContextGatewayEnforcementPlan {
+	representation: "passthrough" | "test-build-compact";
+	content: ResultContent;
+	sourceContentBytes: number;
+	contentBytes: number;
+	textBytes: number;
+	reason: string;
+}
+
+function byteLengthJson(value: unknown): number {
+	if (value === undefined) return 0;
+	try {
+		return new TextEncoder().encode(JSON.stringify(value)).byteLength;
+	} catch {
+		return 0;
+	}
+}
+
+function contentText(content: unknown): string {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	return content
+		.filter((part) => part && typeof part === "object" && !Array.isArray(part)
+			&& (part as Record<string, unknown>).type === "text"
+			&& typeof (part as Record<string, unknown>).text === "string")
+		.map((part) => (part as Record<string, unknown>).text as string)
+		.join("\n");
+}
+
+function textOnlyContent(content: unknown): boolean {
+	return Array.isArray(content)
+		&& content.every((part) => part && typeof part === "object" && !Array.isArray(part)
+			&& (part as Record<string, unknown>).type === "text"
+			&& typeof (part as Record<string, unknown>).text === "string");
+}
+
+function upstreamTruncated(details: unknown): boolean {
+	if (!details || typeof details !== "object" || Array.isArray(details)) return false;
+	const record = details as Record<string, unknown>;
+	if (record.truncated === true) return true;
+	const truncation = record.truncation;
+	return !!truncation && typeof truncation === "object" && !Array.isArray(truncation)
+		&& (truncation as Record<string, unknown>).truncated === true;
+}
+
+/**
+ * Selective storeless enforcement. It never performs generic truncation.
+ * Only recognised, complete, simple test/build output is compacted; every
+ * other result stays byte-for-byte passthrough until a recovery contract exists.
+ */
+export function planContextGatewayEnforcement(input: {
+	event: { content?: unknown; details?: unknown; isError?: boolean };
+	toolClass: ContextGatewayToolClass;
+	shell: ShellCommandClassification;
+	budgetBytes: number;
+	maxInlineBytes: number;
+}): ContextGatewayEnforcementPlan {
+	const sourceText = contentText(input.event.content);
+	const sourceContentBytes = byteLengthJson(input.event.content);
+	const passthrough = (reason: string): ContextGatewayEnforcementPlan => ({
+		representation: "passthrough",
+		content: input.event.content,
+		sourceContentBytes,
+		contentBytes: sourceContentBytes,
+		textBytes: new TextEncoder().encode(sourceText).byteLength,
+		reason,
+	});
+
+	if (input.toolClass !== "shell") return passthrough("class-not-enforced");
+	if (input.shell.scope !== "simple" || input.shell.kind !== "test-build") {
+		return passthrough("shell-not-proven-test-build");
+	}
+	if (!textOnlyContent(input.event.content)) return passthrough("non-text-content");
+	if (sourceContentBytes <= input.budgetBytes) return passthrough("within-class-budget");
+
+	const parsed = parseTestBuildOutput({
+		text: sourceText,
+		hostOutcome: input.event.isError === true ? "error" : "success",
+		upstreamTruncated: upstreamTruncated(input.event.details),
+	});
+	const compact = planProspectiveTestOutputDelivery(parsed, input.maxInlineBytes, {
+		commandScope: input.shell.scope,
+	});
+	if (compact.decision !== "compact-candidate" || !compact.text) {
+		return passthrough(compact.reason);
+	}
+	const content = [{ type: "text" as const, text: compact.text }];
+	return {
+		representation: "test-build-compact",
+		content,
+		sourceContentBytes,
+		contentBytes: byteLengthJson(content),
+		textBytes: new TextEncoder().encode(compact.text).byteLength,
+		reason: compact.reason,
+	};
+}