@selesai/code 0.13.40 → 0.14.3

package/dist/extensions/pi-subagents/src/slash/delegation-adapters.ts

@@ -4,9 +4,10 @@ import {
 	type SubagentDelegationStatus,
 	type SubagentDelegationThinking,
 	type SubagentDelegationUpdate,
+	type SubagentDelegationUpdateUsage,
 	type SubagentDelegationValue,
 } from "../api/delegation.ts";
-import type { AcceptanceInput, AgentContract, EffectsProjection, ExecutionProjection, JsonSchemaObject, ReviewProjection, ToolBudgetConfig, Usage } from "../shared/types.ts";
+import type { AcceptanceInput, AgentContract, AgentProgress, EffectsProjection, ExecutionProjection, IntercomBridgeConfig, JsonSchemaObject, ReviewProjection, ToolBudgetConfig, Usage } from "../shared/types.ts";
 import { cloneJsonWithinByteLimit } from "./delegation-json.ts";
 
 export interface PromptTemplateDelegationRequest {
@@ -52,6 +53,7 @@ export interface PromptTemplateDelegationUpdate {
 	toolCount?: number;
 	durationMs?: number;
 	tokens?: number;
+	usage?: SubagentDelegationUpdateUsage;
 	taskProgress?: PromptTemplateDelegationTaskProgress[];
 }
 
@@ -108,6 +110,11 @@ export interface PromptTemplateBridgeResult {
 			toolCount?: number;
 			durationMs?: number;
 			tokens?: number;
+			inputTokens?: number;
+			outputTokens?: number;
+			cacheRead?: number;
+			cacheWrite?: number;
+			turnCount?: number;
 		}>;
 	};
 }
@@ -127,6 +134,7 @@ export interface DelegatedSubagentExecutionParams {
 	agentContract?: AgentContract;
 	acceptance?: AcceptanceInput;
 	artifacts?: boolean;
+	intercomBridge?: IntercomBridgeConfig;
 	/** Internal-only thinking override accepted by executeDelegated. */
 	delegatedThinkingOverride?: SubagentDelegationThinking;
 	/** Internal-only capability accepted and stripped by executeDelegated. */
@@ -237,6 +245,21 @@ function buildDelegationMessages(
 	return [{ role: "assistant", content }];
 }
 
+function isFiniteNonNegative(value: unknown): value is number {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+
+function buildDelegationUpdateUsage(entry: Pick<AgentProgress, "inputTokens" | "outputTokens" | "cacheRead" | "cacheWrite" | "turnCount"> | undefined): SubagentDelegationUpdateUsage | undefined {
+	if (!entry) return undefined;
+	const { inputTokens, outputTokens, cacheRead, cacheWrite, turnCount } = entry;
+	if (!isFiniteNonNegative(inputTokens)
+		|| !isFiniteNonNegative(outputTokens)
+		|| !isFiniteNonNegative(cacheRead)
+		|| !isFiniteNonNegative(cacheWrite)
+		|| !isFiniteNonNegative(turnCount)) return undefined;
+	return { input: inputTokens, output: outputTokens, cacheRead, cacheWrite, turns: turnCount };
+}
+
 export function toDelegationUpdate(requestId: string, update: PromptTemplateBridgeResult): PromptTemplateDelegationUpdate | undefined {
 	const progress = update.details?.progress?.[0];
 	const taskProgress = update.details?.progress?.map((entry) => {
@@ -276,6 +299,7 @@ export function toDelegationUpdate(requestId: string, update: PromptTemplateBrid
 		recentTools: sanitizeRecentTools(progress?.recentTools),
 		model: progress ? resolveProgressModel(update, progress) : undefined,
 		toolCount: progress?.toolCount,
+		usage: buildDelegationUpdateUsage(progress),
 		durationMs: progress?.durationMs,
 		tokens: progress?.tokens,
 		taskProgress,
@@ -295,6 +319,7 @@ export function toSubagentDelegationExecutionParams(request: SubagentDelegationR
 		...(request.result.kind === "structured" ? { outputSchema: request.result.schema } : {}),
 		acceptance: false,
 		artifacts: request.artifacts,
+		...(request.intercomBridge !== undefined ? { intercomBridge: request.intercomBridge } : {}),
 		delegatedThinkingOverride: request.thinking,
 		delegatedAllowZeroToolBudget: true,
 		async: false,
@@ -323,6 +348,7 @@ export function toSubagentDelegationUpdate(
 		...(typeof legacy.toolCount === "number" ? { toolCount: legacy.toolCount } : {}),
 		...(typeof legacy.durationMs === "number" ? { durationMs: legacy.durationMs } : {}),
 		...(typeof legacy.tokens === "number" ? { tokens: legacy.tokens } : {}),
+		...(legacy.usage ? { usage: legacy.usage } : {}),
 	};
 }
 
@@ -423,4 +449,4 @@ export function toPromptTemplateResponse(
 		isError: result.isError === true,
 		errorText: result.isError ? contentText : undefined,
 	};
-}
+}

package/dist/extensions/pi-subagents/src/slash/delegation-request.ts

@@ -1,7 +1,9 @@
 import {
 	type SubagentDelegationRequest,
 } from "../api/delegation.ts";
+import { validateIntercomBridgeConfig } from "../intercom/intercom-bridge.ts";
 import { validateToolBudgetConfig } from "../runs/shared/tool-budget.ts";
+import type { IntercomBridgeConfig } from "../shared/types.ts";
 import { cloneJsonWithinByteLimit } from "./delegation-json.ts";
 
 export type SubagentDelegationParseResult =
@@ -22,6 +24,7 @@ const supportedFields = new Set([
 	"toolBudget",
 	"skill",
 	"artifacts",
+	"intercomBridge",
 	"result",
 ]);
 
@@ -97,6 +100,15 @@ export function parseSubagentDelegationRequest(data: unknown): SubagentDelegatio
 	if (value.artifacts !== undefined && typeof value.artifacts !== "boolean") {
 		return { ok: false, ...identity, error: "artifacts must be a boolean." };
 	}
+	let intercomBridge: IntercomBridgeConfig | undefined;
+	if (value.intercomBridge !== undefined) {
+		const bridge = validateIntercomBridgeConfig({ value: value.intercomBridge, label: "intercomBridge" });
+		if (!bridge.ok) return { ok: false, ...identity, error: bridge.error };
+		if (typeof bridge.value.instructionFile === "string" && Buffer.byteLength(bridge.value.instructionFile, "utf8") > MAX_SHORT_TEXT_BYTES) {
+			return { ok: false, ...identity, error: "intercomBridge.instructionFile exceeds 1 KiB when UTF-8 encoded." };
+		}
+		intercomBridge = bridge.value;
+	}
 	if (Buffer.byteLength(value.task as string, "utf8") > MAX_TASK_BYTES) {
 		return { ok: false, ...identity, error: "Delegation task exceeds 1 MiB when UTF-8 encoded." };
 	}
@@ -154,9 +166,11 @@ export function parseSubagentDelegationRequest(data: unknown): SubagentDelegatio
 		ok: true,
 		request: {
 			...value,
+			// The validated copy replaces the caller's object so the request never aliases untrusted input.
+			...(intercomBridge ? { intercomBridge } : {}),
 			result: structuredSchema
 				? { kind: "structured", schema: structuredSchema }
 				: { kind: "text" },
 		} as unknown as SubagentDelegationRequest,
 	};
-}
+}

package/dist/extensions/pi-subagents/src/slash/prompt-template-bridge.ts

@@ -82,6 +82,20 @@ function sameRecentTools(
 	return left.every((tool, index) => tool.tool === right[index]?.tool && tool.args === right[index]?.args);
 }
 
+/** A cache-only or turn-only change with unchanged tokens/tool progress must still count as a change, not a heartbeat. */
+function sameUpdateUsage(
+	left: SubagentDelegationUpdate["usage"],
+	right: SubagentDelegationUpdate["usage"],
+): boolean {
+	if (left === right) return true;
+	if (!left || !right) return false;
+	return left.input === right.input
+		&& left.output === right.output
+		&& left.cacheRead === right.cacheRead
+		&& left.cacheWrite === right.cacheWrite
+		&& left.turns === right.turns;
+}
+
 /** Duration is a heartbeat clock, not delegation-visible progress; terminal usage remains authoritative. */
 function sameStructuredDelegationUpdateProgress(left: SubagentDelegationUpdate, right: SubagentDelegationUpdate): boolean {
 	return left.requestId === right.requestId
@@ -95,7 +109,8 @@ function sameStructuredDelegationUpdateProgress(left: SubagentDelegationUpdate,
 		&& sameRecentTools(left.recentTools, right.recentTools)
 		&& left.model === right.model
 		&& left.toolCount === right.toolCount
-		&& left.tokens === right.tokens;
+		&& left.tokens === right.tokens
+		&& sameUpdateUsage(left.usage, right.usage);
 }
 
 export function registerPromptTemplateDelegationBridge<Ctx extends { cwd?: string }>(
@@ -219,7 +234,7 @@ export function registerPromptTemplateDelegationBridge<Ctx extends { cwd?: strin
 						requestId: legacy.requestId,
 						messages: [],
 						isError: true,
-						errorText: "Legacy prompt-template tasks/worktree orchestration was removed; use workflowScript.",
+						errorText: "Legacy prompt-template tasks/worktree orchestration was removed; use a workflow script.",
 					});
 					return;
 				}
@@ -230,7 +245,7 @@ export function registerPromptTemplateDelegationBridge<Ctx extends { cwd?: strin
 				...legacyRequest,
 				messages: [],
 				isError: true,
-				errorText: "Legacy prompt-template direct delegation was removed; use workflowScript through the subagent tool or structured delegation.",
+				errorText: "Legacy prompt-template direct delegation was removed; use a workflow script through the subagent tool or structured delegation.",
 			} satisfies PromptTemplateDelegationResponse);
 			return;
 		}
@@ -416,4 +431,4 @@ export function registerPromptTemplateDelegationBridge<Ctx extends { cwd?: strin
 			settledAttempts.clear();
 		},
 	};
-}
+}

package/dist/extensions/pi-subagents/src/slash/prompt-workflows.ts

@@ -41,7 +41,18 @@ function readPromptFiles(cwd: string): string[] {
 			continue;
 		}
 		for (const entry of entries) {
-			if (entry.isFile() && entry.name.endsWith(".md")) files.push(path.join(dir, entry.name));
+			if (!entry.name.endsWith(".md")) continue;
+			const filePath = path.join(dir, entry.name);
+			let isFile = entry.isFile();
+			if (entry.isSymbolicLink()) {
+				try {
+					isFile = fs.statSync(filePath).isFile();
+				} catch (error) {
+					if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+					isFile = false;
+				}
+			}
+			if (isFile) files.push(filePath);
 		}
 	}
 	return files;
@@ -284,4 +295,4 @@ export function registerPromptWorkflowCommands(input: {
 		},
 	});
 
-}
+}

package/dist/extensions/pi-subagents/src/slash/slash-commands.ts

@@ -24,13 +24,12 @@ import { listScheduledRunSummaries } from "../runs/background/scheduled-runs.ts"
 import { resolveAsyncStatusChild } from "../runs/shared/child-identity.ts";
 import { readStatus } from "../shared/utils.ts";
 
-import { FLEET_OPEN_SHORTCUT } from "../shared/shortcuts.ts";
 import type { SlashSubagentResponse, SlashSubagentUpdate } from "./slash-bridge.ts";
 import { registerPromptWorkflowCommands } from "./prompt-workflows.ts";
 import { collectSubagentCost, formatSubagentCostReport } from "./subagent-cost.ts";
 import { openSubagentsAdmin } from "./subagents-admin.ts";
 import { SUBAGENT_GUIDE_TOPICS } from "../extension/subagent-guide.ts";
-import { openSubagentFleet } from "../tui/fleet.ts";
+import { getInspectorPlugins } from "../inspectors/plugins.ts";
 import {
 	applySlashUpdate,
 	buildSlashInitialResult,
@@ -122,7 +121,7 @@ function discoverSlashAgents(pi: ExtensionAPI, cwd: string, scope: AgentScope):
 		...(scope !== "project" ? all.user : []),
 		...(scope !== "user" ? all.project : []),
 	];
-	const merged = mergeRuntimeAgents(pi, discovered, configuredAgents);
+	const merged = mergeRuntimeAgents(pi, discovered, configuredAgents, { cwd, scope });
 	return { ...merged, unknownAgentDiagnosticContext: { ...unknownAgentDiagnosticContext(discovered), agents: merged.agents } };
 }
 
@@ -602,14 +601,19 @@ export function launchSlashSubagent(
 }
 
 
-function slashRunWorkflowScript(key: string, child: Record<string, unknown>): string {
+function slashRunWorkflowScript(key: string, child: SubagentParamsLike): string {
 	return `return runs.run(${JSON.stringify(key)}, ${JSON.stringify(child)})`;
 }
 
 export function registerSlashCommands(
 	pi: ExtensionAPI,
 	state: SubagentState,
-	options: { fleetKeybindings?: FleetKeybindingsConfig; foregroundDetachShortcut?: string } = {},
+	options: {
+		fleetKeybindings?: FleetKeybindingsConfig;
+		foregroundDetachShortcut?: string;
+		/** disabledFeatures "workflow-scripts": /run launches its one child directly instead of through a script. */
+		workflowScriptsDisabled?: boolean;
+	} = {},
 ): { dispose: () => void } {
 	let fleetOpen = false;
 	let disposed = false;
@@ -635,7 +639,8 @@ export function registerSlashCommands(
 		}
 		fleetOpen = true;
 		try {
-			await openSubagentFleet(ctx, state, { asyncDirRoot: DIRS.async, resultsDir: DIRS.results, fleetKeybindings: options.fleetKeybindings });
+			const { openSubagentFleet } = await import("../tui/fleet.ts");
+			await openSubagentFleet(ctx, state, { asyncDirRoot: DIRS.async, inspectorPlugins: () => getInspectorPlugins(pi), resultsDir: DIRS.results, fleetKeybindings: options.fleetKeybindings });
 		} finally {
 			fleetOpen = false;
 		}
@@ -649,7 +654,7 @@ export function registerSlashCommands(
 	});
 
 	pi.registerCommand("run", {
-		description: "Run one subagent through workflowScript: /run agent[output=file] [task] [--bg] [--fork]",
+		description: "Run one subagent through a workflow script: /run agent[output=file] [task] [--bg] [--fork]",
 		getArgumentCompletions: makeAgentCompletions(pi, state),
 		handler: async (args, ctx) => {
 			const { args: cleanedArgs, bg, fork } = extractExecutionFlags(args);
@@ -676,13 +681,13 @@ export function registerSlashCommands(
 				const existingReads = inline.reads.filter((read) => resolveExistingReadPaths([read], state.baseCwd).length > 0);
 				if (existingReads.length > 0) finalTask = `[Read from: ${existingReads.join(", ")}]\n\n${finalTask}`;
 			}
-			const child: Record<string, unknown> = { agent: agentName, task: finalTask, agentScope: "both" };
+			const child: SubagentParamsLike = { agent: agentName, task: finalTask, agentScope: "both" };
 			if (inline.output !== undefined) child.output = inline.output;
 			if (inline.outputMode !== undefined) child.outputMode = inline.outputMode;
 			if (inline.skill !== undefined) child.skill = inline.skill;
 			if (inline.model) child.model = inline.model;
 			if (fork) child.context = "fork";
-			launchCommand(ctx, { workflowScript: slashRunWorkflowScript("run", child), async: bg ? true : false });
+			launchCommand(ctx, options.workflowScriptsDisabled ? { ...child, async: bg } : { workflowScript: slashRunWorkflowScript("run", child), async: bg });
 		},
 	});
 
@@ -750,11 +755,6 @@ export function registerSlashCommands(
 		handler: async (_args, ctx) => showFleet(ctx),
 	});
 
-	pi.registerShortcut(FLEET_OPEN_SHORTCUT, {
-		description: "Open subagent fleet inspector",
-		handler: async (ctx) => showFleet(ctx),
-	});
-
 	const detachForegroundRun = (args: string, ctx: ExtensionContext): void => {
 		const id = args.trim();
 		let control: ReturnType<typeof selectForegroundDetachControl>;
@@ -1102,4 +1102,4 @@ export function registerSlashCommands(
 			pendingRequests.clear();
 		},
 	};
-}
+}

package/dist/extensions/pi-subagents/src/slash/subagent-cost.ts

@@ -3,7 +3,7 @@ import * as path from "node:path";
 import type { ExtensionContext } from "@selesai/code";
 import { getArtifactPaths, getArtifactsDir } from "../shared/artifacts.ts";
 import { formatTokens } from "../shared/formatters.ts";
-import { DIRS, SLASH_RESULT_TYPE, type Details, type SingleResult, type SubagentState, type Usage } from "../shared/types.ts";
+import { DIRS, SLASH_RESULT_TYPE, type Details, type SubagentState, type Usage } from "../shared/types.ts";
 import { readStatus } from "../shared/utils.ts";
 import { readWorkflowReceipt } from "../workflows/workflow-receipt.ts";
 import { resolveSlashMessageDetails } from "./slash-live-state.ts";
@@ -124,10 +124,11 @@ function detailsFromSessionEntry(entry: unknown): Details | undefined {
 function metadataUsage(
 	artifactsDirs: string[],
 	input: { runId: string; agent: string },
+	indexes: ReadonlyArray<number | undefined> = [0, undefined],
 ): Usage | undefined {
 	if (!/^[A-Za-z0-9._-]+$/.test(input.runId)) return undefined;
 	for (const artifactsDir of artifactsDirs) {
-		for (const index of [0, undefined] as const) {
+		for (const index of indexes) {
 			const metadataPath = getArtifactPaths(artifactsDir, input.runId, input.agent, index).metadataPath;
 			try {
 				const metadata = readUsageMetadata(metadataPath);
@@ -146,7 +147,8 @@ function metadataUsage(
 /**
  * Collect parent and child usage for the current session branch. Foreground
  * children come from persisted `subagent`/`bg_wait` tool-result details; async
- * workflow children are resolved through receipts and artifact metadata.
+ * workflow children are resolved through receipts, and other async runs through
+ * their status steps, then artifact metadata.
  */
 export function collectSubagentCost(
 	ctx: ExtensionContext,
@@ -158,11 +160,13 @@ export function collectSubagentCost(
 	const children: SubagentCostChild[] = [];
 	const seenChildren = new Set<string>();
 	const workflowRunIds = new Set<string>();
+	const asyncRunIds = new Set<string>();
+	const completedRunIds = new Set<string>();
 	let unresolvedAsyncChildren = 0;
 
-	const addChild = (input: { agent?: string; runId?: string; usage?: Usage; sessionFile?: string }): boolean => {
+	const addChild = (input: { agent?: string; runId?: string; identity?: string; usage?: Usage; sessionFile?: string }): boolean => {
 		if (!input.usage || !usageHasValue(input.usage)) return false;
-		const identity = input.runId ? `run:${input.runId}` : input.sessionFile ? `session:${input.sessionFile}` : undefined;
+		const identity = input.identity ?? (input.runId ? `run:${input.runId}` : input.sessionFile ? `session:${input.sessionFile}` : undefined);
 		if (identity && seenChildren.has(identity)) return true;
 		if (identity) seenChildren.add(identity);
 		const usage = { ...input.usage };
@@ -183,13 +187,16 @@ export function collectSubagentCost(
 		if (parentUsage) addUsage(parent, parentUsage);
 		const details = detailsFromSessionEntry(entry);
 		if (!details) continue;
-		if (details.mode === "workflow" && details.runId) workflowRunIds.add(details.runId);
+		// Only async workflows persist a receipt file; foreground workflow child usage is already in results.
+		if (details.mode === "workflow" && details.runId && details.asyncId) workflowRunIds.add(details.runId);
+		// An async launch result has no child results; its usage lands in run artifacts.
+		else if (details.asyncId && details.results.length === 0) asyncRunIds.add(details.asyncId);
 		for (const result of details.results) {
-			const resultRunId = (result as SingleResult & { runId?: unknown }).runId;
-			addChild({ agent: result.agent, runId: typeof resultRunId === "string" ? resultRunId : undefined, usage: usageFromValue(result.usage), sessionFile: result.sessionFile });
+			addChild({ agent: result.agent, runId: typeof result.runId === "string" ? result.runId : undefined, usage: usageFromValue(result.usage), sessionFile: result.sessionFile });
 		}
 		for (const completion of details.completions ?? []) {
 			if (completion.mode === "workflow") workflowRunIds.add(completion.runId);
+			completedRunIds.add(completion.runId);
 			for (const result of completion.results ?? []) {
 				addChild({ agent: result.agent, runId: result.runId, usage: usageFromValue(result.usage), sessionFile: result.sessionFile });
 			}
@@ -241,7 +248,37 @@ export function collectSubagentCost(
 				if (!usage || !addChild({ ...ref, usage })) unresolvedAsyncChildren += 1;
 			}
 		} catch (error) {
-			if ((error as NodeJS.ErrnoException).code !== "ENOENT") console.error(`Failed to resolve async subagent usage for '${workflowRunId}':`, error);
+			// Without a receipt, a bg_wait completion cannot prove it reported every child (a stopped workflow may omit one).
+			unresolvedAsyncChildren += 1;
+			// A running workflow has no receipt yet; readWorkflowReceipt keeps the ENOENT as its cause.
+			const missing = (error as NodeJS.ErrnoException).code === "ENOENT" || ((error as Error).cause as NodeJS.ErrnoException | undefined)?.code === "ENOENT";
+			if (!missing) console.error(`Failed to resolve async subagent usage for '${workflowRunId}':`, error);
+		}
+	}
+
+	for (const asyncRunId of asyncRunIds) {
+		// A bg_wait completion already reported this run's results; its children carry no child runId.
+		if (completedRunIds.has(asyncRunId)) continue;
+		try {
+			const status = readStatus(path.join(DIRS.async, asyncRunId));
+			if (!status?.steps?.length) {
+				unresolvedAsyncChildren += 1;
+				continue;
+			}
+			addArtifactsDir(status.cwd);
+			const steps = status.steps;
+			// The runner suffixes artifact names with the flat step index only for multi-step runs.
+			steps.forEach((step, index) => {
+				const flatIndex = steps.length > 1 ? index : undefined;
+				const usage = metadataUsage([...artifactsDirs], { runId: asyncRunId, agent: step.agent }, flatIndex === undefined ? [undefined, 0] : [flatIndex]);
+				const identity = flatIndex === undefined ? `run:${asyncRunId}` : `run:${asyncRunId}:${flatIndex}`;
+				// Pending and running steps have not finalized their metadata yet.
+				const settled = step.status !== "pending" && step.status !== "running";
+				if (!addChild({ agent: step.agent, runId: asyncRunId, identity, usage }) && settled) unresolvedAsyncChildren += 1;
+			});
+		} catch (error) {
+			unresolvedAsyncChildren += 1;
+			if ((error as NodeJS.ErrnoException).code !== "ENOENT") console.error(`Failed to resolve async subagent usage for '${asyncRunId}':`, error);
 		}
 	}
 

package/dist/extensions/pi-subagents/src/slash/subagents-admin.ts

@@ -11,6 +11,7 @@ import {
 	type BuiltinAgentOverrideBase,
 } from "../agents/agents.ts";
 import { serializeAgent } from "../agents/agent-serializer.ts";
+import { mergeRuntimeAgents, type RuntimeAgentOwner } from "../agents/runtime-agent-registry.ts";
 import { editableAgentConfig, preservedAgentFrontmatterFields } from "../agents/agent-management.ts";
 import { findModelInfo, getSupportedThinkingLevels, toModelInfo } from "../shared/model-info.ts";
 import { SelectorComponent, type SelectorItem, type SelectorResult } from "./selector.ts";
@@ -28,11 +29,13 @@ function sourceRank(source: AgentConfig["source"]): number {
 	return 3;
 }
 
-function allVisibleAgents(cwd: string): AgentConfig[] {
-	const d = discoverAgentsAll(cwd);
-	return [...d.project, ...d.user, ...d.package, ...d.builtin]
-		.filter((agent) => !agent.disabled)
-		.sort((a, b) => a.name.localeCompare(b.name) || sourceRank(a.source) - sourceRank(b.source));
+function allVisibleAgents(pi: RuntimeAgentOwner, cwd: string, preferredModelProvider?: string): AgentConfig[] {
+	const d = discoverAgentsAll(cwd, preferredModelProvider);
+	const allConfigured = [...d.project, ...d.user, ...d.package, ...d.builtin];
+	const visibleConfigured = allConfigured.filter((agent) => !agent.disabled);
+	// Disabled definitions remain in collision checks even though the panel hides them.
+	const agents = mergeRuntimeAgents(pi, { agents: visibleConfigured }, allConfigured, { cwd, scope: "both", preferredModelProvider }).agents;
+	return agents.sort((a, b) => a.name.localeCompare(b.name) || sourceRank(a.source) - sourceRank(b.source));
 }
 
 function agentLabel(agent: AgentConfig): string {
@@ -71,9 +74,19 @@ function modelFullId(model: ModelInfo): string {
 	return `${model.provider}/${model.id}`;
 }
 
-function liveAvailableModels(ctx: ExtensionContext) {
+async function liveAvailableModels(ctx: ExtensionContext) {
 	try {
-		ctx.modelRegistry.refresh?.();
+		// Reload local configuration and cached catalogs without network discovery on picker open.
+		// Selesai: the host ModelRegistry.refresh() may still return void; accept both shapes.
+		type RefreshResult = { errors: Map<string, Error>; aborted?: boolean } | void;
+		const refresh = ctx.modelRegistry.refresh as unknown as ((options?: { allowNetwork?: boolean; signal?: AbortSignal }) => Promise<RefreshResult>) | undefined;
+		const result = (await refresh?.call(ctx.modelRegistry, { allowNetwork: false, signal: AbortSignal.timeout(5_000) })) || undefined;
+		const firstError = result?.errors.entries().next().value;
+		if (firstError) {
+			ctx.ui.notify(`Could not refresh ${firstError[0]}; using the currently loaded choices. ${firstError[1].message}`, "warning");
+		} else if (result?.aborted) {
+			ctx.ui.notify("Model registry refresh timed out; using the currently loaded choices.", "warning");
+		}
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
 		ctx.ui.notify(`Could not refresh the model registry; using the last loaded choices. ${message}`, "warning");
@@ -84,7 +97,6 @@ function liveAvailableModels(ctx: ExtensionContext) {
 function buildBuiltinBase(agent: AgentConfig): BuiltinAgentOverrideBase {
 	return {
 		...(agent.model !== undefined ? { model: agent.model } : {}),
-		...(agent.fallbackModels !== undefined ? { fallbackModels: [...agent.fallbackModels] } : {}),
 		...(agent.thinking !== undefined ? { thinking: agent.thinking } : {}),
 		systemPromptMode: agent.systemPromptMode,
 		inheritProjectContext: agent.inheritProjectContext,
@@ -100,7 +112,6 @@ function buildBuiltinBase(agent: AgentConfig): BuiltinAgentOverrideBase {
 		...(agent.mcpDirectTools !== undefined ? { mcpDirectTools: [...agent.mcpDirectTools] } : {}),
 		...(agent.subagentOnlyExtensions !== undefined ? { subagentOnlyExtensions: [...agent.subagentOnlyExtensions] } : {}),
 		...(agent.mutationTools !== undefined ? { mutationTools: [...agent.mutationTools] } : {}),
-		...(agent.completionGuard !== undefined ? { completionGuard: agent.completionGuard } : {}),
 		...(agent.toolBudget !== undefined ? { toolBudget: agent.toolBudget } : {}),
 	};
 }
@@ -139,6 +150,9 @@ function isReadOnlyExtraAgent(agent: AgentConfig): boolean {
 }
 
 function readOnlyAgentMessage(agent: AgentConfig, field: EditableOverrideField): string | undefined {
+	if (agent.source === "runtime") {
+		return `Cannot update '${agent.name}' ${field} because that agent is runtime-registered by an extension; edit its source definition instead.`;
+	}
 	if (agent.source === "package") {
 		return `Cannot update '${agent.name}' ${field} because that field is owned by its read-only package definition.`;
 	}
@@ -147,8 +161,8 @@ function readOnlyAgentMessage(agent: AgentConfig, field: EditableOverrideField):
 		: undefined;
 }
 
-async function selectAgent(ctx: ExtensionContext, args: string): Promise<AgentSelection> {
-	const agents = allVisibleAgents(ctx.cwd);
+async function selectAgent(pi: RuntimeAgentOwner, ctx: ExtensionContext, args: string): Promise<AgentSelection> {
+	const agents = allVisibleAgents(pi, ctx.cwd, ctx.model?.provider);
 	const requestedName = args.trim().split(/\s+/)[0] ?? "";
 	if (agents.length === 0) return { kind: "not-found", agents, requestedName: requestedName || undefined };
 
@@ -182,7 +196,6 @@ function metadataFor(agent: AgentConfig): string {
 		lines.push(`Package: ${agent.packageName}`);
 	}
 	lines.push(`Model: ${agent.model ?? "default / inherit"}`);
-	if (agent.fallbackModels?.length) lines.push(`Fallback models: ${agent.fallbackModels.join(", ")}`);
 	if (agent.thinking !== undefined) lines.push(`Thinking: ${agent.thinking === false ? "off" : agent.thinking}`);
 	if (tools.length) lines.push(`Tools: ${tools.join(", ")}`);
 	if (agent.excludeTools?.length) lines.push(`Excluded tools: ${agent.excludeTools.join(", ")}`);
@@ -217,7 +230,7 @@ async function selectFromList(ctx: ExtensionContext, title: string, subtitle: st
 }
 
 async function chooseModel(ctx: ExtensionContext, agent: AgentConfig): Promise<string | undefined | null> {
-	const models = liveAvailableModels(ctx);
+	const models = await liveAvailableModels(ctx);
 	const current = agent.model ?? INHERIT_MODEL_CHOICE;
 	const items: SelectorItem[] = [{ value: INHERIT_MODEL_CHOICE, label: INHERIT_MODEL_CHOICE, current: !agent.model }];
 	if (agent.model && !models.some((model) => modelFullId(model) === agent.model)) {
@@ -233,7 +246,7 @@ async function chooseModel(ctx: ExtensionContext, agent: AgentConfig): Promise<s
 }
 
 async function chooseThinking(ctx: ExtensionContext, agent: AgentConfig): Promise<string | undefined | null> {
-	const availableModels = liveAvailableModels(ctx).map(toModelInfo);
+	const availableModels = (await liveAvailableModels(ctx)).map(toModelInfo);
 	const effectiveModel = agent.model ?? (ctx.model ? modelFullId(ctx.model) : undefined);
 	const modelInfo = findModelInfo(effectiveModel, availableModels, ctx.model?.provider);
 	const levels = getSupportedThinkingLevels(modelInfo);
@@ -383,7 +396,7 @@ async function editSystemPrompt(ctx: ExtensionContext, agent: AgentConfig): Prom
 }
 
 export async function openSubagentsAdmin(pi: ExtensionAPI, ctx: ExtensionContext, args = ""): Promise<void> {
-	const selection = await selectAgent(ctx, args);
+	const selection = await selectAgent(pi, ctx, args);
 	if (selection.kind === "cancelled") return;
 	if (selection.kind === "ambiguous") {
 		sendAdminMessage(pi, `Subagent '${selection.requestedName}' is ambiguous. Choose a scope in interactive mode:\n${selection.matches.map((agent) => `- ${agent.source}: ${agent.filePath}`).join("\n")}`);
@@ -446,4 +459,4 @@ export async function openSubagentsAdmin(pi: ExtensionAPI, ctx: ExtensionContext
 		ctx.ui.notify(message, "error");
 		sendAdminMessage(pi, `Failed to update '${agent.name}': ${message}`);
 	}
-}
+}