@mastra/code-sdk 0.0.0-aggregate-trace-20261015182851

package/dist/index.js

@@ -0,0 +1,1305 @@
+import { DEFAULT_OM_MODEL_ID, validateConfigDirName } from "./constants.js";
+import { detectProject, getObservabilityDatabasePath, getResourceIdOverride, getStorageConfig } from "./utils/project.js";
+import { isKimiCodingDeviceId } from "./auth/providers/kimi-coding.js";
+import { AuthStorage } from "./auth/storage.js";
+import { setAuthStorage } from "./providers/openai-codex.js";
+import { getAvailableOmPacks, resolveAutoOMModelId } from "./onboarding/packs.js";
+import { MASTRA_GATEWAY_PROVIDER, OBSERVABILITY_AUTH_PREFIX, loadSettings, resolveOmRoleModel, saveSettings } from "./onboarding/settings.js";
+import { resolveExperimentalAgent, validateExperimentalAgent, wrapExperimentalAgent } from "./experimental-agent.js";
+import { createSessionThreadAdvertisement } from "./agent-connections/session-advertisement.js";
+import { AgentConnectionsSignalProvider } from "./agent-connections/signal-provider.js";
+import { createBackgroundCompletionEvents } from "./agents/background-completion-events.js";
+import { createBackgroundCompletionCallbacks } from "./agents/background-completion.js";
+import { hasCredentialStoreProvider, withCredentialTenantPreparation } from "./agents/credential-resolver.js";
+import { getDynamicWorkspace, getGoalJudgeTools } from "./agents/workspace.js";
+import { createGitRefReminderReader, instructionSourcePaths, loadSessionInstructions, sessionInstructionRoots } from "./agents/prompts/agent-instructions.js";
+import { getDynamicInstructions } from "./agents/instructions.js";
+import { LOCAL_KNOWLEDGE_ORG_ID } from "./knowledge-scope.js";
+import { createAmazonBedrockGateway } from "./providers/amazon-bedrock-gateway.js";
+import { setAuthStorage as setAuthStorage$1 } from "./providers/claude-max.js";
+import { setAuthStorage as setAuthStorage$2 } from "./providers/github-copilot.js";
+import { setAuthStorage as setAuthStorage$3 } from "./providers/kimi-coding.js";
+import { setAuthStorage as setAuthStorage$4 } from "./providers/xai.js";
+import { createMastraCodeGateway, getDynamicModel, getGoalJudgeModel, resolveModel } from "./agents/model.js";
+import { getDynamicMemory, hasSubconsciousTools } from "./agents/memory.js";
+import { buildMode } from "./agents/modes/build.js";
+import { fastMode } from "./agents/modes/explore.js";
+import { createPlanMode } from "./agents/modes/plan.js";
+import { executeSubagent } from "./agents/subagents/execute.js";
+import { exploreSubagent } from "./agents/subagents/explore.js";
+import { planSubagent } from "./agents/subagents/plan.js";
+import { attachOMThreadStatePersistence, restoreOMThreadStateForCurrentThread } from "./agents/thread-caveman-state.js";
+import { createDynamicTools, createToolHooks } from "./agents/tools.js";
+import { AccountRotationProcessor, AccountStartNoticeProcessor, MODEL_FALLBACK_STATE_KEY } from "./auth/account-rotation-processor.js";
+import { createOutcomeScorer } from "./evals/scorers/outcome.js";
+import { createEfficiencyScorer } from "./evals/scorers/efficiency.js";
+import "./evals/scorers/index.js";
+import { HookManager } from "./hooks/manager.js";
+import "./hooks/index.js";
+import { KnowledgeInspectorError, createKnowledgeInspector } from "./knowledge-inspector.js";
+import { createMcpManager } from "./mcp/manager.js";
+import "./mcp/index.js";
+import { getToolCategory } from "./permissions.js";
+import { PluginManager } from "./plugins/manager.js";
+import { PluginSignalLane } from "./plugins/signal-lane.js";
+import { PlanRejectionAbortProcessor } from "./processors/plan-rejection-abort.js";
+import { createGitHubCopilotGateway } from "./providers/github-copilot-gateway.js";
+import { assembleSchedulePrompt } from "./schedules/prompt.js";
+import { ThreadScheduler, scheduleSignalAttributes, shortScheduleId } from "./schedules/scheduler.js";
+import { runScript } from "./schedules/run-script.js";
+import { createScheduleTools } from "./schedules/tools.js";
+import "./schedules/index.js";
+import { stateSchema } from "./schema.js";
+import { mastraBrand } from "./theme-palette.js";
+import { DiscardingScoresStorage } from "./utils/discarding-scores-storage.js";
+import { syncGateways } from "./utils/gateway-sync.js";
+import { registerSessionAndWaitForMaintenance, unregisterSession } from "./utils/maintenance-lock.js";
+import { createSignalsPubSub } from "./utils/signals-pubsub.js";
+import { createResourceNotificationDispatcher, shouldHoldNotificationDelivery } from "./utils/notification-dispatch.js";
+import { DEFAULT_RETENTION, createStorageMaintenance, resolveLocalDbFiles } from "./utils/storage-maintenance.js";
+import { createStorage, createVectorStore } from "./utils/storage-factory.js";
+import { acquireThreadLock, releaseThreadLock } from "./utils/thread-lock.js";
+import { registerWorkflowBuilderPrimitives } from "./workflows/register-primitives.js";
+import { autoApprovePolicy, denyPolicy, permissionModeToPolicy } from "./headless/policy.js";
+import { runMC } from "./headless/run-mc.js";
+import { formatHuman, formatJsonl, renderJsonResult, renderTextResult } from "./headless/format.js";
+import { hasHeadlessFlag, runMCCli } from "./headless/cli.js";
+import "./headless/index.js";
+import path from "path";
+import { createHash, randomUUID } from "crypto";
+import { statSync } from "fs";
+import { homedir, hostname } from "os";
+import { PROVIDER_REGISTRY, findGatewayForModel, getGatewayId } from "@mastra/core/llm";
+import { readFile } from "fs/promises";
+import { AgentController, migratePersistedModelSelection } from "@mastra/core/agent-controller";
+import { createCodingAgent } from "@mastra/core/coding-agent";
+import { Knowledge } from "@mastra/core/knowledge";
+import { Mastra } from "@mastra/core/mastra";
+import { defaultNotificationDeliveryDecision } from "@mastra/core/notifications";
+import { AgentsMDInjector, CyberRefusalHandler, ProviderHistoryCompat, StreamErrorRetryProcessor, createBackgroundWorkSignalProcessor, isBadRequestError } from "@mastra/core/processors";
+import { RequestContext } from "@mastra/core/request-context";
+import { TaskSignalProvider } from "@mastra/core/signals";
+import { MastraCompositeStore } from "@mastra/core/storage";
+import { DEFAULT_GOAL_JUDGE_PROMPT } from "@mastra/core/tools";
+import { DuckDBStore } from "@mastra/duckdb";
+import { GithubSignals } from "@mastra/github-signals";
+import { LibSQLStore, LibSQLVector } from "@mastra/libsql";
+import { MastraPlatformExporter, MastraStorageExporter, Observability, SensitiveDataFilter } from "@mastra/observability";
+import { PostgresStore } from "@mastra/pg";
+//#region src/index.ts
+const CODE_AGENT_ID = "code-agent";
+const MASTRACODE_TRANSIENT_CONNECTION_MAX_RETRIES = 10;
+const MASTRACODE_MAX_PROCESSOR_RETRIES = 64;
+const MASTRACODE_TRANSIENT_CONNECTION_RETRY_INITIAL_DELAY_MS = 500;
+const MASTRACODE_TRANSIENT_CONNECTION_RETRY_MAX_DELAY_MS = 3e4;
+const TRANSIENT_CONNECTION_ERROR_CODES = /* @__PURE__ */ new Set(["ECONNRESET", "EPIPE"]);
+const TRANSIENT_CONNECTION_MESSAGE_PATTERN = /econnreset|socket hang up|write epipe|other side closed/i;
+const isTransientServerStatus = (status) => status >= 500 && status < 600;
+const TRANSIENT_SERVER_ERROR_MESSAGE_PATTERN = /internal server|server error|api may be experiencing issues/i;
+/**
+* Matcher for transient connection failures. Cause-chain traversal is handled
+* by `StreamErrorRetryProcessor.isRetryableStreamError`, which calls each
+* matcher at every level of the cause chain.
+*/
+/**
+* Read the session state fields the AgentsMDInjector callbacks need from the
+* controller request context (set by hosts like the factory review flow).
+*/
+function getInjectorSessionState(requestContext) {
+	return (requestContext?.get("controller"))?.getState();
+}
+function isTransientConnectionError(error) {
+	if (!error) return false;
+	const code = typeof error === "object" && "code" in error ? error.code : void 0;
+	if (typeof code === "string" && TRANSIENT_CONNECTION_ERROR_CODES.has(code.toUpperCase())) return true;
+	const message = error instanceof Error ? error.message : void 0;
+	if (typeof message === "string" && TRANSIENT_CONNECTION_MESSAGE_PATTERN.test(message)) return true;
+	return false;
+}
+function isTransientServerError(error) {
+	if (!error) return false;
+	const errorObj = typeof error === "object" ? error : void 0;
+	if (typeof errorObj?.status === "number" && isTransientServerStatus(errorObj.status) || typeof errorObj?.statusCode === "number" && isTransientServerStatus(errorObj.statusCode)) return true;
+	const message = error instanceof Error ? error.message : void 0;
+	return typeof message === "string" && TRANSIENT_SERVER_ERROR_MESSAGE_PATTERN.test(message);
+}
+function getTransientRetryDelay(retryCount) {
+	return Math.min(MASTRACODE_TRANSIENT_CONNECTION_RETRY_INITIAL_DELAY_MS * Math.pow(2, retryCount), MASTRACODE_TRANSIENT_CONNECTION_RETRY_MAX_DELAY_MS);
+}
+function emitTransientRetry(error, retryCount, delayMs, requestContext) {
+	(requestContext?.get("controller"))?.emitEvent?.({
+		type: "error",
+		error: error instanceof Error ? error : new Error(String(error)),
+		retryable: true,
+		retryDelay: delayMs,
+		retryAttempt: retryCount + 1,
+		maxRetries: MASTRACODE_TRANSIENT_CONNECTION_MAX_RETRIES
+	});
+}
+/** Short deterministic hash (sha256, first 12 hex chars) matching project.ts shortHash style. */
+function shortHash(input) {
+	return createHash("sha256").update(input).digest("hex").slice(0, 12);
+}
+function applyModeDefaultsToModes(modes, modeDefaults) {
+	return modes.map((mode) => {
+		const savedModel = modeDefaults[mode.id];
+		if (!savedModel) return mode;
+		return {
+			...mode,
+			defaultModelId: savedModel
+		};
+	});
+}
+function addPluginToolsToModeAllowlists(modes, pluginToolNames) {
+	if (pluginToolNames.length === 0) return modes;
+	return modes.map((mode) => {
+		if (!mode.availableTools) return mode;
+		return {
+			...mode,
+			availableTools: Array.from(/* @__PURE__ */ new Set([...mode.availableTools, ...pluginToolNames]))
+		};
+	});
+}
+function createAuthStorage() {
+	const authStorage = new AuthStorage();
+	setAuthStorage$1(authStorage);
+	setAuthStorage(authStorage);
+	setAuthStorage$2(authStorage);
+	setAuthStorage$3(authStorage);
+	setAuthStorage$4(authStorage);
+	return authStorage;
+}
+/**
+* Resolve cloud observability credentials for the MastraPlatformExporter.
+* Priority: per-resource settings > MASTRACODE_* environment variables > undefined (no exporter).
+*
+* The env vars are deliberately namespaced `MASTRACODE_*`, not `MASTRA_*`: the
+* cwd `.env` is loaded into `process.env`, so reading `MASTRA_PROJECT_ID` /
+* `MASTRA_CLOUD_ACCESS_TOKEN` would export Mastra Code's own traces into
+* whatever Mastra project the user happens to be working in (and crash on
+* project ids the exporter rejects).
+*/
+function resolveCloudObservabilityConfig(settings, authStorage, resourceId, env = process.env) {
+	const resourceConfig = settings.observability.resources[resourceId];
+	if (resourceConfig) {
+		const token = authStorage.getStoredApiKey(`${OBSERVABILITY_AUTH_PREFIX}${resourceId}`);
+		if (token) return {
+			accessToken: token,
+			projectId: resourceConfig.projectId
+		};
+	}
+	const accessToken = env.MASTRACODE_CLOUD_ACCESS_TOKEN?.trim();
+	if (!accessToken) return void 0;
+	return {
+		accessToken,
+		projectId: env.MASTRACODE_PROJECT_ID?.trim() || void 0
+	};
+}
+/**
+* Base factory: builds every shared MastraCode resource (storage, observability,
+* memory, MCP, providers, gateways, agent, modes) and the {@link AgentController}, but
+* does NOT call `init()` or create a session. The controller is returned inert so
+* the composition layer can decide its Mastra ownership and session model.
+*
+* See {@link bootLocalAgentController} (Case 3) and `mountAgentControllerOnMastra` (Cases 1 & 2).
+*/
+/**
+* `instanceof` checks against Mastra classes are unreliable here: published
+* packages pin exact `@mastra/core` versions, so a user's dependency graph can
+* contain multiple copies of core (and peer-keyed copies of `@mastra/libsql` /
+* `@mastra/pg`). A store built against one copy fails `instanceof` against
+* another — the injected instance then silently fell through to the
+* StorageConfig path and crashed on `config.url`. These structural checks work
+* across duplicated copies.
+*/
+function isInjectedStorageInstance(storage) {
+	if (!storage) return false;
+	if (storage instanceof MastraCompositeStore) return true;
+	const candidate = storage;
+	return typeof candidate.init === "function" && typeof candidate.__registerMastra === "function";
+}
+/** Cross-copy-safe class check: walks the prototype chain by constructor name. */
+function hasAncestorClassNamed(value, className) {
+	for (let proto = Object.getPrototypeOf(value); proto; proto = Object.getPrototypeOf(proto)) if (proto.constructor?.name === className) return true;
+	return false;
+}
+function resolveInjectedStorageBackend(storage, configuredBackend) {
+	if (configuredBackend) return configuredBackend;
+	if (storage instanceof LibSQLStore || hasAncestorClassNamed(storage, "LibSQLStore")) return "libsql";
+	if (storage instanceof PostgresStore || hasAncestorClassNamed(storage, "PostgresStore")) return "pg";
+	throw new Error("storageBackend is required when injecting a custom storage instance.");
+}
+/** Whether the model router would resolve `modelId` through a gateway outside `sdkGatewayIds`. */
+function routesToOtherGateway(modelId, gateways, sdkGatewayIds) {
+	try {
+		return !sdkGatewayIds.has(getGatewayId(findGatewayForModel(modelId, gateways)));
+	} catch (error) {
+		if (error?.id === "MODEL_ROUTER_NO_GATEWAY_FOUND") return false;
+		throw error;
+	}
+}
+async function createMastraCodeAgentController(config) {
+	const cwd = config?.cwd ?? process.cwd();
+	const homeDir = config?.homeDir ?? config?.initialState?.homeDir;
+	const configDir = config?.configDir ?? ".mastracode";
+	const modeless = config?.modes === false;
+	let activeSession;
+	const liveSessions = /* @__PURE__ */ new Set();
+	let pluginRuntimeController;
+	if (configDir !== ".mastracode") validateConfigDirName(configDir);
+	if (!config?.disableEnvFile) try {
+		process.loadEnvFile(path.join(cwd, ".env"));
+	} catch {}
+	const authStorage = createAuthStorage();
+	const globalSettings = loadSettings(config?.settingsPath);
+	const experimentalAgent = resolveExperimentalAgent(globalSettings);
+	const backgroundToolsEnabled = globalSettings.backgroundTools?.enabled ?? false;
+	const storedGatewayKey = authStorage.getStoredApiKey(MASTRA_GATEWAY_PROVIDER);
+	const storedGatewayUrl = globalSettings.memoryGateway?.baseUrl;
+	if (storedGatewayKey) process.env["MASTRA_GATEWAY_API_KEY"] ??= storedGatewayKey;
+	if (storedGatewayUrl) process.env["MASTRA_GATEWAY_URL"] ??= storedGatewayUrl;
+	if (!hasCredentialStoreProvider()) try {
+		const registry = PROVIDER_REGISTRY;
+		const providerEnvVars = {};
+		for (const [provider, cfg] of Object.entries(registry)) {
+			const envVars = cfg?.apiKeyEnvVar;
+			providerEnvVars[provider] = Array.isArray(envVars) ? envVars[0] : envVars;
+		}
+		providerEnvVars[MASTRA_GATEWAY_PROVIDER] ??= "MASTRA_GATEWAY_API_KEY";
+		authStorage.loadStoredApiKeysIntoEnv(providerEnvVars);
+	} catch {
+		authStorage.loadStoredApiKeysIntoEnv({
+			[MASTRA_GATEWAY_PROVIDER]: "MASTRA_GATEWAY_API_KEY",
+			anthropic: "ANTHROPIC_API_KEY",
+			openai: "OPENAI_API_KEY",
+			google: "GOOGLE_GENERATIVE_AI_API_KEY",
+			cerebras: "CEREBRAS_API_KEY",
+			deepseek: "DEEPSEEK_API_KEY"
+		});
+	}
+	const mgApiKey = process.env["MASTRA_GATEWAY_API_KEY"] ?? storedGatewayKey;
+	const mastraCodeGateway = createMastraCodeGateway({
+		mastraGatewayBaseUrl: (process.env["MASTRA_GATEWAY_URL"] ?? storedGatewayUrl ?? "https://gateway-api.mastra.ai").replace(/\/+$/, "").replace(/\/v1$/, ""),
+		mastraGatewayApiKey: mgApiKey,
+		routeThroughMastraGateway: false,
+		settingsPath: config?.settingsPath
+	});
+	const amazonBedrockGateway = createAmazonBedrockGateway();
+	const githubCopilotGateway = createGitHubCopilotGateway();
+	const project = detectProject(cwd);
+	const resourceIdOverride = getResourceIdOverride(project.rootPath, configDir);
+	if (resourceIdOverride) {
+		project.resourceId = resourceIdOverride;
+		project.resourceIdOverride = true;
+	}
+	const cloudObservabilityConfig = resolveCloudObservabilityConfig(globalSettings, authStorage, project.resourceId);
+	const sessionId = `mastracode-session-${shortHash(project.resourceId)}`;
+	const ownerId = `mastracode-${shortHash(`${hostname()}\0${project.rootPath}`)}`;
+	const useCrossAgentSignals = config?.crossAgentSignals ?? globalSettings.signals?.experimentalCrossAgentSignals ?? false;
+	const configuredPubSub = config?.pubsub;
+	const useUnixSocketPubSub = (config?.unixSocketPubSub ?? globalSettings.signals?.unixSocketPubSub ?? false) && process.platform !== "win32";
+	const ownSignalsPubSub = !configuredPubSub && useUnixSocketPubSub ? createSignalsPubSub(project.resourceId, { sharedAgentDiscovery: useCrossAgentSignals }) : void 0;
+	const signalsPubSub = configuredPubSub ?? ownSignalsPubSub;
+	const crossProcessPubSub = config?.crossProcessPubSub ?? Boolean(ownSignalsPubSub);
+	if (crossProcessPubSub && !signalsPubSub) throw new Error("crossProcessPubSub requires a pubsub instance");
+	const useScheduleTools = config?.scheduleTools ?? globalSettings.signals?.experimentalScheduleTools ?? false;
+	const injectedStorage = isInjectedStorageInstance(config?.storage) ? config.storage : void 0;
+	const storageConfig = injectedStorage ? void 0 : config?.storage ?? getStorageConfig(project.rootPath, globalSettings.storage, configDir);
+	if (!injectedStorage) await registerSessionAndWaitForMaintenance({ onWait: (pid) => console.error(`Waiting for storage maintenance (mastracode prune${pid === -1 ? "" : `, PID ${pid}`}) to finish. Press Ctrl+C to give up.`) });
+	let storageResult;
+	if (injectedStorage) storageResult = {
+		storage: injectedStorage,
+		backend: resolveInjectedStorageBackend(injectedStorage, config?.storageBackend)
+	};
+	else try {
+		storageResult = await createStorage(storageConfig);
+	} catch (error) {
+		unregisterSession();
+		throw error;
+	}
+	const storageWarning = storageResult.warning;
+	let observabilityDomain;
+	let observabilityWarning;
+	if (globalSettings.observability.localTracing) try {
+		const observabilityDuckDB = new DuckDBStore({
+			id: "mastra-code-observability",
+			path: getObservabilityDatabasePath()
+		});
+		await observabilityDuckDB.db.getConnection();
+		observabilityDomain = observabilityDuckDB.observability;
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		if (/lock|locked|busy/i.test(message)) observabilityWarning = "Observability unavailable — another MastraCode instance holds the database lock. Traces, scores, and feedback will not be recorded in this session.";
+		else observabilityWarning = `Observability unavailable — DuckDB initialization failed: ${message}`;
+	}
+	const scoresStorage = new DiscardingScoresStorage();
+	const storage = new MastraCompositeStore({
+		id: "mastra-code-storage",
+		default: storageResult.storage,
+		domains: {
+			observability: observabilityDomain ?? false,
+			scores: scoresStorage
+		}
+	});
+	const observability = new Observability({ configs: { default: {
+		serviceName: "mastracode",
+		requestContextKeys: [
+			"controller.threadId",
+			"controller.resourceId",
+			"controller.session.modeId",
+			"controller.controllerId",
+			"controller.state.projectName",
+			"controller.state.gitBranch",
+			"controller.session.modelId",
+			"controller.state.subagentModelId",
+			"controller.state.yolo",
+			"controller.state.thinkingLevel",
+			"controller.state.smartEditing",
+			"controller.state.omScope",
+			"om.observer.selectionMode",
+			"om.observer.effectiveModelId",
+			"om.reflector.selectionMode",
+			"om.reflector.effectiveModelId",
+			"controller.state.observationThreshold",
+			"controller.state.reflectionThreshold"
+		],
+		exporters: [...observabilityDomain ? [new MastraStorageExporter({ strategy: "event-sourced" })] : [], new MastraPlatformExporter({
+			...cloudObservabilityConfig,
+			resolveFromEnv: false
+		})],
+		spanOutputProcessors: [new SensitiveDataFilter()]
+	} } });
+	const vector = config?.vector ?? (storageConfig ? await createVectorStore(storageConfig, storageResult.backend) : void 0);
+	const storageMaintenance = createStorageMaintenance({
+		storage: storageResult.storage,
+		backend: storageResult.backend,
+		retention: DEFAULT_RETENTION,
+		localDbFiles: storageConfig ? resolveLocalDbFiles(storageConfig, storageResult.backend) : [],
+		closeVector: vector instanceof LibSQLVector ? () => vector.close() : void 0
+	});
+	const configuredKnowledgeKey = config?.knowledge?.key.trim();
+	if (config?.knowledge && !configuredKnowledgeKey) throw new Error("knowledge.key must be a non-empty string.");
+	const knowledge = config?.knowledge?.instance ?? (process.env.MASTRACODE_EXPERIMENTAL_SUBCONSCIOUS === "1" ? new Knowledge({
+		id: "mastracode",
+		name: "MastraCode Knowledge",
+		storage
+	}) : void 0);
+	const knowledgeKey = configuredKnowledgeKey ?? "default";
+	const dynamicMemory = config?.memory === void 0 ? getDynamicMemory(storage, vector, config?.settingsPath, { disableSettingsOmSeed: config?.disableSettingsOmSeed }, knowledge) : void 0;
+	const memory = config?.memory === false ? void 0 : config?.memory ?? (dynamicMemory && Object.assign(withCredentialTenantPreparation(dynamicMemory), { settled: dynamicMemory.settled }));
+	const hasSubconscious = config?.memory === void 0 ? (state) => hasSubconsciousTools(vector, state) : false;
+	const mcpManager = config?.disableMcp ? void 0 : createMcpManager(project.rootPath, configDir, config?.mcpServers, globalSettings.mcp);
+	const hookManager = config?.disableHooks ? void 0 : new HookManager(project.rootPath, "session-init", configDir, homeDir, project.isWorktree ? {
+		path: project.rootPath,
+		branch: project.gitBranch,
+		mainRepoPath: project.mainRepoPath
+	} : void 0);
+	const pluginManager = config?.disablePlugins ? void 0 : config?.pluginManager ?? new PluginManager({
+		projectRoot: project.rootPath,
+		configDir,
+		homeDir
+	});
+	pluginManager?.setRuntime({
+		getController: () => pluginRuntimeController,
+		getActiveSession: () => activeSession,
+		getStorage: () => ({
+			storage,
+			storageBackend: storageResult.backend,
+			vector
+		})
+	});
+	const loadedPlugins = pluginManager ? await pluginManager.reload() : [];
+	const pluginTools = pluginManager?.getPluginTools() ?? {};
+	const outcomeScorer = createOutcomeScorer();
+	const efficiencyScorer = createEfficiencyScorer();
+	const ownsNotificationDispatch = !configuredPubSub;
+	const dispatchLeasePubSub = ownsNotificationDispatch && !ownSignalsPubSub && process.platform !== "win32" ? createSignalsPubSub(project.resourceId) : void 0;
+	const notificationDispatcher = createResourceNotificationDispatcher({
+		getMastra: () => controller.getMastra(),
+		getResourceIds: () => [...liveSessions].map((session) => session.identity.getResourceId()),
+		leases: ownsNotificationDispatch ? (ownSignalsPubSub ?? dispatchLeasePubSub)?.getLeaseProvider() : void 0,
+		owner: `${ownerId}:${process.pid}:${randomUUID()}`,
+		onError: (error) => console.warn("Notification dispatch failed:", error)
+	});
+	const getWakeStreamOptions = async ({ resourceId, threadId }) => {
+		const session = await controller.getSessionByResource(resourceId);
+		if (!session) return void 0;
+		const targetThread = await session.thread.getById({ threadId });
+		const metadata = targetThread?.resourceId === resourceId ? targetThread.metadata : void 0;
+		const modes = controller.listModes();
+		const savedModeId = metadata?.currentModeId;
+		const defaultMode = modes.find((mode) => mode.default) ?? modes[0];
+		const modeId = typeof savedModeId === "string" && modes.some((mode) => mode.id === savedModeId) ? savedModeId : defaultMode?.id ?? session.mode.get();
+		const persistedModelId = metadata ? await migratePersistedModelSelection({
+			getMetadata: async () => (await session.thread.getById({ threadId }))?.metadata ?? {},
+			modeId,
+			set: (key, value) => session.thread.setSettingOn({
+				threadId,
+				key,
+				value
+			}),
+			threadId,
+			validModeIds: modes.map((mode) => mode.id)
+		}) : void 0;
+		const defaultModeModelId = modes.find((mode) => mode.id === modeId)?.defaultModelId;
+		const modelId = persistedModelId ?? defaultModeModelId ?? session.model.get() ?? "";
+		const baseState = { ...session.state.get() };
+		delete baseState.modelRoute;
+		delete baseState.mastracodePendingModelFallback;
+		const persistedSandboxPaths = metadata?.sandboxAllowedPaths;
+		baseState.sandboxAllowedPaths = Array.isArray(persistedSandboxPaths) && persistedSandboxPaths.every((path) => typeof path === "string") ? persistedSandboxPaths : [];
+		const persistedStateKeys = [
+			"thinkingLevel",
+			"notifications",
+			"modelRoute",
+			MODEL_FALLBACK_STATE_KEY
+		];
+		for (const key of persistedStateKeys) {
+			const value = metadata?.[key];
+			if (value !== void 0) baseState[key] = value;
+		}
+		let notificationState = baseState;
+		const getNotificationState = () => ({ ...notificationState });
+		const setNotificationState = async (updates) => {
+			notificationState = {
+				...notificationState,
+				...updates
+			};
+			if (session.thread.getId() === threadId) await session.state.set(updates);
+		};
+		const updateNotificationState = async (updater) => {
+			const update = await updater(getNotificationState());
+			if (update.updates) await setNotificationState(update.updates);
+			for (const event of update.events ?? []) if (session.thread.getId() === threadId) session.emit(event);
+			return update.result;
+		};
+		const requestContext = new RequestContext();
+		const agentControllerContext = {
+			controllerId: controller.id,
+			state: getNotificationState(),
+			getState: getNotificationState,
+			setState: setNotificationState,
+			updateState: updateNotificationState,
+			getThreadSetting: (key) => session.thread.getSettingOn({
+				threadId,
+				key
+			}),
+			setThreadSetting: (setting) => session.thread.setSettingOn({
+				threadId,
+				key: setting.key,
+				value: setting.value
+			}),
+			isThreadActive: () => session.thread.getId() === threadId,
+			threadId,
+			resourceId,
+			session: {
+				id: session.identity.getId(),
+				ownerId: session.identity.getOwnerId(),
+				modeId,
+				modelId,
+				state: {
+					get: getNotificationState,
+					set: setNotificationState,
+					update: updateNotificationState
+				}
+			},
+			workspace: session.getWorkspace(),
+			emitEvent: (event) => {
+				if (session.thread.getId() === threadId) session.emit(event);
+			},
+			getSubagentModelId: (params) => {
+				const agentType = params?.agentType;
+				const perType = agentType ? metadata?.[`subagentModelId_${agentType}`] : void 0;
+				const global = metadata?.subagentModelId;
+				if (typeof perType === "string") return perType;
+				if (typeof global === "string") return global;
+				return session.thread.getId() === threadId ? session.subagents.model.get(params ?? {}) : null;
+			}
+		};
+		requestContext.set("controller", agentControllerContext);
+		await config?.prepareWakeRequestContext?.({
+			requestContext,
+			resourceId,
+			threadId
+		});
+		return {
+			memory: {
+				thread: threadId,
+				resource: resourceId
+			},
+			requestContext,
+			maxSteps: 1e3,
+			savePerStep: false,
+			requireToolApproval: notificationState.yolo !== true,
+			modelSettings: { temperature: 1 }
+		};
+	};
+	const threadScheduler = new ThreadScheduler({
+		assemblePrompt: (schedule) => assembleSchedulePrompt(schedule, {
+			cwd: project.rootPath,
+			runScript,
+			readFile: (absPath) => readFile(absPath, "utf8")
+		}),
+		deliver: async (schedule, assembled) => {
+			const target = {
+				resourceId: schedule.resourceId,
+				threadId: schedule.threadId
+			};
+			const streamOptions = await getWakeStreamOptions(target);
+			const accepted = await codeAgent.sendSignal({
+				type: "user",
+				tagName: "user",
+				contents: assembled.prompt,
+				attributes: scheduleSignalAttributes(schedule, assembled)
+			}, {
+				...target,
+				ifActive: { behavior: "deliver" },
+				ifIdle: {
+					behavior: "wake",
+					...streamOptions ? { streamOptions } : {}
+				}
+			}).accepted;
+			if (accepted.action === "blocked" || accepted.action === "discard") throw new Error(`the agent did not accept the prompt (${accepted.action})`);
+		},
+		onError: (error, schedule) => {
+			console.warn(`Schedule ${shortScheduleId(schedule.id)} failed to fire:`, error);
+		}
+	});
+	const scheduleTools = useScheduleTools ? createScheduleTools({
+		scheduler: threadScheduler,
+		fileOptions: () => ({
+			cwd: project.rootPath,
+			homeDir: homedir(),
+			fileExists: (absPath) => {
+				try {
+					return statSync(absPath).isFile();
+				} catch {
+					return false;
+				}
+			}
+		})
+	}) : void 0;
+	const githubSignals = globalSettings.signals?.experimentalGithubSignals && !config?.disableGithubSignals ? new GithubSignals({
+		cwd: project.rootPath,
+		pollIntervalMs: globalSettings.signals.githubPollIntervalMs,
+		gitcrawlCommand: process.env.MASTRACODE_GITCRAWL_BIN ?? process.env.GITCRAWL_BIN ?? process.env.MASTRACODE_GITCRAWL_COMMAND ?? process.env.GITCRAWL_COMMAND,
+		getNotificationStreamOptions: getWakeStreamOptions
+	}) : void 0;
+	const mastraCodeInputProcessors = [
+		...Array.isArray(config?.inputProcessors) ? config.inputProcessors : [],
+		new PlanRejectionAbortProcessor(),
+		...backgroundToolsEnabled ? [createBackgroundWorkSignalProcessor()] : [],
+		new AgentsMDInjector({
+			isEnabled: ({ requestContext }) => {
+				const state = getInjectorSessionState(requestContext);
+				return state?.untrustedCheckout !== true || typeof state?.baseRef === "string";
+			},
+			getBasePath: ({ requestContext }) => getInjectorSessionState(requestContext)?.projectPath ?? project.rootPath,
+			getReader: ({ requestContext }) => {
+				const state = getInjectorSessionState(requestContext);
+				if (state?.untrustedCheckout !== true || typeof state?.baseRef !== "string") return void 0;
+				const projectPath = state?.projectPath ?? project.rootPath;
+				const [primary] = sessionInstructionRoots(projectPath, state.instructionRoots);
+				const reader = createGitRefReminderReader(primary, state.baseRef);
+				if (primary === projectPath) return reader;
+				const outsidePrimary = (filePath) => {
+					const inProject = path.relative(projectPath, filePath);
+					const inPrimary = path.relative(primary, filePath);
+					const under = (rel) => rel !== ".." && !rel.startsWith(`..${path.sep}`) && !path.isAbsolute(rel);
+					return under(inProject) && !under(inPrimary);
+				};
+				return {
+					...reader,
+					pathExists: (filePath) => !outsidePrimary(filePath) && reader.pathExists(filePath),
+					isDirectory: (filePath) => !outsidePrimary(filePath) && reader.isDirectory(filePath)
+				};
+			},
+			getIgnoredInstructionPaths: ({ requestContext }) => {
+				const state = getInjectorSessionState(requestContext);
+				const projectPath = state?.projectPath ?? project.rootPath;
+				const untrusted = state?.untrustedCheckout === true && typeof state?.baseRef === "string";
+				const roots = sessionInstructionRoots(projectPath, state?.instructionRoots);
+				return instructionSourcePaths(loadSessionInstructions({
+					workingDir: projectPath,
+					instructionRoots: state?.instructionRoots,
+					untrustedCheckout: untrusted,
+					baseRef: untrusted ? state?.baseRef : void 0
+				}), roots);
+			}
+		})
+	];
+	const disabledBuiltinTools = new Set(config?.disableBuiltinTools ?? []);
+	const taskSignalProvider = new TaskSignalProvider();
+	if (disabledBuiltinTools.size > 0) {
+		const taskTools = Object.entries(taskSignalProvider.getTools?.() ?? {});
+		const enabledTaskTools = Object.fromEntries(taskTools.filter(([id]) => !disabledBuiltinTools.has(id)));
+		taskSignalProvider.getTools = () => enabledTaskTools;
+	}
+	const agentConnectionsSignalProvider = useCrossAgentSignals ? new AgentConnectionsSignalProvider(config?.agentConnections) : void 0;
+	const NO_PLUGIN_PROCESSORS = {
+		input: [],
+		output: []
+	};
+	let pluginProcessorReadWarned = false;
+	const pluginSignalLane = pluginManager ? new PluginSignalLane({ reservedProviderIds: [
+		taskSignalProvider.id,
+		...agentConnectionsSignalProvider ? [agentConnectionsSignalProvider.id] : [],
+		...githubSignals ? [githubSignals.id] : []
+	] }) : void 0;
+	let unsubscribePluginReload;
+	/**
+	* Plugin processors are read through a function so that enabling, disabling or
+	* updating a plugin takes effect on the next request rather than requiring a
+	* new agent. This runs before every LLM call, and also outside the request
+	* path when the Agent catalogues its configured processors — where a throw is
+	* swallowed into a debug log. So it only reads already-resolved state: no
+	* filesystem, no network, no construction, and it never throws.
+	*/
+	const readPluginProcessors = () => {
+		try {
+			return pluginManager?.getPluginProcessors() ?? NO_PLUGIN_PROCESSORS;
+		} catch (error) {
+			if (!pluginProcessorReadWarned) {
+				pluginProcessorReadWarned = true;
+				console.warn("Failed to read plugin processors:", error);
+			}
+			return NO_PLUGIN_PROCESSORS;
+		}
+	};
+	const codeAgent = wrapExperimentalAgent(createCodingAgent({
+		id: CODE_AGENT_ID,
+		name: "Code Agent",
+		workspace: void 0,
+		instructions: async ({ requestContext }) => {
+			const configured = config?.hostInstructions;
+			return getDynamicInstructions({
+				requestContext,
+				hostInstructions: typeof configured === "function" ? await configured({ requestContext }) : configured,
+				coAuthor: config?.coAuthor,
+				hasSubconscious,
+				hasSubagents: subagents.length > 0,
+				disabledBuiltinTools: config?.disableBuiltinTools
+			});
+		},
+		model: withCredentialTenantPreparation((ctx) => getDynamicModel(ctx, config?.settingsPath, { modeless })),
+		notifications: { deliveryPolicy: { decide: async (input) => {
+			const decision = defaultNotificationDeliveryDecision(input);
+			if (!input.record.resourceId) return decision;
+			const streamOptions = await getWakeStreamOptions({
+				resourceId: input.record.resourceId,
+				threadId: input.record.threadId
+			});
+			const withOptions = streamOptions ? {
+				...decision,
+				streamOptions
+			} : decision;
+			if (!ownsNotificationDispatch) return withOptions;
+			return shouldHoldNotificationDelivery({
+				resourceId: input.record.resourceId,
+				ownedHere: streamOptions !== void 0,
+				dispatcher: notificationDispatcher
+			}) ? {
+				...withOptions,
+				hold: true
+			} : withOptions;
+		} } },
+		tools: createDynamicTools(mcpManager, config?.extraTools, config?.disabledTools, storage, pluginTools, backgroundToolsEnabled, scheduleTools),
+		hooks: createToolHooks(hookManager, config?.postToolObserver),
+		scorers: {
+			outcome: {
+				scorer: outcomeScorer,
+				sampling: { type: "none" }
+			},
+			efficiency: {
+				scorer: efficiencyScorer,
+				sampling: {
+					type: "ratio",
+					rate: .3
+				}
+			}
+		},
+		signals: [
+			taskSignalProvider,
+			...agentConnectionsSignalProvider ? [agentConnectionsSignalProvider] : [],
+			...githubSignals ? [githubSignals] : []
+		],
+		goal: {
+			judge: withCredentialTenantPreparation((ctx) => getGoalJudgeModel(ctx, config?.settingsPath)),
+			maxRuns: globalSettings.models.goalMaxTurns ?? 50,
+			maxSteps: 1e3,
+			prompt: DEFAULT_GOAL_JUDGE_PROMPT,
+			tools: getGoalJudgeTools
+		},
+		inputProcessors: ({ requestContext }) => {
+			const resolveProcessors = (configured) => [
+				...configured,
+				...mastraCodeInputProcessors,
+				new AccountStartNoticeProcessor({ credentialStore: authStorage }),
+				...readPluginProcessors().input.map((entry) => entry.value),
+				...pluginSignalLane?.getInputProcessors() ?? []
+			];
+			if (typeof config?.inputProcessors !== "function") return resolveProcessors([]);
+			const configured = config.inputProcessors({ requestContext });
+			return configured instanceof Promise ? configured.then(resolveProcessors) : resolveProcessors(configured);
+		},
+		outputProcessors: () => [
+			new CyberRefusalHandler(),
+			...readPluginProcessors().output.map((entry) => entry.value),
+			...pluginSignalLane?.getOutputProcessors() ?? []
+		],
+		errorProcessors: [
+			new ProviderHistoryCompat(),
+			new CyberRefusalHandler(),
+			new StreamErrorRetryProcessor({ matchers: [
+				{
+					match: isBadRequestError,
+					maxRetries: 1,
+					delayMs: 2e3
+				},
+				{
+					match: isTransientConnectionError,
+					maxRetries: MASTRACODE_TRANSIENT_CONNECTION_MAX_RETRIES,
+					delayMs: ({ retryCount }) => getTransientRetryDelay(retryCount),
+					onRetry: ({ error, retryCount, delayMs, requestContext }) => emitTransientRetry(error, retryCount, delayMs, requestContext)
+				},
+				{
+					match: isTransientServerError,
+					maxRetries: MASTRACODE_TRANSIENT_CONNECTION_MAX_RETRIES,
+					delayMs: ({ retryCount }) => getTransientRetryDelay(retryCount),
+					onRetry: ({ error, retryCount, delayMs, requestContext }) => emitTransientRetry(error, retryCount, delayMs, requestContext)
+				}
+			] }),
+			new AccountRotationProcessor({
+				credentialStore: authStorage,
+				maxProcessorRetries: MASTRACODE_MAX_PROCESSOR_RETRIES,
+				settingsPath: config?.settingsPath,
+				modeless
+			})
+		],
+		maxProcessorRetries: MASTRACODE_MAX_PROCESSOR_RETRIES
+	}), experimentalAgent);
+	const planMode = createPlanMode(!disabledBuiltinTools.has("submit_plan"));
+	const defaultModes = [
+		{
+			...buildMode,
+			metadata: {
+				...buildMode.metadata,
+				color: mastraBrand.green
+			}
+		},
+		{
+			...planMode,
+			metadata: {
+				...planMode.metadata,
+				color: mastraBrand.purple
+			}
+		},
+		{
+			...fastMode,
+			metadata: {
+				...fastMode.metadata,
+				color: mastraBrand.orange
+			}
+		}
+	];
+	const intervalHandlers = config?.intervalHandlers ?? [{
+		id: "gateway-sync",
+		intervalMs: 300 * 1e3,
+		immediate: false,
+		handler: () => syncGateways()
+	}];
+	const anthropicCred = authStorage.get("anthropic");
+	const openaiCred = authStorage.get("openai-codex");
+	const githubCopilotCred = authStorage.get("github-copilot");
+	const kimiCodingCred = authStorage.get("kimi-for-coding");
+	const startupAccess = {
+		anthropic: anthropicCred?.type === "oauth" ? "oauth" : anthropicCred?.type === "api_key" && anthropicCred.key.trim().length > 0 ? "apikey" : false,
+		openai: openaiCred?.type === "oauth" ? "oauth" : openaiCred?.type === "api_key" && openaiCred.key.trim().length > 0 ? "apikey" : false,
+		cerebras: process.env.CEREBRAS_API_KEY ? "apikey" : false,
+		google: process.env.GOOGLE_GENERATIVE_AI_API_KEY ? "apikey" : false,
+		deepseek: process.env.DEEPSEEK_API_KEY ? "apikey" : false,
+		"github-copilot": githubCopilotCred?.type === "oauth" ? "oauth" : false,
+		"kimi-for-coding": kimiCodingCred?.type === "oauth" && isKimiCodingDeviceId(kimiCodingCred.deviceId) ? "oauth" : kimiCodingCred?.type === "api_key" && kimiCodingCred.key.trim().length > 0 || Boolean(process.env.KIMI_API_KEY?.trim()) ? "apikey" : false
+	};
+	if (mgApiKey) {
+		if (!startupAccess.anthropic) startupAccess.anthropic = "apikey";
+		if (!startupAccess.openai) startupAccess.openai = "apikey";
+	}
+	try {
+		const registry = PROVIDER_REGISTRY;
+		for (const [provider, config] of Object.entries(registry)) {
+			if (startupAccess[provider] === "oauth" || startupAccess[provider] === "apikey") continue;
+			if (provider === "anthropic" || provider === "openai") continue;
+			const envVars = config?.apiKeyEnvVar;
+			if ((Array.isArray(envVars) ? envVars : envVars ? [envVars] : []).some((envVar) => process.env[envVar])) startupAccess[provider] = "apikey";
+		}
+	} catch {}
+	const builtinOmPacks = getAvailableOmPacks(startupAccess);
+	const effectiveDefaults = globalSettings.models.modeDefaults;
+	const effectiveObserverModel = resolveOmRoleModel(globalSettings, "observer", builtinOmPacks);
+	const effectiveReflectorModel = resolveOmRoleModel(globalSettings, "reflector", builtinOmPacks);
+	const observerModelSelection = globalSettings.models.observerModelSelection;
+	const reflectorModelSelection = globalSettings.models.reflectorModelSelection;
+	const effectiveObservationThreshold = globalSettings.models.omObservationThreshold ?? void 0;
+	const effectiveReflectionThreshold = globalSettings.models.omReflectionThreshold ?? void 0;
+	const effectiveCavemanObservations = globalSettings.models.omCavemanObservations ?? void 0;
+	const effectiveObserveAttachments = globalSettings.models.omObserveAttachments ?? "auto";
+	const modes = addPluginToolsToModeAllowlists(applyModeDefaultsToModes(config?.modes === false ? [buildMode] : config?.modes ?? defaultModes, effectiveDefaults), Object.keys(pluginTools));
+	const defaultModeId = modes.find((mode) => mode.metadata?.default === true)?.id ?? modes.find((mode) => mode.id === "build")?.id ?? modes[0]?.id;
+	if (!defaultModeId) throw new Error("MastraCode requires at least one mode");
+	const subagentModeMap = {
+		explore: "fast",
+		plan: "plan",
+		execute: "build"
+	};
+	const disabledTools = new Set(config?.disabledTools);
+	const subagents = (config?.subagents ?? [
+		exploreSubagent,
+		planSubagent,
+		executeSubagent
+	]).map((definition) => ({
+		...definition,
+		...config?.subagents == null && { defaultModelId: modes.find((mode) => mode.id === subagentModeMap[definition.id])?.defaultModelId ?? modes.find((mode) => mode.id === defaultModeId)?.defaultModelId },
+		allowedControllerTools: definition.allowedControllerTools?.filter((name) => !disabledTools.has(name)),
+		allowedWorkspaceTools: definition.allowedWorkspaceTools?.filter((name) => !disabledTools.has(name)),
+		...definition.tools && { tools: Object.fromEntries(Object.entries(definition.tools).filter(([name]) => !disabledTools.has(name))) }
+	}));
+	const globalInitialState = {};
+	if (!config?.disableSettingsOmSeed) {
+		if (observerModelSelection === "auto") globalInitialState.observerModelSelection = "auto";
+		else if (effectiveObserverModel) {
+			globalInitialState.observerModelId = effectiveObserverModel;
+			globalInitialState.observerModelSelection = effectiveObserverModel;
+		} else globalInitialState.observerModelSelection = "auto";
+		if (reflectorModelSelection === "auto") globalInitialState.reflectorModelSelection = "auto";
+		else if (effectiveReflectorModel) {
+			globalInitialState.reflectorModelId = effectiveReflectorModel;
+			globalInitialState.reflectorModelSelection = effectiveReflectorModel;
+		} else globalInitialState.reflectorModelSelection = "auto";
+		if (effectiveObservationThreshold !== void 0) globalInitialState.observationThreshold = effectiveObservationThreshold;
+		if (effectiveReflectionThreshold !== void 0) globalInitialState.reflectionThreshold = effectiveReflectionThreshold;
+		if (effectiveCavemanObservations !== void 0) globalInitialState.cavemanObservations = effectiveCavemanObservations;
+		if (effectiveObserveAttachments !== void 0) globalInitialState.observeAttachments = effectiveObserveAttachments;
+	}
+	if (globalSettings.preferences.yolo !== null) globalInitialState.yolo = globalSettings.preferences.yolo;
+	if (config?.omScope) globalInitialState.omScope = config.omScope;
+	for (const [key, modelId] of Object.entries(globalSettings.models.subagentModels)) if (key === "default" || key === "_default") globalInitialState.subagentModelId = modelId;
+	else globalInitialState[`subagentModelId_${key}`] = modelId;
+	const typedStateSchema = stateSchema;
+	const backgroundCompletionEvents = backgroundToolsEnabled ? createBackgroundCompletionEvents() : void 0;
+	let controller;
+	controller = new AgentController({
+		id: "mastra-code",
+		resourceId: project.resourceId,
+		storage,
+		...backgroundToolsEnabled ? { backgroundTasks: {
+			enabled: true,
+			recoverStaleTasksOnStart: false,
+			...createBackgroundCompletionCallbacks(() => controller, backgroundCompletionEvents)
+		} } : {},
+		observability,
+		memory,
+		pubsub: signalsPubSub,
+		stateSchema: typedStateSchema,
+		omConfig: {
+			observerModel: "auto",
+			defaultObserverModelId: DEFAULT_OM_MODEL_ID,
+			reflectorModel: "auto",
+			defaultReflectorModelId: DEFAULT_OM_MODEL_ID,
+			resolveAutoModelId: ({ currentModelId }) => resolveAutoOMModelId(currentModelId)
+		},
+		agent: codeAgent,
+		subagents,
+		...config?.disableBuiltinTools?.length ? { disableBuiltinTools: config.disableBuiltinTools } : {},
+		resolveSubagentModel: (modelId, { requestContext }) => routesToOtherGateway(modelId, Object.values(controller.getMastra()?.listGateways() ?? {}), /* @__PURE__ */ new Set([
+			mastraCodeGateway.id,
+			amazonBedrockGateway.id,
+			githubCopilotGateway.id,
+			"models.dev"
+		])) ? modelId : resolveModel(modelId, { requestContext }),
+		gateways: [
+			amazonBedrockGateway,
+			githubCopilotGateway,
+			mastraCodeGateway
+		],
+		workspace: config?.workspace ?? ((args) => getDynamicWorkspace({
+			...args,
+			backgroundToolsEnabled
+		})),
+		browser: config?.browser,
+		idGenerator: config?.idGenerator,
+		toolCategoryResolver: getToolCategory,
+		initialState: {
+			projectPath: project.rootPath,
+			projectName: project.name,
+			gitBranch: project.gitBranch,
+			pluginSkillPaths: loadedPlugins.flatMap((plugin) => plugin.status === "active" ? plugin.skillPaths ?? [] : []),
+			pluginCommandPaths: loadedPlugins.flatMap((plugin) => plugin.status === "active" ? plugin.commandPaths ?? [] : []),
+			pluginInstructions: loadedPlugins.flatMap((plugin) => plugin.status === "active" && plugin.instructions ? [plugin.instructions] : []),
+			yolo: true,
+			...globalInitialState,
+			...config?.initialState,
+			configDir
+		},
+		modes,
+		intervalHandlers,
+		modelUseCountProvider: () => loadSettings().modelUseCounts,
+		modelUseCountTracker: (modelId) => {
+			try {
+				const settings = loadSettings();
+				settings.modelUseCounts[modelId] = (settings.modelUseCounts[modelId] ?? 0) + 1;
+				saveSettings(settings);
+			} catch (error) {
+				console.error("Failed to persist model usage count", error);
+			}
+		},
+		threadLock: crossProcessPubSub ? void 0 : {
+			acquire: acquireThreadLock,
+			release: releaseThreadLock
+		}
+	});
+	controller.onSessionCreated((session) => {
+		liveSessions.add(session);
+	});
+	controller.onSessionDeleted((session) => {
+		liveSessions.delete(session);
+	});
+	const sessionPeerCleanup = /* @__PURE__ */ new WeakMap();
+	if (useCrossAgentSignals) {
+		controller.onSessionCreated(async (session) => {
+			const advertisement = createSessionThreadAdvertisement({
+				session,
+				controller,
+				projectName: project.name
+			});
+			sessionPeerCleanup.set(session, () => advertisement.close());
+			const initialThreadId = session.thread.getId();
+			if (initialThreadId) await Promise.race([advertisement.claim(initialThreadId), new Promise((resolve) => {
+				setTimeout(resolve, 5e3).unref?.();
+			})]);
+		}, { blocking: true });
+		controller.onSessionDeleted((session) => {
+			sessionPeerCleanup.get(session)?.();
+			sessionPeerCleanup.delete(session);
+		});
+	}
+	pluginRuntimeController = controller;
+	if (pluginSignalLane && pluginManager) {
+		pluginSignalLane.sync(pluginManager.getPluginSignalProviders());
+		unsubscribePluginReload = pluginManager.onReload(() => pluginSignalLane.sync(pluginManager.getPluginSignalProviders()));
+	}
+	return {
+		controller,
+		storage,
+		storageMaintenance,
+		createKnowledgeInspector: (session, knowledgeKey) => createKnowledgeInspector({
+			storage,
+			knowledge: knowledgeKey ?? knowledge,
+			mastra: controller.getMastra(),
+			session
+		}),
+		observability,
+		memory,
+		knowledge,
+		knowledgeKey,
+		mcpManager,
+		hookManager,
+		pluginManager,
+		loadedPlugins,
+		pluginTools,
+		signalsPubSub,
+		authStorage,
+		resolveModel,
+		storageWarning,
+		observabilityWarning,
+		builtinOmPacks,
+		effectiveDefaults,
+		githubSignals,
+		backgroundToolsEnabled,
+		backgroundCompletionEvents,
+		sessionId,
+		ownerId,
+		projectPath: project.rootPath,
+		codeAgent,
+		setActiveSession: (session) => {
+			activeSession = session;
+		},
+		/**
+		* Starts the signal providers contributed by plugins. Called by the
+		* composition layer once the controller is inited, because that is when a
+		* Mastra instance exists — a provider without one has no storage, and
+		* nothing else will hand it one: the Agent propagates Mastra only to the
+		* providers in its own `signals` array, which these deliberately are not in.
+		*/
+		startPluginSignalProviders: () => {
+			const mastra = controller.getMastra();
+			if (!pluginSignalLane || !mastra) return;
+			pluginSignalLane.setMastra(mastra, codeAgent);
+		},
+		/**
+		* Stops every plugin-contributed signal provider and stops listening for
+		* plugin reloads. The inverse of `startPluginSignalProviders`, for an
+		* embedder that is done with this controller: a `pluginManager` shared
+		* across controllers (`MastraCodeConfig.pluginManager`) outlives any one of
+		* them, so without this its providers keep polling and its reload listener
+		* keeps firing for a controller that is gone.
+		*/
+		stopPluginSignalProviders: () => {
+			unsubscribePluginReload?.();
+			unsubscribePluginReload = void 0;
+			pluginSignalLane?.stopAll();
+		},
+		/** Process-local `/schedules` scheduler. Call `stop()` on shutdown. */
+		threadScheduler,
+		/**
+		* Starts delivering the due notifications of this controller's sessions'
+		* resources from this process. Called by the composition layer once the
+		* controller is inited. A no-op when the embedder configured its own
+		* PubSub, whose shared dispatch schedule keeps delivering everything.
+		*/
+		startNotificationDispatch: () => {
+			if (ownsNotificationDispatch) notificationDispatcher.start();
+		},
+		/**
+		* Stops advertising every live session's threads and releases their
+		* ownership claims. Call first on shutdown: a claim otherwise stays held
+		* (and renewed) through the rest of teardown, so a restarted process cannot
+		* claim the thread — and peers cannot reach it — until this one exits.
+		*/
+		releaseThreadClaims: () => {
+			for (const session of liveSessions) {
+				sessionPeerCleanup.get(session)?.();
+				sessionPeerCleanup.delete(session);
+			}
+		},
+		/** Stops this process's notification dispatch and releases its leases. Call on shutdown. */
+		stopNotificationDispatch: async () => {
+			await notificationDispatcher.stop();
+			await dispatchLeasePubSub?.close();
+		},
+		/**
+		* Hands Mastra to the statically configured input processors.
+		*
+		* The Agent does this itself, but only for processors configured as a
+		* plain array (`Array.isArray` in `__registerMastra`). This lane is a
+		* function so plugins can contribute to it, which takes those processors
+		* out of that branch — including any an embedder passed as
+		* `config.inputProcessors`, some of which need Mastra to work at all
+		* (`CostGuardProcessor` reads observability storage there). Doing it here
+		* keeps that unchanged.
+		*
+		* Plugin processors are deliberately not included: they come and go with
+		* their plugin, and the registry keeps the first instance registered under
+		* an id forever, which would leave a retired instance behind. Plugins
+		* reach Mastra through `getController()` on the plugin context instead.
+		*/
+		registerConfiguredProcessorsWithMastra: () => {
+			const mastra = controller.getMastra();
+			if (!mastra) return;
+			for (const processor of mastraCodeInputProcessors) {
+				mastra.addProcessor(processor);
+				mastra.addProcessorConfiguration(processor, CODE_AGENT_ID, "input");
+			}
+		}
+	};
+}
+/**
+* Wires the session-scoped concerns MastraCode layers on top of a Session:
+* hookManager thread-id sync, GitHub PR polling for the current thread, and
+* per-thread persistence of the mastracode-only `/om` settings.
+*
+* Used by {@link bootLocalAgentController} for the single local session. A server can
+* call this for any session it mints if it wants the same background wiring.
+*/
+async function wireSessionConcerns(base, session) {
+	const { hookManager, githubSignals } = base;
+	base.setActiveSession(session);
+	if (hookManager) session.subscribe((event) => {
+		if (event.type === "thread_changed") hookManager.setSessionId(event.threadId);
+		else if (event.type === "thread_created") hookManager.setSessionId(event.thread.id);
+	});
+	if (githubSignals) {
+		const startGithubPollingForCurrentThread = async (threadId) => {
+			if (!threadId) return;
+			githubSignals.stopAllPolling();
+			try {
+				const thread = (await session.thread.list({ allResources: true })).find((item) => item.id === threadId);
+				await githubSignals.startPollingForThread({
+					threadId,
+					resourceId: thread?.resourceId ?? session.identity.getResourceId()
+				}, { pollImmediately: true });
+			} catch (error) {
+				console.warn("Failed to start GitHub PR polling:", error);
+			}
+		};
+		session.subscribe((event) => {
+			if (event.type === "thread_changed") startGithubPollingForCurrentThread(event.threadId);
+			else if (event.type === "thread_created") startGithubPollingForCurrentThread(event.thread.id);
+		});
+		startGithubPollingForCurrentThread(session.thread.getId());
+	}
+	const omThreadStateSession = session;
+	attachOMThreadStatePersistence(omThreadStateSession);
+	await restoreOMThreadStateForCurrentThread(omThreadStateSession).catch(() => {});
+}
+/**
+* Case 3 (AgentController local + TUI/headless): build the controller, let it stand up its
+* own internal Mastra via `init()`, and mint the single eager session that all
+* work in this process runs through. The AgentController owns no session of its own.
+*/
+async function bootLocalAgentController(config) {
+	const base = await createMastraCodeAgentController(config);
+	const { controller, sessionId, ownerId, projectPath, codeAgent, mcpManager } = base;
+	await controller.init();
+	validateExperimentalAgent(codeAgent, controller.getMastra());
+	const mastra = controller.getMastra();
+	registerSelectedKnowledge(mastra, base.knowledgeKey, base.knowledge);
+	if (mastra) await registerWorkflowBuilderPrimitives(mastra, {
+		projectPath,
+		codeAgent,
+		mcpManager
+	});
+	await mastra?.startWorkers();
+	base.registerConfiguredProcessorsWithMastra();
+	base.startPluginSignalProviders();
+	base.startNotificationDispatch();
+	const session = await controller.createSession({
+		id: sessionId,
+		ownerId,
+		createInitialThread: config?.createInitialThread
+	});
+	await wireSessionConcerns(base, session);
+	let knowledgeInspector;
+	let knowledgeInspectorUnavailableReason;
+	if (!base.knowledge) knowledgeInspectorUnavailableReason = "Knowledge is off. Set MASTRACODE_EXPERIMENTAL_SUBCONSCIOUS=1 or pass a `knowledge` instance to createMastraCode.";
+	else try {
+		knowledgeInspector = await base.createKnowledgeInspector(session);
+		if (!knowledgeInspector) knowledgeInspectorUnavailableReason = "Knowledge inspection requires a configured knowledge storage domain.";
+	} catch (error) {
+		knowledgeInspectorUnavailableReason = `Knowledge is unavailable: ${error instanceof Error ? error.message : String(error)}`;
+	}
+	return {
+		...base,
+		session,
+		knowledgeInspector,
+		knowledgeInspectorUnavailableReason
+	};
+}
+/**
+* Registers the selected Knowledge on a Mastra built outside `mastraArgs` (the
+* controller's internal Mastra, or a caller-owned one) so keyed lookups resolve
+* it and an instance without its own storage inherits the Mastra's.
+*/
+function registerSelectedKnowledge(mastra, key, knowledge) {
+	if (!mastra || !knowledge) return;
+	const existing = mastra.listKnowledge()[key];
+	if (existing === knowledge) return;
+	if (existing) throw new Error(`This Mastra already registers a different Knowledge instance under "${key}".`);
+	mastra.addKnowledge(knowledge, key);
+}
+/**
+* Cases 1 & 2 (AgentController in Server + Web/TUI): build the controller, register it on a
+* server-owned Mastra, THEN init it. Registering before `init()` is what makes
+* the controller inherit the server's Mastra (storage, agents, gateways) instead of
+* spinning up its own internal one — there is a single shared Mastra.
+*
+* No eager session is minted: each client (browser or terminal) creates/resumes
+* its own isolated session via `controller.createSession({ resourceId })`, so one
+* server can drive many concurrent users.
+*
+* Pass an existing `mastra` to mount onto a Mastra that already hosts other
+* primitives; otherwise a Mastra is created that owns the controller's storage so
+* durability is configured in one place.
+*/
+async function mountAgentControllerOnMastra(config) {
+	const prepared = await prepareAgentControllerMount(config);
+	if (config?.mastra) {
+		prepared.base.controller.__registerMastra(config.mastra);
+		registerSelectedKnowledge(config.mastra, prepared.base.knowledgeKey, prepared.base.knowledge);
+		await prepared.finalize();
+		return {
+			...prepared.base,
+			mastra: config.mastra
+		};
+	}
+	const mastra = new Mastra(prepared.mastraArgs);
+	await prepared.finalize();
+	return {
+		...prepared.base,
+		mastra
+	};
+}
+/**
+* Assemble everything needed to construct the server-owned Mastra WITHOUT
+* constructing it, so a caller (the platform entry `src/mastra/index.ts`) can
+* run the `new Mastra(...)` literal in its own module. The deployer's
+* `checkConfigExport` Babel plugin only marks the config valid when it finds a
+* top-level `new Mastra(...)` exported as `mastra` in the ENTRY file; hiding the
+* construction inside this helper would trip the "Invalid Mastra config" warning.
+*
+* Returns the constructor args plus a `finalize()` that runs the post-construct
+* boot (`controller.init()` + `startWorkers()`). The controller is registered on
+* the Mastra via the `agentControllers` arg at construction time.
+*/
+async function prepareAgentControllerMount(config) {
+	const base = await createMastraCodeAgentController(config);
+	const { controller, storage, authStorage, projectPath, codeAgent, mcpManager, backgroundToolsEnabled, backgroundCompletionEvents } = base;
+	const controllerId = config?.controllerId ?? controller.id;
+	const apiRoutes = config?.buildApiRoutes?.({
+		controller,
+		authStorage
+	});
+	const extraServerConfig = config?.buildServerConfig?.({
+		controller,
+		authStorage
+	});
+	const weOwnTheMastra = !config?.mastra;
+	const serverConfig = {
+		...extraServerConfig,
+		...apiRoutes?.length ? { apiRoutes } : {}
+	};
+	const mastraArgs = {
+		agentControllers: { [controllerId]: controller },
+		storage,
+		...backgroundToolsEnabled ? { backgroundTasks: {
+			enabled: true,
+			recoverStaleTasksOnStart: false,
+			...createBackgroundCompletionCallbacks(() => controller, backgroundCompletionEvents)
+		} } : {},
+		...base.knowledge ? { knowledge: { [base.knowledgeKey]: base.knowledge } } : {},
+		...base.signalsPubSub ? { pubsub: base.signalsPubSub } : {},
+		...Object.keys(serverConfig).length ? { server: serverConfig } : {}
+	};
+	const finalize = async () => {
+		await controller.init();
+		validateExperimentalAgent(codeAgent, controller.getMastra());
+		if (weOwnTheMastra) {
+			const mastra = controller.getMastra();
+			if (mastra) await registerWorkflowBuilderPrimitives(mastra, {
+				projectPath,
+				codeAgent,
+				mcpManager
+			});
+		}
+		await controller.getMastra()?.startWorkers();
+		base.registerConfiguredProcessorsWithMastra();
+		base.startPluginSignalProviders();
+		base.startNotificationDispatch();
+	};
+	return {
+		base,
+		mastraArgs,
+		finalize
+	};
+}
+/**
+* Back-compat alias. Historically `createMastraCode` built and booted a local
+* controller with a single session; that behavior now lives in
+* {@link bootLocalAgentController}. New code should call the explicit factory for its
+* case: `bootLocalAgentController` (local) or {@link mountAgentControllerOnMastra} (server).
+*/
+const createMastraCode = bootLocalAgentController;
+//#endregion
+export { KnowledgeInspectorError, LOCAL_KNOWLEDGE_ORG_ID, autoApprovePolicy, bootLocalAgentController, createAuthStorage, createKnowledgeInspector, createMastraCode, createMastraCodeAgentController, denyPolicy, formatHuman, formatJsonl, hasHeadlessFlag, mountAgentControllerOnMastra, permissionModeToPolicy, prepareAgentControllerMount, renderJsonResult, renderTextResult, resolveCloudObservabilityConfig, runMC, runMCCli, wireSessionConcerns };
+
+//# sourceMappingURL=index.js.map