@mastra/factory 0.0.0-aggregate-trace-20261015182851

package/dist/factory.js

@@ -0,0 +1,1006 @@
+import { timedPhase } from "./timing.js";
+import { buildAuthDisabledRoutes, buildAuthRoutes, createFactoryAuthGate, createFactoryRouteAuth, factoryUserOrgId, getFactoryAuthOrgId, getFactoryAuthUserFromContext, getFactoryAuthUserId } from "./auth.js";
+import { assertFactoryConfigVersion } from "./rules/validation.js";
+import { isTerminalWorkItem } from "./boards/semantics.js";
+import { createBoardRegistry } from "./boards/registry.js";
+import "./boards/index.js";
+import { isValidGitRef } from "./sandbox/git-ref.js";
+import { FactoryEnvironmentStateProcessor } from "./session/environment-state-processor.js";
+import { createPlaintextFactorySecretEncryption } from "./secret-encryption.js";
+import { ModelCredentialsStorage } from "./storage/domains/credentials/base.js";
+import { createTenantCredentialPrimer, primeTenantCredentials, registerTenantCredentialResolver } from "./routes/tenant-credentials.js";
+import { FactoryProjectsStorage } from "./storage/domains/projects/base.js";
+import { SourceControlStorage } from "./storage/domains/source-control/base.js";
+import { environmentSlugs, resolveSessionRepositories } from "./session/environment-repositories.js";
+import { createSourceControlSessionLookup } from "./session/factory-session.js";
+import { hydrateSupervisorSession, parseSupervisorResourceId, resolveSupervisorScope } from "./supervisor/session.js";
+import { FactoryWorkspaceRegistry, createWorkspaceFactory } from "./workspace.js";
+import { ENVIRONMENT_BUILD_WORKFLOW_ID } from "./environment/build-workflow.js";
+import { EnvironmentBuildRunner } from "./environment/build-runner.js";
+import { touchFeed } from "./feed-events.js";
+import { reconcileGithubAcceptanceLabels } from "./integrations/github/acceptance-labels.js";
+import { WorkItemsStorage } from "./storage/domains/work-items/base.js";
+import { IntakeStorage } from "./storage/domains/intake/base.js";
+import { isFactoryGithubLogin, trustedCollaborator } from "./integrations/github/rules.js";
+import { recordFactoryPullRequestProvenance, resolveFactoryPullRequestParentWorkItemId } from "./integrations/github/provenance.js";
+import { dismissStaleFactoryReviews } from "./integrations/github/stale-reviews.js";
+import { PlatformApiClient, platformApiClientConfigFromEnv } from "./integrations/platform/api-client.js";
+import { buildPlatformConnectRoutes } from "./integrations/platform/connect/routes.js";
+import { observeSessionFirstExec } from "./session/first-exec-capture.js";
+import { observeSessionFilesystem } from "./session/filesystem-capture.js";
+import { prepareSessionRunContext } from "./integrations/subscription-session.js";
+import { PlatformGithubIntegration } from "./integrations/platform/github/integration.js";
+import { PlatformGitLabIntegration } from "./integrations/platform/gitlab/integration.js";
+import { PlatformIncidentioIntegration } from "./integrations/platform/incidentio/integration.js";
+import { PlatformJiraIntegration } from "./integrations/platform/jira/integration.js";
+import { PlatformLinearIntegration } from "./integrations/platform/linear/integration.js";
+import { resolveFactoryCredentialTenant } from "./session/credential-policy.js";
+import { hydrateSessionMemorySettings, layerPersonalMemorySettings } from "./session/memory-settings-hydration.js";
+import { MemorySettingsStorage, factoryMemorySettingsUserId } from "./storage/domains/memory-settings/base.js";
+import { resolveDeploymentModelProviders } from "./routes/config.js";
+import { createCustomProvidersPrimer, registerCustomProvidersSource } from "./routes/custom-provider-source.js";
+import { ProjectRoutes } from "./routes/projects.js";
+import { FactoryTransitionService } from "./rules/transition-service.js";
+import { AuditStorage } from "./storage/domains/audit/base.js";
+import { AuditDomain } from "./storage/domains/audit/domain.js";
+import { QueueHealthStorage } from "./storage/domains/queue-health/base.js";
+import { assembleFactoryApiRoutes, buildIntegrationContext } from "./routes/surface.js";
+import { TelemetryRoutes } from "./routes/telemetry.js";
+import { readFactorySessionScope, resolveFactorySessionAddress } from "./rules/binding-context.js";
+import { observeSessionRunEnd } from "./session/run-audit.js";
+import { FactoryFeedReader } from "./storage/domains/comments/feed-context.js";
+import { FactoryDecisionDispatcher } from "./rules/dispatcher.js";
+import { FactoryPhaseStateProcessor, reportMemorySettingsUnavailable } from "./rules/processor.js";
+import { createReviewSourceTool, resolveReviewSourceUiOrigin } from "./rules/review-source-tool.js";
+import { createTerminalStageCleanup } from "./rules/terminal-cleanup.js";
+import { createFactoryTransitionTools } from "./rules/tools.js";
+import { CallbackFactorySandbox } from "./sandbox/callback-factory-sandbox.js";
+import { SessionRetirementCoordinator } from "./sandbox/session-retirement.js";
+import { handleServerError } from "./server-error.js";
+import { hydrateSessionDefaultModel } from "./session/default-model-hydration.js";
+import { observeSessionFirstMessage } from "./session/first-message-capture.js";
+import { LiveSessions } from "./session/live-sessions.js";
+import { createSourceControlTools } from "./session/source-control-tools.js";
+import { observeSessionThreadTitle } from "./session/thread-title-mirror.js";
+import { createSpaStaticMiddleware, resolveUiDistDir } from "./spa-static.js";
+import { createStateSigner } from "./state-signing.js";
+import { observeAgentGitAction } from "./storage/domains/audit/agent-audit.js";
+import { ChannelIdentityStorage } from "./storage/domains/channel-identity/base.js";
+import { WorkItemCommentsStorage } from "./storage/domains/comments/base.js";
+import { CommentsDomain } from "./storage/domains/comments/domain.js";
+import { CustomProvidersStorage } from "./storage/domains/custom-providers/base.js";
+import { FilesystemStorage } from "./storage/domains/filesystem/base.js";
+import { IntegrationStorage } from "./storage/domains/integrations/base.js";
+import { ModelDefaultsStorage } from "./storage/domains/model-defaults/base.js";
+import { FactorySupervisorHealthWorker } from "./supervisor/health-worker.js";
+import { SUPERVISOR_INSTRUCTIONS } from "./supervisor/instructions.js";
+import { createFactorySupervisorReadTools } from "./supervisor/read-tools.js";
+import { messageWorkerSession } from "./supervisor/session-messaging.js";
+import { createFactorySupervisorWriteTools } from "./supervisor/write-tools.js";
+import { hasAuthInit, isUserProvider } from "@mastra/core/server";
+import { MastraAuthStudio } from "@mastra/auth-studio";
+import { prepareAgentControllerMount } from "@mastra/code-sdk";
+import { AgentControllerChannels } from "@mastra/core/channels";
+import { EventEmitterPubSub } from "@mastra/core/events";
+import { describeFactorySandbox, isFactorySandbox } from "@mastra/core/workspace";
+//#region src/factory.ts
+/**
+* `MastraFactory` — the single entry point to the whole Mastra Software Factory.
+*
+* The consumer's deploy entry constructs deployment-specific config instances
+* (auth adapter, pubsub) and passes them here explicitly. The only provider
+* defaults constructed here are Platform GitHub, GitLab, Jira, incident.io, and
+* Linear integrations when Platform credentials exist and the caller did not
+* provide those integrations.
+*
+* `prepare()` resolves feature readiness, threads every dependency explicitly,
+* assembles the web routes/middleware, and returns the constructor args for
+* `new Mastra(...)`. The literal `export const mastra = new Mastra(...)` must
+* stay in the entry file — the deployer's `checkConfigExport` Babel plugin
+* only marks the config valid when it finds that literal in the entry AST —
+* so the factory produces args instead of the instance. `finalize()` runs the
+* post-construct boot (controller init + workers).
+*
+* Integration readiness is derived from each instance's declared capabilities
+* and the storage domains those capabilities require.
+*/
+const CONTROLLER_ID = "code";
+function hasPlatformCredentials() {
+	return Boolean(process.env.MASTRA_PLATFORM_ACCESS_TOKEN?.trim() || process.env.MASTRA_PLATFORM_SECRET_KEY?.trim());
+}
+/**
+* Default auth provider — `MastraAuthStudio`, which proxies identity to the
+* shared Mastra platform API. `MastraAuthStudio` resolves `MASTRA_SHARED_API_URL`,
+* `MASTRA_ORGANIZATION_ID`, and `MASTRA_COOKIE_DOMAIN` from env on its own —
+* this helper only derives a cookie-domain fallback from the factory's
+* `publicUrl`.
+*
+* Cookie-domain resolution (Studio picks the first that wins):
+*   1. explicit `MASTRA_COOKIE_DOMAIN` env, if set;
+*   2. `.mastra.ai` when `sharedApiUrl` is on `.mastra.ai`;
+*   3. this parent-domain fallback derived from `publicUrl` — so a deploy on
+*      `https://foo.mastra.cloud` mints cookies with `Domain=.mastra.cloud`
+*      without the caller wiring the env var by hand.
+*   4. otherwise host-only (no `Domain=`), which is correct for `localhost`.
+*/
+function buildDefaultStudioAuth(publicUrl) {
+	return new MastraAuthStudio({ cookieDomain: parentDomainFromPublicUrl(publicUrl) });
+}
+/**
+* Derive a parent cookie domain from `publicUrl` by stripping the leftmost
+* label — the same shape platform-API's env injection uses (see
+* `platform/servers/api/src/lib/studio-env-vars.ts`: `.${routingDomain.replace(/^[^.]+\./, '')}`).
+*
+* Rather than a generic `strip-left-label` heuristic — which either emits
+* cookies scoped to a public suffix (`sub.example.co.uk` → `.example.co.uk`
+* requires PSL data to be safe) or misclassifies numeric hostnames like
+* `3scale.example.com` as IPv4 — we only derive a parent domain when the
+* host sits under one of the platform's known registrable domains. Anything
+* else (custom domains, arbitrary tenant hostnames, IPs, `localhost`)
+* falls through to host-only cookies. Callers that need a different scope
+* pass `MASTRA_COOKIE_DOMAIN` explicitly (Studio honors that first).
+*/
+const KNOWN_PLATFORM_COOKIE_PARENTS = ["mastra.cloud", "mastra.ai"];
+function isIpLiteral(hostname) {
+	if (hostname.includes(":")) return true;
+	return /^\d+(?:\.\d+){3}$/.test(hostname);
+}
+function parentDomainFromPublicUrl(publicUrl) {
+	let hostname;
+	try {
+		hostname = new URL(publicUrl).hostname.toLowerCase();
+	} catch {
+		return;
+	}
+	if (hostname === "localhost" || isIpLiteral(hostname)) return void 0;
+	for (const parent of KNOWN_PLATFORM_COOKIE_PARENTS) {
+		if (hostname === parent) return void 0;
+		if (hostname.endsWith(`.${parent}`)) return `.${parent}`;
+	}
+}
+/** A session parking or being answered is inbox news, so the registry bumps the project's feed. */
+function liveSessionsTouchingTheFeed(controller, eventBus) {
+	const liveSessions = new LiveSessions(controller);
+	liveSessions.onParkedChanged((session) => {
+		const { factoryOrgId, factoryProjectId } = session.state.get();
+		if (factoryOrgId && factoryProjectId) touchFeed(eventBus, {
+			orgId: factoryOrgId,
+			factoryProjectId
+		});
+	});
+	return liveSessions;
+}
+/**
+* The fleet-era `sandbox` options and what replaced each one. Only the keys
+* the host actually passed are explained, so a host that never used the fleet
+* gets the short message.
+*/
+const RETIRED_SANDBOX_OPTIONS = {
+	machine: "'machine' becomes the provider instance: one sandbox per session, constructed by the FactorySandbox, instead of one template machine cloned per repository",
+	workdir: "'workdir' becomes the workingDirectory of the FactorySandboxContext, which every provider passes to its sandbox; when it is absent the provider uses its own default",
+	maxSandboxes: "'maxSandboxes' is gone with the sandbox fleet: there is one sandbox per session and no pool to cap"
+};
+function invalidSandboxOptionMessage(option) {
+	const lines = [
+		`MastraFactory: 'sandbox' must be a FactorySandbox instance or a callback constructing a MastraSandbox from a FactorySandboxContext:`,
+		`  sandbox: new PlatformFactorySandbox()`,
+		`  sandbox: ctx => new PlatformSandbox({ id: ctx.sessionId, sandboxId: ctx.sandboxId })`
+	];
+	if (typeof option === "object" && option !== null) {
+		const retired = Object.keys(RETIRED_SANDBOX_OPTIONS).filter((key) => key in option);
+		if (retired.length > 0) {
+			lines.push(`The object you passed is the retired alpha sandbox config. Its options map as follows:`);
+			for (const key of retired) lines.push(`  ${RETIRED_SANDBOX_OPTIONS[key]}.`);
+		}
+	}
+	return lines.join("\n");
+}
+var MastraFactory = class {
+	#config;
+	/** The normalized sandbox, set by `prepare()`. Undefined until then and when sandboxes are disabled. */
+	#sandbox;
+	#sandboxDescription;
+	#boards;
+	#configVersion;
+	#prepared;
+	#dispatcher;
+	#factoryProcessor;
+	/** Environment builds through the sandbox's `builds`; undefined when the sandbox has none. */
+	#environmentBuilds;
+	#preparing = false;
+	constructor(config) {
+		if (!config?.storage) throw new Error("MastraFactory: 'storage' is required. Pass a FactoryStorage backend — e.g. new PgFactoryStorage({ connectionString }) from '@mastra/pg' for deployments, or new LibSQLFactoryStorage({ url }) from '@mastra/libsql' for local dev.");
+		this.#boards = createBoardRegistry({
+			boards: config.boards,
+			includeDefaultBoards: config.includeDefaultBoards
+		});
+		if ("rules" in config) throw new Error("MastraFactory: 'rules' was removed. Set 'configVersion' for the audit label and declare tool-result rules on the owning board via defineBoard({ tools }).");
+		this.#configVersion = assertFactoryConfigVersion(config.configVersion ?? "factory-config-v1");
+		this.#config = config;
+	}
+	/**
+	* The host sandbox's provider, settings schema (JSON Schema) and
+	* capabilities, as the environment route reports them. Undefined before
+	* `prepare()` and when sandboxes are disabled.
+	*/
+	get sandboxDescription() {
+		if (!this.#sandbox) return void 0;
+		this.#sandboxDescription ??= describeFactorySandbox(this.#sandbox);
+		return this.#sandboxDescription;
+	}
+	/**
+	* Resolve feature readiness, wire every dependency explicitly, and assemble
+	* everything needed to construct the server-owned Mastra. Returns the args
+	* for the `new Mastra(...)` literal that must live in the entry file.
+	*/
+	async prepare() {
+		if (this.#preparing) throw new Error("MastraFactory.prepare() called twice");
+		this.#preparing = true;
+		const publicOrigin = (this.#config.publicUrl ?? "http://localhost:4111").replace(/\/+$/, "");
+		const allowedOrigins = (this.#config.allowedOrigins ?? []).map((o) => o.replace(/\/+$/, "")).filter(Boolean);
+		const storage = this.#config.storage;
+		const vector = this.#config.vector;
+		const pubsub = this.#config.pubsub;
+		const eventBus = pubsub ?? new EventEmitterPubSub();
+		const configuredAuth = this.#config.auth;
+		const auth = configuredAuth === null ? void 0 : configuredAuth ?? buildDefaultStudioAuth(publicOrigin);
+		if (auth && !this.#config.secretEncryption) console.warn("[factory] auth is enabled but 'secretEncryption' is not configured. Persisted model credentials, custom-provider API keys, and integration secrets will be stored as plaintext. Provide 'secretEncryption' (e.g. via FACTORY_CREDENTIAL_ENCRYPTION_KEY) to encrypt them at rest.");
+		const secretEncryption = this.#config.secretEncryption ?? createPlaintextFactorySecretEncryption();
+		const deploymentModelProviders = resolveDeploymentModelProviders(this.#config.deploymentModelProviders);
+		const routeAuth = createFactoryRouteAuth(auth);
+		const integrations = [...this.#config.integrations ?? []];
+		const explicitGithub = integrations.some((integration) => integration.id === "github");
+		let installedPlatformGithub = false;
+		if (hasPlatformCredentials()) {
+			if (!explicitGithub) {
+				integrations.push(new PlatformGithubIntegration({
+					rules: this.#config.platform?.github?.rules,
+					slug: this.#config.platform?.github?.slug ?? this.#config.platform?.githubAppSlug
+				}));
+				installedPlatformGithub = true;
+			}
+			if (!integrations.some((integration) => integration.id === "incidentio")) integrations.push(new PlatformIncidentioIntegration());
+			if (!integrations.some((integration) => integration.id === "jira")) integrations.push(new PlatformJiraIntegration());
+			if (!integrations.some((integration) => integration.id === "gitlab")) integrations.push(new PlatformGitLabIntegration());
+			if (!integrations.some((integration) => integration.id === "linear")) integrations.push(new PlatformLinearIntegration());
+		}
+		if (this.#config.platform?.github && !installedPlatformGithub) console.warn("[factory] 'platform.github' config was provided but the factory installed no GitHub integration of its own " + (explicitGithub ? "(an explicit integration with id 'github' takes precedence, so these options were ignored)." : "(no Platform credentials are configured and no explicit GitHub integration was passed)."));
+		const integrationIds = /* @__PURE__ */ new Set();
+		for (const integration of integrations) {
+			if (integrationIds.has(integration.id)) throw new Error(`MastraFactory: duplicate integration id '${integration.id}' in 'integrations'.`);
+			integrationIds.add(integration.id);
+		}
+		const configVersion = this.#configVersion;
+		const intakeStorage = storage.registerDomain(new IntakeStorage());
+		const auditStorage = storage.registerDomain(new AuditStorage());
+		const workItemsStorage = storage.registerDomain(new WorkItemsStorage());
+		workItemsStorage.onAttentionChanged((scope) => touchFeed(eventBus, scope));
+		workItemsStorage.useTerminalPhasePredicate((item) => isTerminalWorkItem(this.#boards, item));
+		const modelCredentialsStorage = storage.registerDomain(new ModelCredentialsStorage(secretEncryption));
+		const modelDefaultsStorage = storage.registerDomain(new ModelDefaultsStorage());
+		const memorySettingsStorage = storage.registerDomain(new MemorySettingsStorage());
+		const customProvidersStorage = storage.registerDomain(new CustomProvidersStorage(secretEncryption));
+		const queueHealthStorage = storage.registerDomain(new QueueHealthStorage());
+		const integrationStorage = storage.registerDomain(new IntegrationStorage(secretEncryption));
+		const factoryProjectsStorage = storage.registerDomain(new FactoryProjectsStorage());
+		const filesystemStorage = storage.registerDomain(new FilesystemStorage());
+		const sourceControlStorage = storage.registerDomain(new SourceControlStorage());
+		const channelIdentityStorage = storage.registerDomain(new ChannelIdentityStorage());
+		const workItemCommentsStorage = storage.registerDomain(new WorkItemCommentsStorage());
+		const domains = {
+			intake: intakeStorage,
+			modelCredentials: modelCredentialsStorage,
+			modelDefaults: modelDefaultsStorage,
+			memorySettings: memorySettingsStorage,
+			customProviders: customProvidersStorage,
+			filesystem: filesystemStorage,
+			projects: factoryProjectsStorage,
+			queueHealth: queueHealthStorage,
+			workItems: workItemsStorage,
+			channelIdentity: channelIdentityStorage,
+			comments: workItemCommentsStorage
+		};
+		const auditDomain = new AuditDomain({
+			auth: routeAuth,
+			audit: auditStorage,
+			projects: factoryProjectsStorage,
+			users: auth && isUserProvider(auth) ? auth : void 0,
+			sinks: integrations,
+			agentTenant: (requestContext) => {
+				const user = getFactoryAuthUserFromContext(requestContext);
+				return {
+					orgId: getFactoryAuthOrgId(user),
+					userId: getFactoryAuthUserId(user)
+				};
+			}
+		});
+		const feedPublishers = [];
+		const commentsDomain = new CommentsDomain({
+			auth: routeAuth,
+			comments: workItemCommentsStorage,
+			workItems: workItemsStorage,
+			projects: factoryProjectsStorage,
+			channelIdentity: channelIdentityStorage,
+			audit: auditDomain,
+			publishers: feedPublishers,
+			pubsub: eventBus
+		});
+		const sandboxOption = this.#config.sandbox;
+		let sandboxConfig;
+		if (sandboxOption === void 0 || isFactorySandbox(sandboxOption)) sandboxConfig = sandboxOption;
+		else if (typeof sandboxOption === "function") sandboxConfig = new CallbackFactorySandbox(sandboxOption);
+		else throw new Error(invalidSandboxOptionMessage(sandboxOption));
+		this.#sandbox = sandboxConfig;
+		const workspaceRegistry = new FactoryWorkspaceRegistry();
+		const stateSigner = createStateSigner(this.#config.stateSecret);
+		if (auth && hasAuthInit(auth)) await timedPhase("prepare.auth.init", () => auth.init({
+			database: storage.authDatabase?.(),
+			publicUrl: publicOrigin,
+			allowedOrigins
+		}));
+		await timedPhase("prepare.storage.init", () => storage.init());
+		registerCustomProvidersSource({
+			storage: customProvidersStorage,
+			authEnabled: Boolean(auth)
+		});
+		for (const integration of integrations) {
+			const integrationSourceControl = integration.versionControl ? sourceControlStorage.forIntegration(integration.id) : void 0;
+			integration.initialize?.({
+				storage: integrationStorage.forIntegration(integration.id),
+				projects: factoryProjectsStorage,
+				auth: routeAuth,
+				intake: intakeStorage,
+				...integrationSourceControl ? { sourceControl: integrationSourceControl } : {}
+			});
+			if (integration.versionControl && integrationSourceControl) integration.versionControl.initialize({ storage: integrationSourceControl });
+		}
+		const sourceControlSessions = createSourceControlSessionLookup([.../* @__PURE__ */ new Set(["github", ...integrations.filter((integration) => integration.versionControl).map(({ id }) => id)])].map((id) => sourceControlStorage.forIntegration(id)));
+		if (auth) registerTenantCredentialResolver(modelCredentialsStorage, deploymentModelProviders, (requestContext) => resolveFactoryCredentialTenant(requestContext, {
+			projects: factoryProjectsStorage,
+			sourceControl: sourceControlSessions,
+			workItems: workItemsStorage
+		}));
+		const integrationRegistrations = integrations.map((integration) => {
+			const requiredDomains = [
+				"integrations",
+				...integration.versionControl ? ["source-control"] : [],
+				...integration.channels ? ["channel-identity"] : []
+			];
+			return {
+				integration,
+				ready: requiredDomains.every((domain) => storage.isDomainReady(domain)),
+				ensureReady: async () => {
+					for (const domain of requiredDomains) await storage.ensureDomainReady(domain);
+				}
+			};
+		});
+		const intakeReady = integrations.some((integration) => integration.intake !== void 0) && storage.isDomainReady("intake");
+		const factoryReady = storage.isDomainReady("projects") && storage.isDomainReady("work-items");
+		const knowledgeEnabled = this.#config.knowledge !== void 0 || process.env.MASTRACODE_EXPERIMENTAL_SUBCONSCIOUS === "1";
+		const deploymentOrganizationId = process.env.MASTRACODE_DEPLOYMENT_ORGANIZATION_ID?.trim() || void 0;
+		const githubIntegration = integrations.find((integration) => integration.id === "github");
+		const gitlabIntegration = integrations.find((integration) => integration.id === "gitlab" && integration.intake && integration.versionControl);
+		const workItemsReady = storage.isDomainReady("work-items");
+		const sessionRetirement = sandboxConfig && storage.isDomainReady("source-control") ? new SessionRetirementCoordinator({ invalidateSession: (sessionId) => workspaceRegistry.invalidateSession(sessionId) }) : void 0;
+		const retireTerminalSessions = sessionRetirement && workItemsReady ? async ({ orgId, workItemId }) => {
+			const item = await workItemsStorage.get({
+				orgId,
+				id: workItemId
+			});
+			if (!item) return;
+			const sessionIds = [...new Set(Object.values(item.sessions).map((session) => session.sessionId))];
+			await Promise.all(sessionIds.map(async (sessionId) => {
+				const sourceControl = await sourceControlSessions.getSourceControlBySessionId(sessionId);
+				if (!sourceControl) return;
+				await sessionRetirement.retireSession({
+					sourceControl,
+					orgId,
+					sessionId,
+					deleteSession: false
+				});
+			}));
+		} : void 0;
+		const terminalCleanup = workItemsReady ? createTerminalStageCleanup({
+			workItems: workItemsStorage,
+			reconcileBinding: async (binding) => {
+				await factoryProcessor?.reconcileBinding(binding);
+			},
+			abortSession: async (binding) => {
+				const controller = this.#prepared?.base.controller;
+				if (!controller) return;
+				const session = await controller.getSessionByResource(binding.resourceId);
+				if (session?.stream.isActive()) session.abort();
+			},
+			...retireTerminalSessions ? { releaseSandboxes: retireTerminalSessions } : {}
+		}) : void 0;
+		const onTerminalStage = terminalCleanup ? (args) => terminalCleanup({
+			orgId: args.orgId,
+			factoryProjectId: args.factoryProjectId,
+			workItemId: args.workItemId,
+			revision: args.revision,
+			...args.actor.type === "agent" ? { initiatingBindingId: args.actor.bindingId } : {}
+		}) : retireTerminalSessions;
+		const transitionService = workItemsReady ? new FactoryTransitionService({
+			configVersion,
+			boards: this.#boards,
+			storage: workItemsStorage,
+			audit: auditDomain,
+			autoApprovePlans: async ({ orgId, factoryProjectId }) => {
+				await factoryProjectsStorage.ensureReady();
+				return (await factoryProjectsStorage.get({
+					orgId,
+					id: factoryProjectId
+				}))?.autoApprovePlans ?? false;
+			},
+			...onTerminalStage ? { onTerminalStage } : {},
+			...githubIntegration ? { onAccepted: (args) => reconcileGithubAcceptanceLabels(githubIntegration, sourceControlStorage.forIntegration(githubIntegration.id), args) } : {}
+		}) : void 0;
+		this.#environmentBuilds = this.#sandbox?.builds ? new EnvironmentBuildRunner({
+			sandbox: this.#sandbox,
+			projects: factoryProjectsStorage,
+			sourceControl: githubIntegration?.versionControl ? {
+				storage: sourceControlStorage.forIntegration(githubIntegration.id),
+				versionControl: githubIntegration.versionControl
+			} : void 0,
+			logger: { info: (msg, meta) => console.info(`[Mastra Factory] ${msg}`, meta ?? {}) }
+		}, { getMastra: () => this.#prepared?.base.controller.getMastra() }) : void 0;
+		const environmentBuilds = this.#environmentBuilds;
+		const projectRoutes = new ProjectRoutes({
+			auth: routeAuth,
+			sandbox: this.#sandbox,
+			...environmentBuilds ? { environmentBuilds } : {},
+			projects: factoryProjectsStorage,
+			sourceControl: sourceControlStorage,
+			versionControlIntegrationIds: integrations.filter((integration) => integration.versionControl).map((integration) => integration.id),
+			...githubIntegration || gitlabIntegration ? { resolveRepository: async ({ integrationId, orgId, userId, installationId, externalId, slug }) => {
+				if (githubIntegration && integrationId === githubIntegration.id) {
+					const installation = await githubIntegration.sourceControlStorage.installations.get({
+						orgId,
+						id: installationId
+					});
+					if (!installation) return null;
+					const selected = (await githubIntegration.listInstallationRepos(Number(installation.externalId))).find((repo) => repo.id.toString() === externalId && repo.fullName === slug);
+					if (!selected) return null;
+					return githubIntegration.sourceControlStorage.repositories.upsert({
+						orgId,
+						input: {
+							installationId,
+							externalId,
+							slug: selected.fullName,
+							defaultBranch: isValidGitRef(selected.defaultBranch) ? selected.defaultBranch : "main",
+							providerMetadata: {
+								private: selected.private,
+								owner: selected.owner
+							}
+						}
+					});
+				}
+				if (!gitlabIntegration?.intake || !gitlabIntegration.versionControl || integrationId !== gitlabIntegration.id) return null;
+				const installation = await sourceControlStorage.forIntegration(gitlabIntegration.id).installations.get({
+					orgId,
+					id: installationId
+				});
+				if (!installation) return null;
+				const selected = (await gitlabIntegration.intake.listSources({
+					orgId,
+					userId
+				})).find((source) => source.name === slug && typeof source.metadata?.projectId === "string" && source.metadata.projectId === externalId && source.metadata.connectionId === installation.externalId);
+				if (!selected) return null;
+				const [repository] = await gitlabIntegration.versionControl.registerRepositories({
+					orgId,
+					installationId,
+					repositories: [{
+						externalId,
+						slug,
+						defaultBranch: typeof selected.metadata?.defaultBranch === "string" && isValidGitRef(selected.metadata.defaultBranch) ? selected.metadata.defaultBranch : "main",
+						metadata: selected.metadata
+					}]
+				});
+				return repository ?? null;
+			} } : {},
+			...typeof githubIntegration?.ingestLinkedRepositoryBacklog === "function" ? { onProjectRepositoryLinked: ({ orgId, projectRepository }) => {
+				githubIntegration.ingestLinkedRepositoryBacklog({
+					orgId,
+					projectRepositoryId: projectRepository.id
+				}).catch((error) => {
+					console.warn("[factory] Failed to import a linked repository backlog:", error);
+				});
+			} } : {},
+			...sessionRetirement ? { sessionRetirement } : {},
+			...workItemsReady ? {
+				workItems: workItemsStorage,
+				controller: { getSessionByResource: async (resourceId) => this.#prepared?.base.controller.getSessionByResource(resourceId) }
+			} : {}
+		});
+		const loadMemorySettings = async ({ requestContext, binding }) => {
+			if (!requestContext) return;
+			const scope = readFactorySessionScope(requestContext);
+			const user = getFactoryAuthUserFromContext(requestContext);
+			const callerUserId = getFactoryAuthUserId(user);
+			const callerOrgId = factoryUserOrgId(user);
+			const factoryProjectId = binding?.factoryProjectId ?? scope?.factoryProjectId;
+			const target = factoryProjectId ? {
+				orgId: binding?.orgId ?? scope?.factoryOrgId ?? callerOrgId ?? "local",
+				userId: factoryMemorySettingsUserId(factoryProjectId)
+			} : callerUserId && callerOrgId ? {
+				orgId: callerOrgId,
+				userId: callerUserId
+			} : {
+				orgId: "local",
+				userId: "local"
+			};
+			const record = await memorySettingsStorage.get(target);
+			let personal = null;
+			if (factoryProjectId && requestContext.get("channel") && callerUserId && callerOrgId) try {
+				personal = await memorySettingsStorage.get({
+					orgId: callerOrgId,
+					userId: callerUserId
+				});
+			} catch (error) {
+				console.warn("[Factory Memory Settings] Unable to read the sender's memory settings", { error: error instanceof Error ? error.message : String(error) });
+			}
+			requestContext.set("mastra__factoryMemorySettings", layerPersonalMemorySettings(record, personal));
+		};
+		const factoryProcessor = workItemsReady ? new FactoryPhaseStateProcessor({
+			configVersion,
+			storage: workItemsStorage,
+			boards: this.#boards,
+			loadMemorySettings,
+			...transitionService ? { transitionService } : {},
+			...githubIntegration ? { recordPullRequestProvenance: (input) => recordFactoryPullRequestProvenance(githubIntegration, sourceControlStorage.forIntegration("github"), integrationStorage.forIntegration("github"), workItemsStorage, input) } : {},
+			messageReader: { listMessages: async (input) => {
+				const memory = await storage.getMastraStorage().getStore("memory");
+				return memory ? memory.listMessages(input) : {
+					messages: [],
+					hasMore: false
+				};
+			} }
+		}) : void 0;
+		for (const { integration } of integrationRegistrations) if (integration.requiresStableStateSigner && !stateSigner.stable) throw new Error(`MastraFactory: integration '${integration.id}' signs OAuth state and requires a replica-stable state secret, but none is configured. Set 'stateSecret' on the factory config.`);
+		const mastraStorageBackend = (() => {
+			for (let proto = Object.getPrototypeOf(storage); proto; proto = Object.getPrototypeOf(proto)) {
+				if (proto.constructor?.name === "PgFactoryStorage") return "pg";
+				if (proto.constructor?.name === "LibSQLFactoryStorage") return "libsql";
+			}
+		})();
+		const toolIntegrations = integrationRegistrations.filter(({ integration }) => integration.agentTools || integration.sessionTools);
+		const sourceControlToolProviders = integrations.flatMap((integration) => integration.versionControl ? [{
+			id: integration.id,
+			versionControl: integration.versionControl,
+			storage: sourceControlStorage.forIntegration(integration.id)
+		}] : []);
+		const prepared = await timedPhase("prepare.controllerMount", () => prepareAgentControllerMount({
+			controllerId: CONTROLLER_ID,
+			coAuthor: { name: "mastra-platform[bot]" },
+			...this.#config.disableBuiltinTools?.length ? { disableBuiltinTools: this.#config.disableBuiltinTools } : {},
+			modes: false,
+			workspace: createWorkspaceFactory({
+				...sandboxConfig ? { sandbox: sandboxConfig } : {},
+				...this.#config.sandboxStart ? { sandboxStart: this.#config.sandboxStart } : {},
+				sourceControls: integrations.flatMap((integration) => integration.versionControl ? [{
+					id: integration.id,
+					versionControl: integration.versionControl,
+					storage: sourceControlStorage.forIntegration(integration.id),
+					...integration.id === "github" && githubIntegration ? { github: githubIntegration } : {}
+				}] : []),
+				...factoryProjectsStorage ? { projects: factoryProjectsStorage } : {},
+				...workItemsStorage ? { workItems: workItemsStorage } : {},
+				workspaceRegistry
+			}),
+			disableGithubSignals: true,
+			prepareWakeRequestContext: async ({ requestContext, resourceId }) => {
+				if (!storage.isDomainReady("source-control")) return;
+				await prepareSessionRunContext(requestContext, resourceId, { sessions: sourceControlSessions });
+			},
+			disableSettingsOmSeed: true,
+			hostInstructions: async ({ requestContext }) => {
+				const context = requestContext.get("controller");
+				if (parseSupervisorResourceId(context?.resourceId)) return SUPERVISOR_INSTRUCTIONS;
+				if (context?.threadId && context.resourceId) {
+					const current = context.getState();
+					if (!(Boolean(current.factoryProjectId) && Boolean(current.factoryOrgId) && typeof current.untrustedCheckout === "boolean")) {
+						const recovered = await resolveFactorySessionAddress({
+							requestContext,
+							storage: workItemsStorage,
+							forceBindingLookup: true,
+							...storage.isDomainReady("source-control") ? { sessions: sourceControlSessions } : {}
+						});
+						if (recovered?.binding) {
+							const state = context.getState();
+							if (state.factoryProjectId !== recovered.binding.factoryProjectId || recovered.binding.role === "review" && state.untrustedCheckout !== true) throw new Error("Factory review session security state could not be restored before prompt creation.");
+						}
+					}
+				}
+			},
+			initialState: {
+				skipGlobalInstructions: true,
+				factoryOrgUnresolved: true,
+				projectPath: "",
+				projectName: "",
+				gitBranch: ""
+			},
+			storage: storage.getMastraStorage(),
+			...mastraStorageBackend ? { storageBackend: mastraStorageBackend } : {},
+			...this.#config.knowledge ? { knowledge: this.#config.knowledge } : {},
+			inputProcessors: async ({ requestContext }) => {
+				const environmentProcessor = new FactoryEnvironmentStateProcessor();
+				if (factoryProcessor) {
+					await factoryProcessor.prepareMemorySettings(requestContext);
+					return [environmentProcessor, factoryProcessor];
+				}
+				try {
+					await loadMemorySettings({
+						requestContext,
+						binding: null
+					});
+				} catch (error) {
+					reportMemorySettingsUnavailable(requestContext, error instanceof Error ? error.message : String(error));
+				}
+				return [environmentProcessor];
+			},
+			...vector ? { vector } : {},
+			...toolIntegrations.length > 0 || sourceControlToolProviders.length > 0 || workItemsStorage && transitionService ? { extraTools: async ({ requestContext }) => {
+				const tools = {};
+				const toolOwners = /* @__PURE__ */ new Map();
+				const mergeTools = (ownerId, contributed) => {
+					for (const [name, tool] of Object.entries(contributed)) {
+						const owner = toolOwners.get(name);
+						if (owner) throw new Error(`MastraFactory: integration tool '${name}' from '${ownerId}' conflicts with '${owner}'.`);
+						toolOwners.set(name, ownerId);
+						tools[name] = tool;
+					}
+				};
+				if (storage.isDomainReady("source-control")) mergeTools("source-control", await createSourceControlTools({
+					requestContext,
+					providers: sourceControlToolProviders,
+					audit: auditDomain
+				}));
+				if (workItemsStorage && transitionService) {
+					mergeTools("factory", await createFactoryTransitionTools({
+						requestContext,
+						storage: workItemsStorage,
+						transitionService,
+						boards: this.#boards,
+						...storage.isDomainReady("source-control") ? { sessions: sourceControlSessions } : {}
+					}));
+					const reviewSourceUiOrigin = resolveReviewSourceUiOrigin(process.env.MASTRACODE_PUBLIC_URL);
+					mergeTools("factory-review-source", await createReviewSourceTool({
+						requestContext,
+						storage: workItemsStorage,
+						uiOrigin: reviewSourceUiOrigin,
+						...storage.isDomainReady("source-control") ? { sessions: sourceControlSessions } : {}
+					}));
+					const supervisorScope = await resolveSupervisorScope({
+						requestContext,
+						projects: factoryProjectsStorage
+					});
+					if (supervisorScope) {
+						const userId = getFactoryAuthUserId(getFactoryAuthUserFromContext(requestContext));
+						mergeTools("factory-supervisor", createFactorySupervisorReadTools({
+							scope: supervisorScope,
+							workItems: workItemsStorage,
+							boards: this.#boards,
+							comments: workItemCommentsStorage,
+							audit: auditStorage,
+							messageReader: { listMessages: async (input) => {
+								const memory = await storage.getMastraStorage().getStore("memory");
+								return memory ? memory.listMessages(input) : {
+									messages: [],
+									hasMore: false
+								};
+							} }
+						}));
+						if (userId) mergeTools("factory-supervisor-write", createFactorySupervisorWriteTools({
+							scope: supervisorScope,
+							userId,
+							workItems: workItemsStorage,
+							boards: this.#boards,
+							audit: auditDomain,
+							transitionService,
+							...githubIntegration ? { reconcileAcceptanceLabels: (args) => reconcileGithubAcceptanceLabels(githubIntegration, sourceControlStorage.forIntegration(githubIntegration.id), args) } : {},
+							messageSession: ({ sessionId, message, delivery }) => messageWorkerSession({
+								controller: prepared.base.controller,
+								sessionId,
+								message,
+								delivery,
+								...requestContext ? { requestContext } : {}
+							})
+						}));
+					}
+				}
+				for (const { integration, ready, ensureReady } of toolIntegrations) {
+					if (!ready && ensureReady) try {
+						await ensureReady();
+					} catch {
+						continue;
+					}
+					if (integration.agentTools) mergeTools(integration.id, await integration.agentTools({ requestContext }));
+					if (integration.sessionTools) mergeTools(integration.id, integration.sessionTools({ requestContext }));
+				}
+				return tools;
+			} } : {},
+			postToolObserver: async (toolContext) => {
+				const requestContext = toolContext.context?.requestContext;
+				if (requestContext) await observeAgentGitAction({
+					audit: auditDomain,
+					toolContext: {
+						...toolContext,
+						context: requestContext
+					},
+					resolveRepositorySlugs: async (sessionId) => {
+						for (const provider of sourceControlToolProviders) {
+							const session = await provider.storage.sessions.getBySessionId(sessionId);
+							if (!session) continue;
+							return environmentSlugs(await resolveSessionRepositories({
+								sourceControl: provider.storage,
+								session
+							}));
+						}
+						return [];
+					}
+				});
+				await Promise.all(integrations.map(async (integration) => {
+					if (!integration.postToolObserver) return;
+					try {
+						await integration.postToolObserver({
+							toolContext,
+							requestContext
+						});
+					} catch (error) {
+						console.warn(`[factory] Integration '${integration.id}' post-tool observer failed:`, error);
+					}
+				}));
+			},
+			...pubsub ? {
+				pubsub,
+				crossProcessPubSub: true
+			} : {},
+			buildApiRoutes: ({ controller, authStorage }) => [
+				...auth ? buildAuthRoutes(auth, { publicUrl: publicOrigin }) : buildAuthDisabledRoutes(),
+				...new TelemetryRoutes({
+					auth: routeAuth,
+					providerName: auth?.name,
+					publicOrigin,
+					allowedOrigins
+				}).routes(),
+				...assembleFactoryApiRoutes({
+					controllerId: CONTROLLER_ID,
+					controller,
+					liveSessions: liveSessionsTouchingTheFeed(controller, eventBus),
+					auth: routeAuth,
+					...auth && isUserProvider(auth) ? { users: auth } : {},
+					authStorage,
+					audit: auditDomain,
+					publicOrigin,
+					stateSigner,
+					sandbox: sandboxConfig,
+					...environmentBuilds ? { onRepositoryPush: environmentBuilds.onRepositoryPush } : {},
+					sessionRetirement,
+					factoryStorage: storage,
+					integrationStorage,
+					sourceControlStorage,
+					domains,
+					feed: commentsDomain,
+					integrations: integrationRegistrations,
+					intakeReady,
+					factoryReady,
+					knowledgeEnabled,
+					deploymentOrganizationId,
+					deploymentModelProviders,
+					knowledgeKey: this.#config.knowledge?.key,
+					configVersion,
+					boardRegistry: this.#boards,
+					factoryTransitionService: transitionService,
+					onFactoryRuntime: ({ transitionService: runtimeTransitionService, prepareBinding }) => {
+						this.#dispatcher ??= new FactoryDecisionDispatcher({
+							controller,
+							transitionService: runtimeTransitionService,
+							storage: storage.getDomain("work-items"),
+							audit: auditDomain,
+							boards: this.#boards,
+							maxInFlight: this.#config.dispatcher?.maxInFlight,
+							isAutoRunEnabled: async ({ orgId, factoryProjectId }) => {
+								await factoryProjectsStorage.ensureReady();
+								return (await factoryProjectsStorage.get({
+									orgId,
+									id: factoryProjectId
+								}))?.autoRunEnabled ?? false;
+							},
+							autoApprovePlans: async ({ orgId, factoryProjectId }) => {
+								await factoryProjectsStorage.ensureReady();
+								return (await factoryProjectsStorage.get({
+									orgId,
+									id: factoryProjectId
+								}))?.autoApprovePlans ?? false;
+							},
+							reconcileToolResults: () => factoryProcessor?.reconcileAllBoundThreads() ?? Promise.resolve(),
+							prepareBinding,
+							feedReader: new FactoryFeedReader(workItemCommentsStorage),
+							...githubIntegration ? { dismissStaleReviews: async (decision) => {
+								await dismissStaleFactoryReviews(githubIntegration.versionControl, decision, (login) => isFactoryGithubLogin(githubIntegration, login), (login) => trustedCollaborator(githubIntegration, {
+									installationId: decision.installationId,
+									repository: decision.repository,
+									login
+								}));
+							} } : {},
+							primeCredentials: (tenant) => primeTenantCredentials({
+								tenant,
+								credentials: modelCredentialsStorage
+							}),
+							resolveLinkedWorkItemParentId: async ({ orgId, factoryProjectId, decision }) => {
+								if (decision.source !== "github-pr") return null;
+								const repositoryId = decision.metadata?.githubRepositoryId;
+								const pullRequestNumber = decision.metadata?.githubPullRequestNumber;
+								if (typeof repositoryId !== "number" || typeof pullRequestNumber !== "number") return null;
+								return resolveFactoryPullRequestParentWorkItemId(integrationStorage.forIntegration("github"), {
+									orgId,
+									factoryProjectId,
+									repositoryId,
+									pullRequestNumber
+								});
+							}
+						});
+					}
+				}),
+				...projectRoutes.routes(),
+				...auditDomain.routes(),
+				...commentsDomain.routes(),
+				...hasPlatformCredentials() ? buildPlatformConnectRoutes({
+					auth: routeAuth,
+					client: new PlatformApiClient(platformApiClientConfigFromEnv())
+				}) : []
+			],
+			buildServerConfig: () => {
+				const cors = allowedOrigins.length ? { cors: {
+					origin: allowedOrigins,
+					credentials: true
+				} } : {};
+				const onError = { onError: handleServerError };
+				const uiDist = resolveUiDistDir();
+				const spa = uiDist ? [createSpaStaticMiddleware(uiDist)] : [];
+				if (!auth) return {
+					middleware: [createCustomProvidersPrimer({
+						auth: routeAuth,
+						storage: customProvidersStorage,
+						authEnabled: false
+					}), ...spa],
+					...cors,
+					...onError
+				};
+				return {
+					auth,
+					middleware: [
+						createFactoryAuthGate(auth),
+						createTenantCredentialPrimer({
+							auth: routeAuth,
+							credentials: modelCredentialsStorage
+						}),
+						createCustomProvidersPrimer({
+							auth: routeAuth,
+							storage: customProvidersStorage,
+							authEnabled: Boolean(auth)
+						}),
+						...spa
+					],
+					...cors,
+					...onError
+				};
+			}
+		}));
+		prepared.base.controller.onSessionCreated((session) => {
+			observeSessionFilesystem(session, {
+				filesystem: filesystemStorage,
+				sourceControl: { sessions: sourceControlSessions }
+			});
+			observeSessionFirstMessage(session, { sourceControl: { sessions: sourceControlSessions } });
+			observeSessionFirstExec(session, { sourceControl: { sessions: sourceControlSessions } });
+			observeSessionThreadTitle(session, { sourceControl: { sessions: sourceControlSessions } });
+			observeSessionRunEnd(session, { audit: auditDomain });
+		});
+		prepared.base.controller.onSessionCreated((session) => hydrateSupervisorSession(session, {
+			projects: factoryProjectsStorage,
+			modelDefaults: modelDefaultsStorage
+		}).catch((error) => {
+			console.warn("[Factory Supervisor] Failed to hydrate supervisor session", { error: error instanceof Error ? error.message : String(error) });
+		}), { blocking: true });
+		prepared.base.controller.onSessionCreated((session) => hydrateSessionMemorySettings(session, { sourceControl: { sessions: sourceControlSessions } }), { blocking: true });
+		prepared.base.controller.onSessionCreated((session) => hydrateSessionDefaultModel(session, {
+			sourceControl: sourceControlSessions,
+			projects: factoryProjectsStorage,
+			workItems: workItemsStorage,
+			modelDefaults: modelDefaultsStorage
+		}), { blocking: true });
+		this.#prepared = prepared;
+		this.#factoryProcessor = factoryProcessor;
+		const channelRegistrations = integrationRegistrations.filter(({ integration, ready }) => ready && integration.channels);
+		if (channelRegistrations.length > 1) throw new Error(`MastraFactory: integrations [${channelRegistrations.map(({ integration }) => integration.id).join(", ")}] all provide channels, but only one may. Remove all but one.`);
+		for (const { integration } of channelRegistrations) {
+			const context = buildIntegrationContext({
+				controller: prepared.base.controller,
+				publicOrigin,
+				auth: routeAuth,
+				stateSigner,
+				sandbox: sandboxConfig,
+				factoryStorage: storage,
+				integrationStorage,
+				sourceControlStorage,
+				integrations: integrationRegistrations,
+				configVersion,
+				boardRegistry: this.#boards,
+				factoryReady,
+				domains,
+				feed: commentsDomain,
+				...githubIntegration ? { sourceControlOwnerId: "github" } : {}
+			}, integration.id);
+			prepared.base.controller.setChannels(new AgentControllerChannels(integration.channels(context)));
+		}
+		for (const { integration } of integrationRegistrations.filter(({ integration, ready }) => ready && integration.feedPublisher)) {
+			const context = buildIntegrationContext({
+				controller: prepared.base.controller,
+				publicOrigin,
+				auth: routeAuth,
+				stateSigner,
+				sandbox: sandboxConfig,
+				factoryStorage: storage,
+				integrationStorage,
+				sourceControlStorage,
+				integrations: integrationRegistrations,
+				configVersion,
+				boardRegistry: this.#boards,
+				factoryReady,
+				domains,
+				feed: commentsDomain,
+				...githubIntegration ? { sourceControlOwnerId: "github" } : {}
+			}, integration.id);
+			const publisher = integration.feedPublisher(context);
+			if (publisher) feedPublishers.push(publisher);
+		}
+		const integrationWorkers = [...factoryReady ? [new FactorySupervisorHealthWorker({
+			projects: factoryProjectsStorage,
+			workItems: workItemsStorage,
+			boards: this.#boards
+		})] : [], ...integrationRegistrations.filter(({ integration, ready }) => ready && integration.workers).flatMap(({ integration }) => integration.workers(buildIntegrationContext({
+			controller: prepared.base.controller,
+			publicOrigin,
+			auth: routeAuth,
+			stateSigner,
+			sandbox: sandboxConfig,
+			factoryStorage: storage,
+			integrationStorage,
+			sourceControlStorage,
+			integrations: integrationRegistrations,
+			configVersion,
+			boardRegistry: this.#boards,
+			factoryReady,
+			domains,
+			feed: commentsDomain,
+			...githubIntegration ? { sourceControlOwnerId: "github" } : {}
+		}, integration.id)))];
+		return {
+			...prepared.mastraArgs,
+			...auth ? { studio: { auth } } : {},
+			...integrationWorkers.length > 0 ? { workers: integrationWorkers } : {},
+			...environmentBuilds ? { workflows: { [ENVIRONMENT_BUILD_WORKFLOW_ID]: environmentBuilds.workflow } } : {}
+		};
+	}
+	/**
+	* Post-construct boot: initialize the controller (which inherits the
+	* constructed Mastra's storage) and start its workers. Call AFTER the entry
+	* has run `new Mastra(prepare()'s args)`.
+	*/
+	async finalize() {
+		if (!this.#prepared) throw new Error("MastraFactory.finalize() called before prepare()");
+		await timedPhase("finalize.controller", () => this.#prepared.finalize());
+		await this.#environmentBuilds?.probeSchedules();
+		await timedPhase("finalize.reconcileBoundThreads", () => this.#factoryProcessor?.reconcileAllBoundThreads() ?? Promise.resolve());
+		this.#dispatcher?.start();
+	}
+	/** Stop Factory-owned background dispatch before the host process shuts down. */
+	async shutdown() {
+		await this.#dispatcher?.stop();
+	}
+};
+//#endregion
+export { MastraFactory };
+
+//# sourceMappingURL=factory.js.map