@xopcai/xopc 0.0.82 → 0.0.83

package/dist/src/agent/agent-manager.js

@@ -1,25 +1,22 @@
+import { createLogger } from "../utils/logger/index.js";
+import { init_logger } from "../utils/logger.js";
 import { resolveStateDir } from "../config/paths-state.js";
 import { expandWorkspacePathString, init_workspace_path } from "../config/workspace-path.js";
 import { init_agent_scope, resolveAgentProfileDir } from "./agent-scope.js";
+import { init_paths, resolveBundledSkillsDir } from "../config/paths.js";
+import { CredentialResolver, init_credentials } from "../auth/credentials.js";
 import { getAgentDefaultModelRef, init_schema } from "../config/schema.js";
+import { init_sync_provider_auth, resolveProviderApiKeySync } from "../auth/sync-provider-auth.js";
 import { applyConfigOverrides } from "../config/runtime-overrides.js";
 import { resolveEffectiveAgentProfileForSession } from "../config/agent-profile.js";
-import { createLogger } from "../utils/logger/index.js";
-import { init_logger } from "../utils/logger.js";
-import { init_paths, resolveBundledSkillsDir } from "../config/paths.js";
-import { init_sync_provider_auth, resolveProviderApiKeySync } from "../auth/sync-provider-auth.js";
-import { CredentialResolver, init_credentials } from "../auth/credentials.js";
 import { getApiKeySync, getDefaultModelSync, init_providers, resolveModel } from "../providers/index.js";
 import { createExtensionAwareStreamFn } from "../providers/extension-stream-bridge.js";
 import { extractTextContent, loadProfileMarkdownFiles } from "./context/workspace.js";
 import { resolveBootstrapContextSync } from "./bootstrap/bootstrap-files.js";
 import { createSkillConfigManager } from "./skills/config.js";
 import { isValidSkillEnvVarName } from "./skills/required-env-vars.js";
-import { SkillManager } from "./skills/skill-manager.js";
-import "./skills/index.js";
-import { SystemPromptBuilder } from "./prompt/service-prompt-builder.js";
 import { resolveLocalizedSkillMarkdown, resolveLocalizedSkillMeta } from "./skills/skill-view-path.js";
-import { isMemorySubsystemEnabled, resolveBuiltinMemoryStoreConfig, shouldInjectMemoryPrefetchThisTurn, shouldRegisterCuratedMemoryTool } from "./memory/memory-config.js";
+import { isMemorySubsystemEnabled, shouldRegisterCuratedMemoryTool } from "./memory/memory-config.js";
 import { AgentToolsFactory } from "./tools/factory.js";
 import { parseMcpToolName } from "./mcp/bundle-mcp-policy.js";
 import { disposeAllSessionMcpRuntimes, retireSessionMcpRuntimeForSessionKey } from "./mcp/bundle-mcp-runtime.js";
@@ -27,15 +24,11 @@ import "./mcp/bundle-mcp-tools.js";
 import { evictAllEmbeddedSessionRunners, evictEmbeddedSessionRunner } from "./embedded/session-runner.js";
 import { loadSkillsLock } from "./skills/hub-lock.js";
 import { isUnderManagedSkillsDir } from "./skills/managed-store.js";
-import { BuiltinMemoryStore } from "./memory/builtin-memory-store.js";
-import { createMemoryManagerFromConfig } from "./memory/create-memory-manager.js";
-import { injectPrefetchIntoUserMessage } from "./memory/inject-prefetch.js";
-import { extractAgentUserPlainText } from "./memory/user-message-text.js";
-import { resolveBackgroundReviewSettings } from "./background-review/settings.js";
-import { isAssistantTurnAborted, isAssistantTurnFailed } from "./orchestration/llm-turn-retry.js";
-import { runBackgroundReviewTurn } from "./background-review/run-background-review.js";
-import { Agent } from "@earendil-works/pi-agent-core";
+import { MemoryPrefetchCoordinator } from "./memory/prefetch-coordinator.js";
+import { WorkspaceRuntimeRegistry } from "./workspace-runtime/registry.js";
+import { BackgroundReviewCoordinator } from "./background-review/coordinator.js";
 import { basename, resolve, sep } from "node:path";
+import { Agent } from "@earendil-works/pi-agent-core";
 //#region src/agent/agent-manager.ts
 /**
 * Agent Manager - Manages Agent instances per session
@@ -67,52 +60,26 @@ var AgentManager = class {
 	defaultModel;
 	credentialCache = /* @__PURE__ */ new Map();
 	credentialResolver;
-	workspaceRuntimes = /* @__PURE__ */ new Map();
-	/** Per-session user-message index for prefetch injection cadence. */
-	memoryPrefetchUserTurn = /* @__PURE__ */ new Map();
+	workspaceRuntimes;
+	memoryPrefetch;
+	backgroundReview;
 	constructor(config) {
 		this.config = config;
 		this.baseWorkspacePath = this.computeBaseWorkspacePath();
-		const baseRt = this.getWorkspaceRuntime(this.baseWorkspacePath);
-		this.toolsFactory = new AgentToolsFactory({
-			workspace: this.baseWorkspacePath,
-			extensionRegistry: config.extensionRegistry,
-			getCurrentContext: config.getCurrentContext,
-			hookRunner: config.hookRunner,
-			bus: config.bus,
+		this.workspaceRuntimes = new WorkspaceRuntimeRegistry({
+			getConfig: () => this.config.config,
+			bundledSkillsDir: resolveBundledSkillsDir()
+		});
+		this.memoryPrefetch = new MemoryPrefetchCoordinator({
+			getConfig: () => this.config.config,
+			getMemoryManagerForSession: (sk) => this.getMemoryManagerForSession(sk),
+			getLastAssistantContent: (sk) => this.getLastAssistantContent(sk)
+		});
+		this.backgroundReview = new BackgroundReviewCoordinator({
 			getConfig: () => this.mergedConfig(),
-			getPrimaryModel: () => this.resolveModelStringToModel(this.pickDefaultModelRef()),
-			getBuiltinMemoryStore: () => baseRt.builtinMemoryStore,
-			getMemoryManager: () => baseRt.memoryManager,
-			getSessionStore: config.getSessionStore,
-			gatewayClarify: config.gatewayClarify,
-			getCronService: config.getCronService,
-			getSkillIndexingContext: () => {
-				const ctx = this.config.getCurrentContext?.();
-				if (!ctx?.sessionKey) return void 0;
-				const inst = this.agents.get(ctx.sessionKey);
-				if (!inst) return void 0;
-				return {
-					registeredToolNames: inst.registeredToolNames,
-					skillAllowlist: inst.effectiveProfile.skillsAllowlist
-				};
-			},
-			onSkillsFilesystemMutate: () => {
-				this.refreshSkillsAfterDiskChange();
-			},
-			getSkillPassthroughEnvVarNames: () => {
-				const ctx = this.config.getCurrentContext?.();
-				if (!ctx?.sessionKey) return [];
-				return [...this.agents.get(ctx.sessionKey)?.skillEnvPassthroughKeys ?? []];
-			},
-			registerSkillEnvPassthrough: (names) => {
-				const ctx = this.config.getCurrentContext?.();
-				if (!ctx?.sessionKey) return;
-				const inst = this.agents.get(ctx.sessionKey);
-				if (!inst) return;
-				for (const n of names) if (isValidSkillEnvVarName(n)) inst.skillEnvPassthroughKeys.add(n.trim());
-			}
+			onSkillsFilesystemMutate: () => this.refreshSkillsAfterDiskChange()
 		});
+		this.toolsFactory = new AgentToolsFactory(this.buildToolsFactoryDeps());
 		this.defaultModel = config.model || getDefaultModelSync(config.config);
 		this.credentialResolver = new CredentialResolver();
 		this.warmCredentialCache().catch((err) => {
@@ -152,25 +119,6 @@ var AgentManager = class {
 		if (!cfg) return;
 		return resolveEffectiveAgentProfileForSession(cfg, sessionKey).thinkingDefault;
 	}
-	getWorkspaceRuntime(resolvedPath) {
-		const existing = this.workspaceRuntimes.get(resolvedPath);
-		if (existing) return existing;
-		const builtinMemoryStore = new BuiltinMemoryStore(resolveBuiltinMemoryStoreConfig(resolvedPath, this.config.config));
-		const memoryManager = createMemoryManagerFromConfig(resolvedPath, builtinMemoryStore, this.config.config);
-		const skillManager = new SkillManager(resolvedPath, resolveBundledSkillsDir());
-		const rt = {
-			skillManager,
-			systemPromptBuilder: new SystemPromptBuilder({
-				workspace: resolvedPath,
-				config: this.config.config,
-				skillManager
-			}),
-			builtinMemoryStore,
-			memoryManager
-		};
-		this.workspaceRuntimes.set(resolvedPath, rt);
-		return rt;
-	}
 	pickDefaultModelRef() {
 		const cfg = this.mergedConfig();
 		return getAgentDefaultModelRef(cfg)?.trim() || getDefaultModelSync(cfg);
@@ -189,6 +137,13 @@ var AgentManager = class {
 	}
 	/**
 	* Keep defaults in sync when config is hot-reloaded or saved from the UI.
+	*
+	* The previous implementation rebuilt the entire `AgentToolsFactory` (80+ lines
+	* of dependency wiring) on every reload. The factory's deps are now built from
+	* a single helper ({@link buildToolsFactoryDeps}) and read `this.*` through
+	* closures, so existing instances automatically see the new config without
+	* reconstruction. The browser is still shut down because its cached settings
+	* (headless mode, backend choice) come from the config snapshot at connect time.
 	*/
 	updateAgentDefaults(config) {
 		this.config.config = config;
@@ -197,17 +152,23 @@ var AgentManager = class {
 		this.defaultModel = ref || getDefaultModelSync(config);
 		this.baseWorkspacePath = this.computeBaseWorkspacePath();
 		this.toolsFactory.shutdownBrowser();
-		for (const rt of this.workspaceRuntimes.values()) rt.memoryManager.shutdownAll().catch(() => {});
-		this.workspaceRuntimes.clear();
-		this.toolsFactory = new AgentToolsFactory({
+		this.workspaceRuntimes.clearAll();
+	}
+	/**
+	* Construct the dep bag passed to `AgentToolsFactory`. Closures reference
+	* `this.*` so they remain valid across hot reloads (no rebuild needed).
+	*/
+	buildToolsFactoryDeps() {
+		return {
 			workspace: this.baseWorkspacePath,
 			extensionRegistry: this.config.extensionRegistry,
 			getCurrentContext: this.config.getCurrentContext,
+			hookRunner: this.config.hookRunner,
 			bus: this.config.bus,
 			getConfig: () => this.mergedConfig(),
 			getPrimaryModel: () => this.resolveModelStringToModel(this.pickDefaultModelRef()),
-			getBuiltinMemoryStore: () => this.getWorkspaceRuntime(this.baseWorkspacePath).builtinMemoryStore,
-			getMemoryManager: () => this.getWorkspaceRuntime(this.baseWorkspacePath).memoryManager,
+			getBuiltinMemoryStore: () => this.workspaceRuntimes.getOrCreate(this.baseWorkspacePath).builtinMemoryStore,
+			getMemoryManager: () => this.workspaceRuntimes.getOrCreate(this.baseWorkspacePath).memoryManager,
 			getSessionStore: this.config.getSessionStore,
 			gatewayClarify: this.config.gatewayClarify,
 			getCronService: this.config.getCronService,
@@ -236,126 +197,69 @@ var AgentManager = class {
 				if (!inst) return;
 				for (const n of names) if (isValidSkillEnvVarName(n)) inst.skillEnvPassthroughKeys.add(n.trim());
 			}
-		});
+		};
 	}
 	getMemoryManager() {
-		return this.getWorkspaceRuntime(this.baseWorkspacePath).memoryManager;
+		return this.workspaceRuntimes.getOrCreate(this.baseWorkspacePath).memoryManager;
 	}
 	getMemoryManagerForSession(sessionKey) {
 		const path = this.getResolvedWorkspaceForSession(sessionKey);
-		return this.getWorkspaceRuntime(path).memoryManager;
+		return this.workspaceRuntimes.getOrCreate(path).memoryManager;
 	}
 	/**
 	* Prefix the user turn with fenced prefetched memory (external providers).
+	* Delegates to {@link MemoryPrefetchCoordinator}.
 	*/
-	async applyMemoryPrefetchToUserMessage(userMessage, sessionKey) {
-		if (!isMemorySubsystemEnabled(this.config.config)) return userMessage;
-		const plain = extractAgentUserPlainText(userMessage);
-		const turn = (this.memoryPrefetchUserTurn.get(sessionKey) ?? 0) + 1;
-		this.memoryPrefetchUserTurn.set(sessionKey, turn);
-		if (!shouldInjectMemoryPrefetchThisTurn(this.config.config, turn)) return userMessage;
-		return injectPrefetchIntoUserMessage(this.getMemoryManagerForSession(sessionKey), sessionKey, userMessage, plain);
+	applyMemoryPrefetchToUserMessage(userMessage, sessionKey) {
+		return this.memoryPrefetch.applyToUserMessage(userMessage, sessionKey);
 	}
 	/**
 	* After a completed turn: sync external providers and queue next-turn prefetch.
+	* Delegates to {@link MemoryPrefetchCoordinator}.
 	*/
 	afterAgentTurn(sessionKey, userPlainText) {
-		if (!isMemorySubsystemEnabled(this.config.config)) return;
-		const assistant = this.getLastAssistantContent(sessionKey) ?? "";
-		const mm = this.getMemoryManagerForSession(sessionKey);
-		mm.syncAll(userPlainText, assistant, { sessionId: sessionKey });
-		mm.queuePrefetchAll(userPlainText, { sessionId: sessionKey });
+		this.memoryPrefetch.afterTurn(sessionKey, userPlainText);
 	}
 	/**
 	* Call once per user turn before the main `agent.prompt` (via {@link runAgentTurnWithModelFallbacks} `beforeUserPrompt`).
+	* Delegates to {@link BackgroundReviewCoordinator}.
 	*/
 	beginBackgroundReviewUserTurn(sessionKey) {
 		const inst = this.agents.get(sessionKey);
-		if (!inst?.backgroundNudge) return;
-		const cfg = resolveBackgroundReviewSettings(this.config.config);
-		if (!cfg.enabled || cfg.memoryNudgeInterval <= 0) return;
-		if (!inst.registeredToolNames.includes("curated_memory")) return;
-		inst.backgroundNudge.turnsSinceMemory += 1;
-		if (inst.backgroundNudge.turnsSinceMemory >= cfg.memoryNudgeInterval) {
-			inst.backgroundNudge.pendingMemoryReview = true;
-			inst.backgroundNudge.turnsSinceMemory = 0;
-		}
+		if (!inst) return;
+		this.backgroundReview.beginUserTurn(sessionKey, inst.registeredToolNames);
 	}
 	/**
 	* After a successful main turn (after memory sync via `afterAgentTurn`), may run a quiet follow-up for memory/skills.
+	* Delegates to {@link BackgroundReviewCoordinator}.
 	*/
 	scheduleBackgroundReviewAfterUserTurn(sessionKey) {
-		this.runBackgroundReviewIfNeeded(sessionKey).catch((err) => {
-			log.warn({
-				err,
-				sessionKey
-			}, "Background review failed");
-		});
-	}
-	async runBackgroundReviewIfNeeded(sessionKey) {
 		const inst = this.agents.get(sessionKey);
-		if (!inst?.backgroundNudge) return;
-		const settings = resolveBackgroundReviewSettings(this.config.config);
-		if (!settings.enabled) return;
-		if (isAssistantTurnAborted(inst.agent) || isAssistantTurnFailed(inst.agent)) return;
-		if (!this.getLastAssistantContent(sessionKey)?.trim()) return;
-		const reviewMemory = inst.backgroundNudge.pendingMemoryReview;
-		inst.backgroundNudge.pendingMemoryReview = false;
-		let reviewSkills = false;
-		if (settings.skillNudgeInterval > 0 && inst.registeredToolNames.includes("skill_manage")) {
-			if (inst.backgroundNudge.itersSinceSkill >= settings.skillNudgeInterval) {
-				reviewSkills = true;
-				inst.backgroundNudge.itersSinceSkill = 0;
-			}
-		}
-		if (!reviewMemory && !reviewSkills) return;
-		const rt = this.getWorkspaceRuntime(inst.resolvedWorkspacePath);
-		await runBackgroundReviewTurn({
+		if (!inst) return;
+		this.backgroundReview.scheduleAfterUserTurn({
 			sessionKey,
-			mainAgent: inst.agent,
-			settings,
-			reviewMemory,
-			reviewSkills,
+			agent: inst.agent,
 			registeredToolNames: inst.registeredToolNames,
 			skillAllowlist: inst.effectiveProfile.skillsAllowlist,
 			workspacePath: inst.resolvedWorkspacePath,
-			skillManager: rt.skillManager,
-			builtinMemoryStore: rt.builtinMemoryStore,
-			memoryManager: rt.memoryManager,
-			getConfig: () => this.mergedConfig(),
-			onSkillsFilesystemMutate: () => this.refreshSkillsAfterDiskChange()
+			lastAssistantText: this.getLastAssistantContent(sessionKey),
+			workspaceRuntime: this.workspaceRuntimes.getOrCreate(inst.resolvedWorkspacePath)
 		});
 	}
-	attachBackgroundNudgeListeners(sessionKey) {
-		const inst = this.agents.get(sessionKey);
-		if (!inst?.backgroundNudge) return;
-		inst.backgroundNudge.unsubscribe?.();
-		const unsub = inst.agent.subscribe((ev) => {
-			const cfg = resolveBackgroundReviewSettings(this.config.config);
-			if (!cfg.enabled || cfg.skillNudgeInterval <= 0) return;
-			if (!inst.registeredToolNames.includes("skill_manage")) return;
-			if (ev.type === "turn_start") inst.backgroundNudge.itersSinceSkill += 1;
-			if (ev.type === "tool_execution_end") {
-				const te = ev;
-				if (!te.isError && typeof te.toolName === "string" && te.toolName.trim() === "skill_manage") inst.backgroundNudge.itersSinceSkill = 0;
-			}
-		});
-		inst.backgroundNudge.unsubscribe = unsub;
-	}
 	/**
 	* Expand `/skill:name` user text into the full skill block for the current turn (WebChat, channels).
 	*/
 	expandSkillUserText(text) {
 		const ctx = this.config.getCurrentContext?.();
 		const path = ctx?.sessionKey ? this.getResolvedWorkspaceForSession(ctx.sessionKey) : this.baseWorkspacePath;
-		return this.getWorkspaceRuntime(path).skillManager.expandCommand(text);
+		return this.workspaceRuntimes.getOrCreate(path).skillManager.expandCommand(text);
 	}
 	/**
 	* Structured SKILL.md preview for the gateway console.
 	* When `lang` is provided (e.g. "zh"), tries SKILL-{lang}.md first; falls back to SKILL.md.
 	*/
 	getSkillMarkdownSource(skillName, lang) {
-		const skill = this.getWorkspaceRuntime(this.baseWorkspacePath).skillManager.findSkill(skillName);
+		const skill = this.workspaceRuntimes.getOrCreate(this.baseWorkspacePath).skillManager.findSkill(skillName);
 		if (!skill) return null;
 		if (lang) {
 			const localized = resolveLocalizedSkillMarkdown(skill, lang);
@@ -390,7 +294,7 @@ var AgentManager = class {
 	getSkillCatalog(lang) {
 		const skillsConfig = createSkillConfigManager(resolveStateDir()).load();
 		const lock = loadSkillsLock();
-		return this.getWorkspaceRuntime(this.baseWorkspacePath).skillManager.getSkills().map((s) => {
+		return this.workspaceRuntimes.getOrCreate(this.baseWorkspacePath).skillManager.getSkills().map((s) => {
 			const base = resolve(s.baseDir);
 			const managed = isUnderManagedSkillsDir(s.baseDir);
 			const directoryId = base.split(sep).filter(Boolean).pop() || s.name;
@@ -419,7 +323,7 @@ var AgentManager = class {
 		const cfg = this.config.config;
 		const touched = /* @__PURE__ */ new Set();
 		for (const instance of this.agents.values()) {
-			const rt = this.getWorkspaceRuntime(instance.resolvedWorkspacePath);
+			const rt = this.workspaceRuntimes.getOrCreate(instance.resolvedWorkspacePath);
 			if (!touched.has(instance.resolvedWorkspacePath)) {
 				rt.skillManager.refreshPromptFromConfig();
 				touched.add(instance.resolvedWorkspacePath);
@@ -445,7 +349,7 @@ var AgentManager = class {
 		for (const rt of this.workspaceRuntimes.values()) rt.skillManager.reload();
 		const touched = /* @__PURE__ */ new Set();
 		for (const instance of this.agents.values()) {
-			const rt = this.getWorkspaceRuntime(instance.resolvedWorkspacePath);
+			const rt = this.workspaceRuntimes.getOrCreate(instance.resolvedWorkspacePath);
 			if (!touched.has(instance.resolvedWorkspacePath)) touched.add(instance.resolvedWorkspacePath);
 			const contextFiles = this.resolveContextFilesForSession(instance.sessionKey, instance.effectiveProfile);
 			const newPrompt = rt.systemPromptBuilder.rebuild(contextFiles, {
@@ -470,20 +374,12 @@ var AgentManager = class {
 		if (existing) if (existing.resolvedWorkspacePath !== targetPath) this.removeAgent(sessionKey);
 		else {
 			existing.lastUsedAt = Date.now();
-			if (!existing.backgroundNudge) {
-				existing.backgroundNudge = {
-					turnsSinceMemory: 0,
-					itersSinceSkill: 0,
-					pendingMemoryReview: false
-				};
-				this.attachBackgroundNudgeListeners(sessionKey);
-			}
 			log.debug({ sessionKey }, "Reusing existing agent instance");
 			return existing.agent;
 		}
 		const profile = resolveEffectiveAgentProfileForSession(cfg, sessionKey);
 		const resolvedPath = targetPath;
-		const rt = this.getWorkspaceRuntime(resolvedPath);
+		const rt = this.workspaceRuntimes.getOrCreate(resolvedPath);
 		if (isMemorySubsystemEnabled(cfg)) rt.memoryManager.initializeAll(sessionKey, { workspace: resolvedPath }).catch((err) => log.warn({
 			err,
 			sessionKey
@@ -498,14 +394,9 @@ var AgentManager = class {
 			effectiveProfile: profile,
 			resolvedWorkspacePath: resolvedPath,
 			registeredToolNames,
-			skillEnvPassthroughKeys: /* @__PURE__ */ new Set(),
-			backgroundNudge: {
-				turnsSinceMemory: 0,
-				itersSinceSkill: 0,
-				pendingMemoryReview: false
-			}
+			skillEnvPassthroughKeys: /* @__PURE__ */ new Set()
 		});
-		this.attachBackgroundNudgeListeners(sessionKey);
+		this.backgroundReview.attachToAgent(sessionKey, agent, registeredToolNames);
 		const modelRef = profile.primaryModelRef?.trim() || this.defaultModel;
 		this.config.getModelManager?.().setSessionProfileDefault(sessionKey, modelRef);
 		log.debug({
@@ -533,7 +424,7 @@ var AgentManager = class {
 	removeAgent(sessionKey) {
 		const instance = this.agents.get(sessionKey);
 		if (instance) {
-			instance.backgroundNudge?.unsubscribe?.();
+			this.backgroundReview.forgetSession(sessionKey);
 			this.toolsFactory.closeBrowserPageForSession(sessionKey);
 			retireSessionMcpRuntimeForSessionKey({
 				sessionKey,
@@ -542,7 +433,7 @@ var AgentManager = class {
 			instance.agent.abort();
 			evictEmbeddedSessionRunner(sessionKey, "agent_removed");
 			this.agents.delete(sessionKey);
-			this.memoryPrefetchUserTurn.delete(sessionKey);
+			this.memoryPrefetch.forgetSession(sessionKey);
 			this.config.getModelManager?.().clearSessionProfileDefault(sessionKey);
 			log.info({
 				sessionKey,
@@ -584,15 +475,12 @@ var AgentManager = class {
 		this.toolsFactory.shutdownBrowser();
 		disposeAllSessionMcpRuntimes().catch(() => {});
 		evictAllEmbeddedSessionRunners("agent_manager_dispose");
-		for (const instance of this.agents.values()) {
-			instance.backgroundNudge?.unsubscribe?.();
-			instance.agent.abort();
-		}
+		this.backgroundReview.clear();
+		for (const instance of this.agents.values()) instance.agent.abort();
 		this.agents.clear();
-		this.memoryPrefetchUserTurn.clear();
+		this.memoryPrefetch.clear();
 		this.sessionWorkspaceOverrides.clear();
-		for (const rt of this.workspaceRuntimes.values()) rt.memoryManager.shutdownAll().catch(() => {});
-		this.workspaceRuntimes.clear();
+		this.workspaceRuntimes.clearAll();
 		log.debug("All agent instances disposed");
 	}
 	async warmCredentialCache() {