@better-openclaw/core 1.0.26 → 1.0.30

package/src/generate.ts

@@ -5,6 +5,7 @@ import {
 } from "./bare-metal-partition.js";
 import { composeMultiFile } from "./composer.js";
 import { StackConfigError, ValidationError } from "./errors.js";
+import { getFrameworkById } from "./frameworks/index.js";
 import { generateBareMetalInstall } from "./generators/bare-metal-install.js";
 import { generateCaddyfile } from "./generators/caddy.js";
 import { generateCloneScripts } from "./generators/clone-repos.js";
@@ -16,7 +17,6 @@ import { generateHealthCheck } from "./generators/health-check.js";
 import { generateN8nWorkflows } from "./generators/n8n-workflows.js";
 import { generateNativeInstallScripts } from "./generators/native-services.js";
 import { generateOpenclawInstallScript } from "./generators/openclaw-install-script.js";
-import { generateOpenClawConfig } from "./generators/openclaw-json.js";
 import { generatePostgresInit } from "./generators/postgres-init.js";
 import { generatePrometheusConfig } from "./generators/prometheus.js";
 import { generateReadme } from "./generators/readme.js";
@@ -24,6 +24,7 @@ import { generateScripts } from "./generators/scripts.js";
 import { generateSkillFiles } from "./generators/skills.js";
 import { generateStackManifest } from "./generators/stack-manifest.js";
 import { generateTraefikConfig } from "./generators/traefik.js";
+import type { OperationsLogger } from "./logger/logger.js";
 import { migrateConfig } from "./migrations.js";
 import { resolve } from "./resolver.js";
 import type {
@@ -45,30 +46,52 @@ function getComposePlatform(platform: Platform): "linux/amd64" | "linux/arm64" {
  * Main orchestration function: takes generation input, resolves dependencies,
  * generates all files, validates, and returns the complete file tree.
  */
-export function generate(rawInput: GenerationInput): GenerationResult {
+export function generate(
+	rawInput: GenerationInput,
+	options?: { logger?: OperationsLogger },
+): GenerationResult {
+	const logger = options?.logger;
+
 	// Apply config migrations if needed
 	const input = migrateConfig(rawInput as Record<string, unknown>) as GenerationInput;
 
 	const composePlatform = getComposePlatform(input.platform);
 
+	logger?.info("generation", "Starting stack generation", {
+		projectName: input.projectName,
+		services: input.services,
+		platform: input.platform,
+		proxy: input.proxy,
+		deploymentType: input.deploymentType,
+	});
+
 	// 1. Resolve dependencies
 	const resolverInput: ResolverInput = {
 		services: input.services,
 		skillPacks: input.skillPacks,
 		aiProviders: input.aiProviders,
+		primaryFramework: input.primaryFramework,
 		proxy: input.proxy,
 		gpu: input.gpu,
 		platform: composePlatform,
 		monitoring: input.monitoring,
 	};
+	logger?.debug("resolution", "Resolving dependencies");
 	const resolved = resolve(resolverInput);
 
 	if (!resolved.isValid) {
-		throw new StackConfigError(
-			`Invalid stack configuration: ${resolved.errors.map((e) => e.message).join("; ")}`,
-		);
+		const errMsg = `Invalid stack configuration: ${resolved.errors.map((e) => e.message).join("; ")}`;
+		logger?.error("resolution", errMsg);
+		throw new StackConfigError(errMsg);
 	}
 
+	logger?.info("resolution", `Resolved ${resolved.services.length} services`, {
+		serviceCount: resolved.services.length,
+		addedDeps: resolved.addedDependencies.length,
+		warnings: resolved.warnings.length,
+		estimatedMemoryMB: resolved.estimatedMemoryMB,
+	});
+
 	const isBareMetal = input.deploymentType === "bare-metal";
 	let resolvedForCompose = resolved;
 	let nativeIds = new Set<string>();
@@ -85,6 +108,8 @@ export function generate(rawInput: GenerationInput): GenerationResult {
 		}
 	}
 
+	logger?.debug("generation", "Generating Docker Compose YAML");
+
 	// 2. Generate Docker Compose YAML (multi-file)
 	// Compute Traefik labels before composing (labels get injected into docker-compose services)
 	let traefikOutput: ReturnType<typeof generateTraefikConfig> | undefined;
@@ -94,6 +119,8 @@ export function generate(rawInput: GenerationInput): GenerationResult {
 
 	const composeOptions = {
 		projectName: input.projectName,
+		primaryFramework: input.primaryFramework,
+		companionFrameworks: input.companionFrameworks,
 		proxy: input.proxy,
 		proxyHttpPort: input.proxyHttpPort,
 		proxyHttpsPort: input.proxyHttpsPort,
@@ -110,6 +137,7 @@ export function generate(rawInput: GenerationInput): GenerationResult {
 		openclawInstallMethod: input.openclawInstallMethod ?? "docker",
 	};
 	const composeResult = composeMultiFile(resolvedForCompose, composeOptions);
+	logger?.info("generation", `Generated ${Object.keys(composeResult.files).length} compose files`);
 
 	// 3. Validate (using the base docker-compose.yml)
 	const validation = validate(resolvedForCompose, composeResult.files["docker-compose.yml"] ?? "", {
@@ -117,10 +145,11 @@ export function generate(rawInput: GenerationInput): GenerationResult {
 		generateSecrets: input.generateSecrets,
 	});
 	if (!validation.valid) {
-		throw new ValidationError(
-			`Validation failed: ${validation.errors.map((e) => e.message).join("; ")}`,
-		);
+		const errMsg = `Validation failed: ${validation.errors.map((e) => e.message).join("; ")}`;
+		logger?.error("validation", errMsg);
+		throw new ValidationError(errMsg);
 	}
+	logger?.debug("validation", "Stack validation passed");
 
 	// 4. Generate all files
 	const files: GeneratedFiles = {};
@@ -139,6 +168,7 @@ export function generate(rawInput: GenerationInput): GenerationResult {
 		composeFiles: Object.keys(composeResult.files),
 		composeProfiles: composeResult.profiles,
 		openclawImage: input.openclawImage,
+		primaryFramework: input.primaryFramework,
 	});
 	files[".env.example"] = envFiles.envExample;
 	files[".env"] = envFiles.env;
@@ -165,12 +195,18 @@ export function generate(rawInput: GenerationInput): GenerationResult {
 		files[path] = content;
 	}
 
-	// OpenClaw Core Configuration
-	files["openclaw/config/openclaw.json"] = generateOpenClawConfig(resolved, {
-		deploymentType: input.deploymentType,
-		gatewayPort: 18789,
-		openclawVersion: input.openclawVersion,
-	});
+	// Framework-specific configuration
+	const framework = getFrameworkById(input.primaryFramework ?? "openclaw");
+	if (framework) {
+		const fwConfig = framework.generateConfig(resolved, {
+			deploymentType: input.deploymentType,
+			gatewayPort: 18789,
+			frameworkVersion: input.openclawVersion,
+		});
+		if (fwConfig) {
+			files[fwConfig.path] = fwConfig.content;
+		}
+	}
 
 	// README
 	files["README.md"] = generateReadme(resolved, {
@@ -180,6 +216,7 @@ export function generate(rawInput: GenerationInput): GenerationResult {
 		deploymentType: input.deploymentType,
 		hasNativeServices: isBareMetal && nativeServices.length > 0,
 		openclawInstallMethod: input.openclawInstallMethod,
+		primaryFramework: input.primaryFramework,
 	});
 
 	// Scripts
@@ -310,6 +347,22 @@ export function generate(rawInput: GenerationInput): GenerationResult {
 	// 5. Calculate metadata
 	const skillCount = resolved.services.reduce((sum, s) => sum + s.definition.skills.length, 0);
 
+	const fileCount = Object.keys(files).length;
+
+	logger?.log({
+		level: "info",
+		category: "generation",
+		message: `Stack generation complete: ${fileCount} files, ${resolved.services.length} services`,
+		outcome: "success",
+		context: {
+			fileCount,
+			serviceCount: resolved.services.length,
+			skillCount,
+			estimatedMemoryMB: resolved.estimatedMemoryMB,
+		},
+		filesAffected: { created: Object.keys(files) },
+	});
+
 	return {
 		files,
 		metadata: {

package/src/generators/caddy.test.ts

@@ -19,7 +19,7 @@ describe("generateCaddyfile (via generate)", () => {
 		const result = generate(baseInput);
 
 		expect(result.files).toHaveProperty("caddy/Caddyfile");
-		expect(result.files["caddy/Caddyfile"]!.length).toBeGreaterThan(0);
+		expect(result.files["caddy/Caddyfile"]?.length).toBeGreaterThan(0);
 	});
 
 	it("does not generate Caddyfile when proxy is none", () => {
@@ -53,4 +53,44 @@ describe("generateCaddyfile (via generate)", () => {
 		// Caddy auto-enables TLS, so should reference HTTPS or TLS
 		expect(caddyfile.length).toBeGreaterThan(50);
 	});
+
+	it("adds flush_interval -1 for WebSocket-enabled services (opensandbox)", () => {
+		const result = generate({
+			...baseInput,
+			services: ["opensandbox"],
+		});
+		const caddyfile = result.files["caddy/Caddyfile"]!;
+
+		expect(caddyfile).toContain("opensandbox");
+		expect(caddyfile).toContain("flush_interval -1");
+	});
+
+	it("adds flush_interval -1 for desktop-environment (KasmVNC)", () => {
+		const result = generate({
+			...baseInput,
+			services: ["desktop-environment"],
+		});
+		const caddyfile = result.files["caddy/Caddyfile"]!;
+
+		expect(caddyfile).toContain("desktop-environment");
+		expect(caddyfile).toContain("flush_interval -1");
+	});
+
+	it("adds flush_interval -1 for agent-browser viewport streaming port", () => {
+		const result = generate({
+			...baseInput,
+			services: ["agent-browser"],
+		});
+		const caddyfile = result.files["caddy/Caddyfile"]!;
+
+		expect(caddyfile).toContain("agent-browser");
+		expect(caddyfile).toContain("flush_interval -1");
+	});
+
+	it("does NOT add flush_interval for non-WebSocket services", () => {
+		const result = generate(baseInput);
+		const caddyfile = result.files["caddy/Caddyfile"]!;
+
+		expect(caddyfile).not.toContain("flush_interval");
+	});
 });

package/src/generators/caddy.ts

@@ -40,6 +40,8 @@ export function generateCaddyfile(resolved: ResolverOutput, domain: string): str
 		const primaryPort = exposedPorts[0]!;
 		const subdomain = `${definition.id}.${domain}`;
 
+		const needsWebSocket = primaryPort.websocket === true;
+
 		const block = [
 			`# ${definition.icon} ${definition.name}`,
 			`# ${definition.description}`,
@@ -49,9 +51,15 @@ export function generateCaddyfile(resolved: ResolverOutput, domain: string): str
 			`		header_up X-Real-IP {remote_host}`,
 			`		header_up X-Forwarded-For {remote_host}`,
 			`		header_up X-Forwarded-Proto {scheme}`,
-			`	}`,
 		];
 
+		// Disable response buffering for streaming WebSocket connections (noVNC, KasmVNC)
+		if (needsWebSocket) {
+			block.push(`		flush_interval -1`);
+		}
+
+		block.push(`	}`);
+
 		// Add health check if service has one
 		if (definition.healthcheck) {
 			block.push("");
@@ -74,7 +82,13 @@ export function generateCaddyfile(resolved: ResolverOutput, domain: string): str
 
 			block.push(`# ${definition.name} — ${port.description}`);
 			block.push(`${portSubdomain} {`);
-			block.push(`	reverse_proxy ${definition.id}:${port.container}`);
+			if (port.websocket) {
+				block.push(`	reverse_proxy ${definition.id}:${port.container} {`);
+				block.push(`		flush_interval -1`);
+				block.push(`	}`);
+			} else {
+				block.push(`	reverse_proxy ${definition.id}:${port.container}`);
+			}
 			block.push(`}`);
 			block.push("");
 		}

package/src/generators/clone-repos.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest";
-import { generateCloneScripts } from "./clone-repos.js";
 import type { ResolverOutput } from "../types.js";
+import { generateCloneScripts } from "./clone-repos.js";
 
 /** Minimal resolved output with no services */
 function emptyResolved(): ResolverOutput {

package/src/generators/clone-repos.ts

@@ -22,7 +22,10 @@ export function generateCloneScripts(resolved: ResolverOutput): Record<string, s
 			let block = `clone_or_update "${s.definition.id}" "${gs.repoUrl}" ${branchArg}`;
 			if (gs.postCloneCommands && gs.postCloneCommands.length > 0) {
 				const cmds = gs.postCloneCommands
-					.map((cmd) => `  (cd "$REPOS_DIR/${s.definition.id}${gs.subdirectory ? `/${gs.subdirectory}` : ""}" && ${cmd})`)
+					.map(
+						(cmd) =>
+							`  (cd "$REPOS_DIR/${s.definition.id}${gs.subdirectory ? `/${gs.subdirectory}` : ""}" && ${cmd})`,
+					)
 					.join("\n");
 				block += `\n${cmds}`;
 			}
@@ -96,7 +99,9 @@ ok "All repositories ready."
 			if (gs.postCloneCommands && gs.postCloneCommands.length > 0) {
 				const subdir = gs.subdirectory ? `/${gs.subdirectory}` : "";
 				const cmds = gs.postCloneCommands
-					.map((cmd) => `Push-Location "$ReposDir/${s.definition.id}${subdir}"; ${cmd}; Pop-Location`)
+					.map(
+						(cmd) => `Push-Location "$ReposDir/${s.definition.id}${subdir}"; ${cmd}; Pop-Location`,
+					)
 					.join("\n");
 				block += `\n${cmds}`;
 			}

package/src/generators/env.test.ts

@@ -37,8 +37,8 @@ describe("generateEnvFiles (via generate)", () => {
 		const redisLine = env.split("\n").find((l) => l.startsWith("REDIS_PASSWORD="));
 		expect(redisLine).toBeDefined();
 		// Value should not be empty
-		const value = redisLine!.split("=")[1];
-		expect(value!.length).toBeGreaterThan(0);
+		const value = redisLine?.split("=")[1];
+		expect(value?.length).toBeGreaterThan(0);
 	});
 
 	it("env files contain service-specific variables", () => {

package/src/generators/env.ts

@@ -1,4 +1,6 @@
 import { randomBytes } from "node:crypto";
+import { getFrameworkById } from "../frameworks/index.js";
+import type { AgentFrameworkId } from "../frameworks/types.js";
 import type { ResolverOutput } from "../types.js";
 import { getDbRequirements } from "./postgres-init.js";
 
@@ -17,6 +19,8 @@ export interface EnvGeneratorOptions {
 	composeProfiles?: string[];
 	/** OpenClaw image variant (official, coolify, alpine). */
 	openclawImage?: "official" | "coolify" | "alpine";
+	/** Primary agent framework (defaults to "openclaw"). */
+	primaryFramework?: AgentFrameworkId;
 }
 
 /**
@@ -69,191 +73,37 @@ export function generateEnvFiles(
 		});
 	}
 
-	// ── Base OpenClaw Variables ──────────────────────────────────────────────
+	// ── Framework-Specific Base Variables ────────────────────────────────────
 
-	lines.push({
-		comment: formatComment("OpenClaw version to deploy", "OpenClaw Core", true, false),
-		key: "OPENCLAW_VERSION",
-		exampleValue: version,
-		actualValue: version,
-	});
-
-	const gatewayToken = options.generateSecrets ? randomBytes(24).toString("hex") : "";
-
-	lines.push({
-		comment: formatComment(
-			"Authentication token for the OpenClaw gateway API",
-			"OpenClaw Core",
-			true,
-			true,
-		),
-		key: "OPENCLAW_GATEWAY_TOKEN",
-		exampleValue: "your_gateway_token_here",
-		actualValue: gatewayToken,
-	});
-
-	lines.push({
-		comment: formatComment("Port the OpenClaw gateway listens on", "OpenClaw Core", true, false),
-		key: "OPENCLAW_GATEWAY_PORT",
-		exampleValue: "18789",
-		actualValue: "18789",
-	});
-
-	lines.push({
-		comment: formatComment(
-			"Port for the OpenClaw ACP bridge (WebSocket)",
-			"OpenClaw Core",
-			false,
-			false,
-		),
-		key: "OPENCLAW_BRIDGE_PORT",
-		exampleValue: "18790",
-		actualValue: "18790",
-	});
-
-	lines.push({
-		comment: formatComment(
-			"Gateway network bind mode: 'lan' (all interfaces, required for Docker). Use 'loopback' only for native (non-Docker) installs with Tailscale serve/funnel",
-			"OpenClaw Core",
-			false,
-			false,
-		),
-		key: "OPENCLAW_GATEWAY_BIND",
-		exampleValue: "lan",
-		actualValue: "lan",
-	});
-
-	lines.push({
-		comment: formatComment(
-			"Host path to OpenClaw configuration directory",
-			"OpenClaw Core",
-			true,
-			false,
-		),
-		key: "OPENCLAW_CONFIG_DIR",
-		exampleValue: "./openclaw/config",
-		actualValue: "./openclaw/config",
-	});
-
-	lines.push({
-		comment: formatComment(
-			"Host path to OpenClaw workspace directory",
-			"OpenClaw Core",
-			true,
-			false,
-		),
-		key: "OPENCLAW_WORKSPACE_DIR",
-		exampleValue: "./openclaw/workspace",
-		actualValue: "./openclaw/workspace",
-	});
-
-	// Set OPENCLAW_IMAGE based on variant (empty = use compose default)
-	const imageVariantMap: Record<string, string> = {
-		official: "", // use compose default (ghcr.io/openclaw/openclaw:VERSION)
-		coolify: "coollabsio/openclaw:latest",
-		alpine: "alpine/openclaw:latest",
-	};
-	const imageValue = imageVariantMap[options.openclawImage ?? "official"] ?? "";
-
-	lines.push({
-		comment: formatComment(
-			`OpenClaw Docker image variant: ${options.openclawImage ?? "official"} (official, coolify, alpine)`,
-			"OpenClaw Core",
-			false,
-			false,
-		),
-		key: "OPENCLAW_IMAGE",
-		exampleValue: "",
-		actualValue: imageValue,
-	});
-
-	lines.push({
-		comment: formatComment(
-			"Extra bind mounts for gateway and CLI containers (comma-separated, format: source:target[:options])",
-			"OpenClaw Core",
-			false,
-			false,
-		),
-		key: "OPENCLAW_EXTRA_MOUNTS",
-		exampleValue: "",
-		actualValue: "",
-	});
-
-	lines.push({
-		comment: formatComment(
-			"Named volume or host path for /home/node persistence across container restarts",
-			"OpenClaw Core",
-			false,
-			false,
-		),
-		key: "OPENCLAW_HOME_VOLUME",
-		exampleValue: "",
-		actualValue: "",
-	});
-
-	lines.push({
-		comment: formatComment(
-			"Extra apt packages to install during Docker image build (space-separated)",
-			"OpenClaw Core",
-			false,
-			false,
-		),
-		key: "OPENCLAW_DOCKER_APT_PACKAGES",
-		exampleValue: "",
-		actualValue: "",
-	});
-
-	lines.push({
-		comment: formatComment(
-			"Alternative auth: gateway password (use token OR password, not both)",
-			"OpenClaw Core",
-			false,
-			true,
-		),
-		key: "OPENCLAW_GATEWAY_PASSWORD",
-		exampleValue: "",
-		actualValue: "",
-	});
-
-	lines.push({
-		comment: formatComment(
-			"Override state directory path (default: ~/.openclaw)",
-			"OpenClaw Core",
-			false,
-			false,
-		),
-		key: "OPENCLAW_STATE_DIR",
-		exampleValue: "",
-		actualValue: "",
-	});
-
-	lines.push({
-		comment: formatComment(
-			"Override config file path (default: ~/.openclaw/openclaw.json)",
-			"OpenClaw Core",
-			false,
-			false,
-		),
-		key: "OPENCLAW_CONFIG_PATH",
-		exampleValue: "",
-		actualValue: "",
-	});
+	const framework = getFrameworkById(options.primaryFramework ?? "openclaw");
+	if (framework) {
+		const sectionName = framework.getEnvSectionName();
+		const fwEnvVars = framework.getBaseEnvVars({
+			generateSecrets: options.generateSecrets,
+			domain: options.domain,
+			frameworkVersion: version,
+			frameworkImageVariant: options.openclawImage ?? "official",
+		});
 
-	lines.push({
-		comment: formatComment(
-			"Import missing keys from login shell profile (set to 1 to enable)",
-			"OpenClaw Core",
-			false,
-			false,
-		),
-		key: "OPENCLAW_LOAD_SHELL_ENV",
-		exampleValue: "",
-		actualValue: "",
-	});
+		for (const envLine of fwEnvVars) {
+			lines.push({
+				comment: formatComment(
+					envLine.comment,
+					sectionName,
+					false,
+					envLine.key.includes("TOKEN") || envLine.key.includes("PASSWORD"),
+				),
+				key: envLine.key,
+				exampleValue: envLine.exampleValue,
+				actualValue: envLine.actualValue,
+			});
+		}
+	}
 
 	if (options.domain) {
+		const sectionName = framework?.getEnvSectionName() ?? "Core";
 		lines.push({
-			comment: formatComment("Primary domain for service routing", "OpenClaw Core", false, false),
+			comment: formatComment("Primary domain for service routing", sectionName, false, false),
 			key: "OPENCLAW_DOMAIN",
 			exampleValue: "example.com",
 			actualValue: options.domain,

package/src/generators/health-check.ts

@@ -101,7 +101,7 @@ function generateBashScript(resolved: ResolverOutput, options: HealthCheckOption
 	}
 
 	// Build the log-scan service list
-	const svcIdList = checks.map((s) => '"' + s.id + '"').join(" ");
+	const svcIdList = checks.map((s) => `"${s.id}"`).join(" ");
 
 	const lines: string[] = [
 		"#!/usr/bin/env bash",
@@ -450,7 +450,7 @@ function generateBashScript(resolved: ResolverOutput, options: HealthCheckOption
 		"fi",
 	];
 
-	return lines.join("\n") + "\n";
+	return `${lines.join("\n")}\n`;
 }
 
 // ─── PowerShell Script ──────────────────────────────────────────────────────
@@ -522,7 +522,7 @@ function generatePowerShellScript(resolved: ResolverOutput, options: HealthCheck
 		bmChecks.push("");
 	}
 
-	const svcIdList = checks.map((s) => '"' + s.id + '"').join(", ");
+	const svcIdList = checks.map((s) => `"${s.id}"`).join(", ");
 
 	const lines: string[] = [
 		"#Requires -Version 5.1",
@@ -808,5 +808,5 @@ function generatePowerShellScript(resolved: ResolverOutput, options: HealthCheck
 		"}",
 	];
 
-	return lines.join("\n") + "\n";
+	return `${lines.join("\n")}\n`;
 }

package/src/generators/openclaw-json.ts

@@ -351,6 +351,61 @@ const LOCAL_PROVIDER_PORTS: Record<string, number> = {
  * Generates a default `openclaw/config/openclaw.json` tailored
  * to the services installed in the stack.
  */
+/**
+ * Builds the memory configuration based on installed services.
+ * Priority: mem0 > memu > hindsight > builtin.
+ * Also detects vector databases and adds vectorStore config.
+ */
+function buildMemoryConfig(resolved: ResolverOutput): Record<string, unknown> {
+	const has = (id: string) => resolved.services.some((s) => s.definition.id === id);
+
+	// Detect vector databases (priority order)
+	const vectorStore = has("qdrant")
+		? { provider: "qdrant", host: "qdrant", port: 6333 }
+		: has("chromadb")
+			? { provider: "chromadb", host: "chromadb", port: 8000 }
+			: has("weaviate")
+				? { provider: "weaviate", host: "weaviate", port: 8080 }
+				: has("milvus")
+					? { provider: "milvus", uri: "http://milvus:19530" }
+					: null;
+
+	// Detect memory services (priority order)
+	if (has("mem0")) {
+		return {
+			backend: "mem0",
+			citations: "auto",
+			mem0: { host: "mem0", port: 8000, userId: "openclaw-agent" },
+			...(vectorStore ? { vectorStore } : {}),
+		};
+	}
+
+	if (has("memu")) {
+		return {
+			backend: "memu",
+			citations: "auto",
+			memu: { host: "memu", port: 8000, agentId: "openclaw-agent" },
+			...(vectorStore ? { vectorStore } : {}),
+		};
+	}
+
+	if (has("hindsight")) {
+		return {
+			backend: "hindsight",
+			citations: "auto",
+			hindsight: { host: "hindsight", port: 8888, namespace: "openclaw" },
+			...(vectorStore ? { vectorStore } : {}),
+		};
+	}
+
+	// No memory service — use builtin, optionally with a vector store
+	return {
+		backend: "builtin",
+		citations: "auto",
+		...(vectorStore ? { vectorStore } : {}),
+	};
+}
+
 export function generateOpenClawConfig(
 	resolved: ResolverOutput,
 	options: OpenClawConfigOptions,
@@ -667,11 +722,8 @@ export function generateOpenClawConfig(
 				maxPingPongTurns: 5,
 			},
 		},
-		// Memory — vector search over session history and markdown notes
-		memory: {
-			backend: "builtin",
-			citations: "auto",
-		},
+		// Memory — dynamically configured based on installed services
+		memory: buildMemoryConfig(resolved),
 		// UI customization
 		ui: {
 			assistant: {

package/src/generators/postgres-init.ts

@@ -52,7 +52,16 @@ const DB_REQUIREMENTS: Record<string, Omit<DbRequirement, "serviceId" | "service
 	openpanel: { dbName: "openpanel", dbUser: "openpanel", passwordEnvVar: "OPENPANEL_DB_PASSWORD" },
 	usesend: { dbName: "usesend", dbUser: "usesend", passwordEnvVar: "USESEND_DB_PASSWORD" },
 	nextcloud: { dbName: "nextcloud", dbUser: "nextcloud", passwordEnvVar: "NEXTCLOUD_DB_PASSWORD" },
+	// ── CRM ────────────────────────────────────────────────────────────────
+	twenty: { dbName: "twenty", dbUser: "twenty", passwordEnvVar: "TWENTY_DB_PASSWORD" },
+	relaticle: {
+		dbName: "relaticle",
+		dbUser: "relaticle",
+		passwordEnvVar: "RELATICLE_DB_PASSWORD",
+	},
 	// ── Agent Memory ────────────────────────────────────────────────────────
+	mem0: { dbName: "mem0", dbUser: "mem0", passwordEnvVar: "MEM0_DB_PASSWORD" },
+	memu: { dbName: "memu", dbUser: "memu", passwordEnvVar: "MEMU_DB_PASSWORD" },
 	hindsight: { dbName: "hindsight", dbUser: "hindsight", passwordEnvVar: "HINDSIGHT_DB_PASSWORD" },
 	// ── SaaS Boilerplates ────────────────────────────────────────────────────
 	"open-saas": { dbName: "opensaas", dbUser: "opensaas", passwordEnvVar: "OPENSAAS_DB_PASSWORD" },