pi-ui-extend 1.0.41 → 1.0.45

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,
@@ -35,9 +34,17 @@ export {
 	shouldForceCurrentSubagentModel,
 } from "./core/config.js";
 export { routeSubagentTasks, SubagentRoutingError } from "./core/routing.js";
-export { BROWSER_QA_RUNNER_ENV, getBrowserQaRunnerPath } from "./core/browser-qa.js";
+export {
+	BROWSER_QA_RUNNER_ENV,
+	UI_QA_RUNNER_ENV,
+	LEGACY_BROWSER_QA_TYPE,
+	UI_QA_TYPE,
+	getBrowserQaRunnerPath,
+	getUiQaRunnerPath,
+	isUiQaType,
+} 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);
@@ -98,7 +99,6 @@ async function launchQueuedAgent(options: LaunchQueuedAgentOptions): Promise<voi
 			parentSession,
 			maxResultBytes: resolved.maxResultBytes,
 			timeoutMs: resolved.timeoutMs,
-			isolatedSkills: resolved.isolatedSkills,
 		};
 		if (resolved.retry.maxRetries > 0 || resolved.fallbackModels.length > 0) {
 			const retryResult = spawnAgentWithRetry(
@@ -111,13 +111,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 +196,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 +228,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 +344,7 @@ export function registerSpawnTool(
 							details: partialDetails,
 						});
 					},
+					onRpcEvent: (event) => onAgentRpcEvent?.(runDir, task.id, event),
 				});
 			}
 

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

@@ -3,8 +3,8 @@ import { Type } from "@earendil-works/pi-ai";
 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 { hasAvailableIndexedProjectRoot } from "../../lib/project.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 toolDescriptions = asyncSubagentToolDescriptions(hasAvailableIndexedProjectRoot());
 	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/coding-discipline/index.ts

@@ -22,6 +22,11 @@ type LookupDetails = {
 	contextChars: number;
 	stopReason?: string;
 	error?: string;
+	attempts?: Array<{
+		ref: string;
+		outcome: "ok" | "unavailable" | "error" | "empty";
+		error?: string;
+	}>;
 };
 
 type ResolvedLookupModel = {
@@ -473,8 +478,9 @@ function createLookupTool() {
 		executionMode: "sequential" as const,
 		async execute(_toolCallId: string, params: LookupParams, signal: AbortSignal | undefined, _onUpdate: unknown, ctx: unknown) {
 			const cwd = contextCwd(ctx) ?? process.cwd();
-			const lookupModelRef = lookupModelFromConfig(cwd);
-			if (!lookupModelRef) {
+			const lookupModelRefs = lookupModelRefsFromConfig(cwd);
+			const primaryLookupModelRef = lookupModelRefs[0];
+			if (!primaryLookupModelRef) {
 				return lookupToolTextResult("lookupModel is not configured in pi-tools-suite config; lookup is disabled.", {
 					model: "",
 					imageCount: 0,
@@ -484,69 +490,86 @@ function createLookupTool() {
 				});
 			}
 
-			const resolved = await resolveLookupModel(ctx, lookupModelRef);
-			if (!resolved) {
-				return lookupToolTextResult(`Lookup model is unavailable or unauthenticated: ${lookupModelRef}`, {
-					model: lookupModelRef,
-					imageCount: 0,
-					imagePathCount: params.imagePaths?.length ?? 0,
-					contextChars: 0,
-					error: "lookup model unavailable",
-				});
-			}
-
 			const recentContext = buildRecentSessionContext(ctx, DEFAULT_LOOKUP_MAX_CONTEXT_CHARS);
 			const sessionImages = extractRecentSessionImages(ctx, DEFAULT_LOOKUP_MAX_IMAGES);
 			const pathImages = readImagePathContents(cwd, params.imagePaths ?? [], Math.max(0, DEFAULT_LOOKUP_MAX_IMAGES - sessionImages.length));
 			const images = [...sessionImages, ...pathImages.images].slice(0, DEFAULT_LOOKUP_MAX_IMAGES);
 			const promptText = buildLookupPrompt(params, recentContext, images.length, pathImages.warnings);
+			const attempts: NonNullable<LookupDetails["attempts"]> = [];
+
+			for (const lookupModelRef of lookupModelRefs) {
+				if (signal?.aborted) throw signal.reason ?? new Error("Lookup aborted");
+				let resolved: ResolvedLookupModel | undefined;
+				try {
+					resolved = await resolveLookupModel(ctx, lookupModelRef);
+				} catch (error) {
+					if (signal?.aborted || isAbortError(error)) throw error;
+					attempts.push({ ref: lookupModelRef, outcome: "error", error: error instanceof Error ? error.message : String(error) });
+					continue;
+				}
+				if (!resolved) {
+					attempts.push({ ref: lookupModelRef, outcome: "unavailable" });
+					continue;
+				}
 
-			try {
-				const response = await completeWithModelRegistry(
-					resolved.modelRegistry,
-					resolved.model,
-					{
-						systemPrompt: LOOKUP_SYSTEM_PROMPT,
-						messages: [
-							{
-								role: "user" as const,
-								content: [{ type: "text" as const, text: promptText }, ...images],
-								timestamp: Date.now(),
-							},
-						],
-					},
-					{
-						apiKey: resolved.apiKey,
-						headers: resolved.headers,
-						env: resolved.env,
-						cacheRetention: "none",
-						maxRetries: 1,
-						maxTokens: DEFAULT_LOOKUP_MAX_TOKENS,
-						signal,
-						timeoutMs: DEFAULT_LOOKUP_TIMEOUT_MS,
-					},
-				);
-				const text = responseText(response).trim() || "Lookup returned no text.";
-				const suffix = response.stopReason === "error" && response.errorMessage ? `\n\nLookup error: ${response.errorMessage}` : "";
-				return lookupToolTextResult(`${text}${suffix}`, {
-					model: lookupModelRef,
-					imageCount: images.length,
-					imagePathCount: pathImages.images.length,
-					contextChars: recentContext.length,
-					stopReason: response.stopReason,
-					...(response.stopReason === "error" && response.errorMessage ? { error: response.errorMessage } : {}),
-				});
-			} catch (error) {
-				if (signal?.aborted || isAbortError(error)) throw error;
-				const message = error instanceof Error ? error.message : String(error);
-				return lookupToolTextResult(`Lookup failed: ${message}`, {
-					model: lookupModelRef,
-					imageCount: images.length,
-					imagePathCount: pathImages.images.length,
-					contextChars: recentContext.length,
-					error: message,
-				});
+				try {
+					const response = await completeWithModelRegistry(
+						resolved.modelRegistry,
+						resolved.model,
+						{
+							systemPrompt: LOOKUP_SYSTEM_PROMPT,
+							messages: [
+								{
+									role: "user" as const,
+									content: [{ type: "text" as const, text: promptText }, ...images],
+									timestamp: Date.now(),
+								},
+							],
+						},
+						{
+							apiKey: resolved.apiKey,
+							headers: resolved.headers,
+							env: resolved.env,
+							cacheRetention: "none",
+							maxRetries: 1,
+							maxTokens: DEFAULT_LOOKUP_MAX_TOKENS,
+							signal,
+							timeoutMs: DEFAULT_LOOKUP_TIMEOUT_MS,
+						},
+					);
+					if (signal?.aborted || response.stopReason === "aborted") throw signal?.reason ?? new Error("Lookup aborted");
+					if (response.stopReason === "error") {
+						attempts.push({ ref: lookupModelRef, outcome: "error", ...(response.errorMessage ? { error: response.errorMessage } : {}) });
+						continue;
+					}
+					const text = responseText(response).trim();
+					if (!text) {
+						attempts.push({ ref: lookupModelRef, outcome: "empty" });
+						continue;
+					}
+					attempts.push({ ref: lookupModelRef, outcome: "ok" });
+					return lookupToolTextResult(text, {
+						model: lookupModelRef,
+						imageCount: images.length,
+						imagePathCount: pathImages.images.length,
+						contextChars: recentContext.length,
+						stopReason: response.stopReason,
+						attempts,
+					});
+				} catch (error) {
+					if (signal?.aborted || isAbortError(error)) throw error;
+					attempts.push({ ref: lookupModelRef, outcome: "error", error: error instanceof Error ? error.message : String(error) });
+				}
 			}
+
+			return lookupToolTextResult("Lookup failed across configured models.", {
+				model: primaryLookupModelRef,
+				imageCount: images.length,
+				imagePathCount: pathImages.images.length,
+				contextChars: recentContext.length,
+				error: "all lookup models failed",
+				attempts,
+			});
 		},
 	};
 }
@@ -585,7 +608,15 @@ function isInstructionMessage(message: unknown): boolean {
 }
 
 function lookupModelFromConfig(cwd?: string): string | undefined {
-	return loadPiToolsSuiteConfig(["coding-discipline"], { cwd: cwd ?? process.cwd() }).lookupModel;
+	return lookupModelRefsFromConfig(cwd)[0];
+}
+
+function lookupModelRefsFromConfig(cwd?: string): string[] {
+	const config = loadPiToolsSuiteConfig(["coding-discipline"], { cwd: cwd ?? process.cwd() });
+	if (!config.lookupModel) return [];
+	return [...new Set([config.lookupModel, ...config.lookupFallbackModels]
+		.map((modelRef) => modelRef.trim())
+		.filter(Boolean))];
 }
 
 function buildLookupPrompt(params: LookupParams, recentContext: string, imageCount: number, warnings: string[]): string {

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

@@ -12,6 +12,18 @@ export interface PiToolsSuiteConfig {
 	todoThinkingOverrides: Record<string, TodoThinkingLevel>;
 	/** Vision-capable model used by the coding-discipline lookup tool; unset disables lookup. */
 	lookupModel?: string;
+	/** Ordered lookup fallbacks tried after lookupModel. Always present, even when empty. */
+	lookupFallbackModels: 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 +32,8 @@ type MutableConfig = {
 	todoThinking: boolean;
 	todoThinkingOverrides: Map<string, TodoThinkingLevel>;
 	lookupModel: string | undefined;
+	lookupFallbackModels: string[];
+	resourceRegistry: ResourceRegistryConfig;
 };
 
 const TODO_THINKING_OVERRIDE_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
@@ -35,8 +49,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 +83,32 @@ function normalizeLookupModel(raw: unknown): string | undefined {
 	return trimmed ? trimmed : undefined;
 }
 
+function normalizeModelList(raw: unknown): string[] {
+	if (!Array.isArray(raw)) return [];
+	return [...new Set(raw
+		.filter((value): value is string => typeof value === "string")
+		.map((value) => value.trim())
+		.filter(Boolean))];
+}
+
+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 +186,8 @@ 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);
+	if (Object.prototype.hasOwnProperty.call(raw, "lookupFallbackModels")) config.lookupFallbackModels = normalizeModelList(raw.lookupFallbackModels);
+	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 +234,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 +253,8 @@ export function loadPiToolsSuiteConfig(moduleNames: readonly string[], options:
 		todoThinking: false,
 		todoThinkingOverrides: new Map(DEFAULT_TODO_THINKING_OVERRIDES),
 		lookupModel: undefined,
+		lookupFallbackModels: [],
+		resourceRegistry: { branch: DEFAULT_RESOURCE_REGISTRY_BRANCH },
 	};
 	const userConfigPath = getPiToolsSuiteUserConfigPath(options.homeDir);
 
@@ -223,5 +275,7 @@ export function loadPiToolsSuiteConfig(moduleNames: readonly string[], options:
 		todoThinking: config.todoThinking,
 		todoThinkingOverrides: Object.fromEntries(config.todoThinkingOverrides),
 		...(config.lookupModel ? { lookupModel: config.lookupModel } : {}),
+		lookupFallbackModels: [...config.lookupFallbackModels],
+		resourceRegistry: { ...config.resourceRegistry },
 	};
 }