neoagent 3.2.1-beta.1 → 3.2.1-beta.11

package/server/services/android/process.js

@@ -0,0 +1,140 @@
+'use strict';
+
+const { spawn } = require('node:child_process');
+
+const DEFAULT_TIMEOUT_MS = 20_000;
+const DEFAULT_MAX_OUTPUT_BYTES = 4 * 1024 * 1024;
+const MAX_TIMEOUT_MS = 30 * 60 * 1000;
+
+function clampNumber(value, fallback, min, max) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) return fallback;
+  return Math.min(max, Math.max(min, Math.round(parsed)));
+}
+
+function createProcessError(message, code, details = {}) {
+  const error = new Error(message);
+  error.code = code;
+  Object.assign(error, details);
+  return error;
+}
+
+function runProcess(command, args = [], options = {}) {
+  const timeoutMs = clampNumber(options.timeoutMs, DEFAULT_TIMEOUT_MS, 100, MAX_TIMEOUT_MS);
+  const maxOutputBytes = clampNumber(
+    options.maxOutputBytes,
+    DEFAULT_MAX_OUTPUT_BYTES,
+    1024,
+    1024 * 1024 * 1024,
+  );
+  const encoding = options.encoding === null ? null : (options.encoding || 'utf8');
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      windowsHide: true,
+    });
+    const stdout = [];
+    const stderr = [];
+    let stdoutBytes = 0;
+    let stderrBytes = 0;
+    let settled = false;
+    let forceKillTimer = null;
+
+    const decode = (chunks) => {
+      const buffer = Buffer.concat(chunks);
+      return encoding === null ? buffer : buffer.toString(encoding);
+    };
+    const cleanup = () => {
+      clearTimeout(timeout);
+      options.signal?.removeEventListener('abort', onAbort);
+    };
+    const settle = (error, result = null) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      if (error) reject(error);
+      else resolve(result);
+    };
+    const terminate = (error) => {
+      try { child.kill('SIGTERM'); } catch {}
+      forceKillTimer = setTimeout(() => {
+        try { child.kill('SIGKILL'); } catch {}
+      }, 1000);
+      forceKillTimer.unref?.();
+      settle(error);
+    };
+    const onAbort = () => {
+      const error = options.signal?.reason instanceof Error
+        ? options.signal.reason
+        : createProcessError('Command was aborted.', 'ABORT_ERR');
+      if (!(options.signal?.reason instanceof Error)) error.name = 'AbortError';
+      terminate(error);
+    };
+    const collect = (target, chunk, streamName) => {
+      if (settled) return;
+      const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      if (streamName === 'stdout') stdoutBytes += buffer.length;
+      else stderrBytes += buffer.length;
+      if (stdoutBytes + stderrBytes > maxOutputBytes) {
+        terminate(createProcessError(
+          `Command exceeded the ${maxOutputBytes}-byte output limit.`,
+          'PROCESS_OUTPUT_LIMIT',
+        ));
+        return;
+      }
+      target.push(buffer);
+    };
+
+    const timeout = setTimeout(() => {
+      terminate(createProcessError(
+        `Command timed out after ${timeoutMs} ms.`,
+        'PROCESS_TIMEOUT',
+        { timeoutMs },
+      ));
+    }, timeoutMs);
+    timeout.unref?.();
+
+    child.stdout?.on('data', (chunk) => collect(stdout, chunk, 'stdout'));
+    child.stderr?.on('data', (chunk) => collect(stderr, chunk, 'stderr'));
+    child.once('error', (error) => settle(error));
+    child.once('close', (exitCode, signal) => {
+      if (forceKillTimer) clearTimeout(forceKillTimer);
+      if (settled) return;
+      const result = {
+        stdout: decode(stdout),
+        stderr: decode(stderr),
+        exitCode,
+        signal: signal || null,
+      };
+      if (exitCode === 0) {
+        settle(null, result);
+        return;
+      }
+      const stderrText = Buffer.concat(stderr).toString('utf8').trim();
+      const stdoutText = Buffer.concat(stdout).toString('utf8').trim();
+      settle(createProcessError(
+        stderrText || stdoutText || `Command exited with code ${exitCode}.`,
+        'PROCESS_EXIT',
+        result,
+      ));
+    });
+
+    if (options.signal?.aborted) {
+      onAbort();
+      return;
+    }
+    options.signal?.addEventListener('abort', onAbort, { once: true });
+    if (options.input != null) child.stdin?.end(options.input);
+    else child.stdin?.end();
+  });
+}
+
+module.exports = {
+  DEFAULT_MAX_OUTPUT_BYTES,
+  DEFAULT_TIMEOUT_MS,
+  clampNumber,
+  runProcess,
+};

package/server/services/android/sdk_download.js

@@ -0,0 +1,143 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const https = require('node:https');
+const os = require('node:os');
+const { Transform } = require('node:stream');
+const { pipeline } = require('node:stream/promises');
+const { createAbortError } = require('../../utils/abort');
+const { clampNumber } = require('./process');
+
+// Google publishes the current filenames and checksums at:
+// https://developer.android.com/studio#command-line-tools-only
+const COMMAND_LINE_TOOLS_VERSION = '15859902';
+const COMMAND_LINE_TOOLS_RELEASES = {
+  darwin: {
+    arm64: {
+      url: `https://dl.google.com/android/repository/commandlinetools-mac_arm64-${COMMAND_LINE_TOOLS_VERSION}_latest.zip`,
+      sha256: '835b62a26162b229b441d1f6d4680383815a270809eb33522c0d480fa5002c4e',
+    },
+    x64: {
+      url: `https://dl.google.com/android/repository/commandlinetools-mac_x86_64-${COMMAND_LINE_TOOLS_VERSION}_latest.zip`,
+      sha256: 'c5a6378ab5cf7e0d5701921405115befff13e9ff7417fb588389338f8bd050f3',
+    },
+  },
+  linux: {
+    url: `https://dl.google.com/android/repository/commandlinetools-linux-${COMMAND_LINE_TOOLS_VERSION}_latest.zip`,
+    sha256: '4e4c464f145a7512b57d088ac6c278c03c9eea610886b35a5e0804e74eedf583',
+  },
+  win32: {
+    url: `https://dl.google.com/android/repository/commandlinetools-win-${COMMAND_LINE_TOOLS_VERSION}_latest.zip`,
+    sha256: '90ae805d20434428bffcb699c290860f19bb5f66a67e6b330067e3de801fb04a',
+  },
+};
+
+function resolveCommandLineToolsRelease(platform = process.platform, arch = os.arch()) {
+  const release = COMMAND_LINE_TOOLS_RELEASES[platform];
+  if (!release) throw new Error(`No Android command-line-tools download for platform: ${platform}`);
+  if (platform !== 'darwin') return release;
+  if (arch !== 'arm64' && arch !== 'x64') {
+    throw new Error(`No Android command-line-tools download for macOS architecture: ${arch}`);
+  }
+  return release[arch];
+}
+
+function assertExpectedDigest(actualDigest, expectedDigest) {
+  const expected = String(expectedDigest || '').trim().toLowerCase();
+  if (!/^[a-f0-9]{64}$/.test(expected)) {
+    throw new Error('Android SDK download is missing a valid SHA-256 checksum.');
+  }
+  const actualBuffer = Buffer.from(actualDigest, 'hex');
+  const expectedBuffer = Buffer.from(expected, 'hex');
+  if (!crypto.timingSafeEqual(actualBuffer, expectedBuffer)) {
+    const error = new Error('Android SDK download failed SHA-256 verification.');
+    error.code = 'ANDROID_SDK_CHECKSUM_MISMATCH';
+    throw error;
+  }
+}
+
+async function downloadFile(url, destination, options = {}) {
+  const maxRedirects = clampNumber(options.maxRedirects, 5, 0, 10);
+  const timeoutMs = clampNumber(options.timeoutMs, 60_000, 1000, 10 * 60 * 1000);
+  const maxBytes = clampNumber(options.maxBytes, 500 * 1024 * 1024, 1024, 1024 * 1024 * 1024);
+  const temporary = `${destination}.${process.pid}.${Math.random().toString(16).slice(2)}.part`;
+
+  const openResponse = (target, redirectsLeft) => new Promise((resolve, reject) => {
+    if (options.signal?.aborted) {
+      reject(createAbortError(options.signal, 'Android SDK download was aborted.'));
+      return;
+    }
+    const parsed = new URL(target);
+    if (parsed.protocol !== 'https:') {
+      reject(new Error(`Refusing non-HTTPS Android SDK download: ${parsed.protocol}`));
+      return;
+    }
+    const request = https.get(parsed, (response) => {
+      options.signal?.removeEventListener('abort', onAbort);
+      const status = Number(response.statusCode || 0);
+      if (status >= 300 && status < 400 && response.headers.location) {
+        response.resume();
+        if (redirectsLeft <= 0) {
+          reject(new Error('Android SDK download exceeded its redirect limit.'));
+          return;
+        }
+        resolve(openResponse(new URL(response.headers.location, parsed).toString(), redirectsLeft - 1));
+        return;
+      }
+      if (status !== 200) {
+        response.resume();
+        reject(new Error(`Android SDK download failed with HTTP ${status}.`));
+        return;
+      }
+      const contentLength = Number(response.headers['content-length'] || 0);
+      if (contentLength > maxBytes) {
+        response.destroy();
+        reject(new Error(`Android SDK download exceeds the ${maxBytes}-byte limit.`));
+        return;
+      }
+      resolve(response);
+    });
+    const onAbort = () => request.destroy(createAbortError(options.signal, 'Android SDK download was aborted.'));
+    options.signal?.addEventListener('abort', onAbort, { once: true });
+    request.setTimeout(timeoutMs, () => request.destroy(new Error('Android SDK download timed out.')));
+    request.once('error', (error) => {
+      options.signal?.removeEventListener('abort', onAbort);
+      reject(error);
+    });
+  });
+
+  try {
+    const response = await openResponse(url, maxRedirects);
+    const hash = crypto.createHash('sha256');
+    let received = 0;
+    const verifier = new Transform({
+      transform(chunk, _encoding, callback) {
+        received += chunk.length;
+        if (received > maxBytes) {
+          callback(new Error(`Android SDK download exceeds the ${maxBytes}-byte limit.`));
+          return;
+        }
+        hash.update(chunk);
+        callback(null, chunk);
+      },
+    });
+    await pipeline(response, verifier, fs.createWriteStream(temporary, { mode: 0o600 }), {
+      signal: options.signal,
+    });
+    assertExpectedDigest(hash.digest('hex'), options.expectedSha256);
+    fs.renameSync(temporary, destination);
+  } catch (error) {
+    if (options.signal?.aborted) {
+      throw createAbortError(options.signal, 'Android SDK download was aborted.');
+    }
+    throw error;
+  } finally {
+    try { fs.unlinkSync(temporary); } catch {}
+  }
+}
+
+module.exports = {
+  downloadFile,
+  resolveCommandLineToolsRelease,
+};

package/server/services/android/uia.js

@@ -12,12 +12,13 @@ const DEFAULT_BOUNDS = Object.freeze({
 function decodeXml(value) {
   return String(value || '')
     .replace(/"/g, '"')
-    .replace(/&/g, '&')
+    .replace(/'/g, "'")
     .replace(/&lt;/g, '<')
     .replace(/&gt;/g, '>')
     .replace(/&#10;/g, '\n')
     .replace(/&#13;/g, '\r')
-    .replace(/&#39;/g, "'");
+    .replace(/&#39;/g, "'")
+    .replace(/&amp;/g, '&');
 }
 
 function parseBounds(raw) {
@@ -54,7 +55,7 @@ function parseNodeAttributes(raw) {
 
 function parseUiDump(xml) {
   const nodes = [];
-  const nodeRe = /<node\b([^>]*)\/>/g;
+  const nodeRe = /<node\b([^>]*)>/g;
   let match = nodeRe.exec(String(xml || ''));
 
   while (match) {
@@ -123,8 +124,8 @@ function scoreNode(node, selector = {}) {
     else return -1;
   }
 
-  if (selector.clickable === true && node.clickable) score += 40;
-  if (selector.clickable === true && !node.clickable) score -= 60;
+  if (selector.clickable === true && !node.clickable) return -1;
+  if (selector.clickable === true) score += 40;
   if (node.enabled) score += 10;
   if (node.bounds.width > 0 && node.bounds.height > 0) score += 10;
 

package/server/services/artifacts/store.js

@@ -3,6 +3,7 @@ const path = require('path');
 const { v4: uuidv4 } = require('uuid');
 const db = require('../../db/database');
 const { DATA_DIR } = require('../../../runtime/paths');
+const { writeBufferAtomic } = require('../../utils/files');
 
 const ARTIFACTS_ROOT = path.join(DATA_DIR, 'artifacts');
 fs.mkdirSync(ARTIFACTS_ROOT, { recursive: true });
@@ -121,6 +122,29 @@ class ArtifactStore {
     };
   }
 
+  async createBufferArtifact(userId, options = {}) {
+    const buffer = Buffer.isBuffer(options.content)
+      ? options.content
+      : Buffer.from(options.content || []);
+    const allocation = this.allocateFile(userId, options);
+    try {
+      await writeBufferAtomic(allocation.storagePath, buffer, {
+        signal: options.signal,
+      });
+      db.prepare('UPDATE artifacts SET byte_size = ? WHERE id = ?')
+        .run(buffer.length, allocation.artifactId);
+      return {
+        ...allocation,
+        filePath: allocation.storagePath,
+        byteSize: buffer.length,
+      };
+    } catch (error) {
+      await fs.promises.rm(allocation.storagePath, { force: true }).catch(() => {});
+      db.prepare('DELETE FROM artifacts WHERE id = ?').run(allocation.artifactId);
+      throw error;
+    }
+  }
+
   getArtifactForUser(userId, artifactId) {
     const row = db.prepare(`
       SELECT id, user_id, kind, backend, content_type, storage_path, original_filename, byte_size, metadata_json, created_at

package/server/services/behavior/config.js

@@ -0,0 +1,251 @@
+'use strict';
+
+const db = require('../../db/database');
+const { isMainAgent } = require('../agents/manager');
+const { MODULE_IDS, cloneDefaults, DEFAULT_MODULE_CONFIG } = require('./defaults');
+
+const SETTINGS_KEY = 'behavior_modules_config';
+const PARTICIPATION_MODES = new Set(['automatic', 'mention_only', 'always']);
+const MODEL_PURPOSES = new Set(['fast', 'general']);
+const DELIVERY_STYLES = new Set(['single', 'natural_bubbles']);
+
+function clampNumber(value, min, max, fallback) {
+  const number = Number(value);
+  if (!Number.isFinite(number)) return fallback;
+  return Math.min(max, Math.max(min, number));
+}
+
+function asObject(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function normalizeModules(rawModules, fallbackEnabled = true, sparse = false) {
+  const source = asObject(rawModules);
+  const modules = {};
+  for (const id of MODULE_IDS) {
+    if (sparse && !Object.prototype.hasOwnProperty.call(source, id)) continue;
+    const entry = asObject(source[id]);
+    modules[id] = {
+      enabled: entry.enabled == null ? fallbackEnabled : entry.enabled !== false,
+    };
+  }
+  return modules;
+}
+
+function normalizeOptionalString(value, fallback = null) {
+  if (value == null) return fallback;
+  const normalized = String(value).trim();
+  return normalized || null;
+}
+
+function normalizeLeafConfig(raw = {}, base = cloneDefaults(), sparse = false) {
+  const input = asObject(raw);
+  const output = {};
+  const assign = (key, value) => {
+    if (!sparse || Object.prototype.hasOwnProperty.call(input, key)) output[key] = value;
+  };
+  const enabled = input.enabled == null ? base.enabled !== false : input.enabled !== false;
+  assign('enabled', enabled);
+  if (!sparse || Object.prototype.hasOwnProperty.call(input, 'modules')) {
+    output.modules = normalizeModules(input.modules, enabled, sparse);
+  }
+  assign(
+    'participationMode',
+    PARTICIPATION_MODES.has(String(input.participationMode || ''))
+      ? String(input.participationMode)
+      : (base.participationMode || DEFAULT_MODULE_CONFIG.participationMode),
+  );
+  assign('minimumNeedScore', clampNumber(
+    input.minimumNeedScore,
+    0,
+    1,
+    base.minimumNeedScore ?? DEFAULT_MODULE_CONFIG.minimumNeedScore,
+  ));
+  assign('batchWindowMs', Math.round(clampNumber(
+    input.batchWindowMs,
+    0,
+    5000,
+    base.batchWindowMs ?? DEFAULT_MODULE_CONFIG.batchWindowMs,
+  )));
+  assign('decisionContextMessageLimit', Math.round(clampNumber(
+    input.decisionContextMessageLimit,
+    4,
+    30,
+    base.decisionContextMessageLimit ?? DEFAULT_MODULE_CONFIG.decisionContextMessageLimit,
+  )));
+  assign(
+    'decisionModelId',
+    normalizeOptionalString(input.decisionModelId, base.decisionModelId || null),
+  );
+  assign(
+    'decisionModelPurpose',
+    MODEL_PURPOSES.has(String(input.decisionModelPurpose || ''))
+      ? String(input.decisionModelPurpose)
+      : (base.decisionModelPurpose || DEFAULT_MODULE_CONFIG.decisionModelPurpose),
+  );
+  assign(
+    'deliveryStyle',
+    DELIVERY_STYLES.has(String(input.deliveryStyle || ''))
+      ? String(input.deliveryStyle)
+      : (base.deliveryStyle || DEFAULT_MODULE_CONFIG.deliveryStyle),
+  );
+  assign('maxBubbles', Math.round(clampNumber(
+    input.maxBubbles,
+    1,
+    5,
+    base.maxBubbles ?? DEFAULT_MODULE_CONFIG.maxBubbles,
+  )));
+  assign('bubbleGapMs', Math.round(clampNumber(
+    input.bubbleGapMs,
+    0,
+    5000,
+    base.bubbleGapMs ?? DEFAULT_MODULE_CONFIG.bubbleGapMs,
+  )));
+  assign('normsRefreshMessageGap', Math.round(clampNumber(
+    input.normsRefreshMessageGap,
+    3,
+    200,
+    base.normsRefreshMessageGap ?? DEFAULT_MODULE_CONFIG.normsRefreshMessageGap,
+  )));
+  assign('observabilityIntervalMinutes', Math.round(clampNumber(
+    input.observabilityIntervalMinutes,
+    30,
+    10080,
+    base.observabilityIntervalMinutes ?? DEFAULT_MODULE_CONFIG.observabilityIntervalMinutes,
+  )));
+  return output;
+}
+
+function normalizeStoredConfig(raw) {
+  const base = cloneDefaults();
+  const input = asObject(raw);
+  const normalized = {
+    schemaVersion: DEFAULT_MODULE_CONFIG.schemaVersion,
+    ...normalizeLeafConfig(input, base),
+  };
+  const platformOverrides = {};
+  for (const [platform, value] of Object.entries(asObject(input.platformOverrides))) {
+    const key = String(platform || '').trim();
+    if (!key) continue;
+    platformOverrides[key] = normalizeLeafConfig(value, normalized, true);
+  }
+  const roomOverrides = {};
+  const rawRoomOverrides = Object.keys(asObject(input.roomOverrides)).length
+    ? asObject(input.roomOverrides)
+    : asObject(input.groupOverrides);
+  for (const [roomKey, value] of Object.entries(rawRoomOverrides)) {
+    const key = String(roomKey || '').trim();
+    if (!key) continue;
+    roomOverrides[key] = normalizeLeafConfig(value, normalized, true);
+  }
+  return {
+    ...normalized,
+    platformOverrides,
+    roomOverrides,
+  };
+}
+
+function readSettingRow(userId, agentId) {
+  const row = db.prepare(
+    'SELECT value FROM agent_settings WHERE user_id = ? AND agent_id = ? AND key = ?',
+  ).get(userId, agentId, SETTINGS_KEY);
+  if (row?.value != null) return row.value;
+  if (isMainAgent(userId, agentId)) {
+    const legacy = db.prepare(
+      'SELECT value FROM user_settings WHERE user_id = ? AND key = ?',
+    ).get(userId, SETTINGS_KEY);
+    return legacy?.value;
+  }
+  return null;
+}
+
+function parseStoredValue(value) {
+  if (value == null || value === '') return cloneDefaults();
+  if (typeof value === 'object') return normalizeStoredConfig(value);
+  try {
+    return normalizeStoredConfig(JSON.parse(value));
+  } catch {
+    return cloneDefaults();
+  }
+}
+
+function getBehaviorConfig(userId, agentId = null) {
+  return parseStoredValue(readSettingRow(userId, agentId));
+}
+
+function setBehaviorConfig(userId, agentId, config) {
+  const normalized = normalizeStoredConfig(config);
+  db.prepare(
+    `INSERT INTO agent_settings (user_id, agent_id, key, value)
+     VALUES (?, ?, ?, ?)
+     ON CONFLICT(user_id, agent_id, key) DO UPDATE SET value = excluded.value`,
+  ).run(userId, agentId, SETTINGS_KEY, JSON.stringify(normalized));
+  return normalized;
+}
+
+function roomConfigKey(platform, chatId) {
+  return `${String(platform || '').trim()}::${String(chatId || '').trim()}`;
+}
+
+function mergeConfigs(base, override) {
+  if (!override) return base;
+  return {
+    ...base,
+    ...override,
+    modules: {
+      ...asObject(base.modules),
+      ...asObject(override.modules),
+    },
+  };
+}
+
+function resolveBehaviorConfig(userId, agentId, { platform = null, chatId = null, isGroup = false } = {}) {
+  const storedValue = readSettingRow(userId, agentId);
+  const stored = parseStoredValue(storedValue);
+  let effective = normalizeLeafConfig(stored, cloneDefaults());
+  let participationModeSource = storedValue == null ? 'default' : 'agent';
+  const platformKey = String(platform || '').trim();
+  if (platformKey && stored.platformOverrides?.[platformKey]) {
+    effective = mergeConfigs(effective, stored.platformOverrides[platformKey]);
+    if (Object.prototype.hasOwnProperty.call(stored.platformOverrides[platformKey], 'participationMode')) {
+      participationModeSource = 'platform';
+    }
+  }
+  if (isGroup && platformKey && chatId) {
+    const key = roomConfigKey(platformKey, chatId);
+    if (stored.roomOverrides?.[key]) {
+      effective = mergeConfigs(effective, stored.roomOverrides[key]);
+      if (Object.prototype.hasOwnProperty.call(stored.roomOverrides[key], 'participationMode')) {
+        participationModeSource = 'room';
+      }
+    }
+  }
+  effective.modules = normalizeModules(effective.modules, effective.enabled !== false);
+  effective.platformOverrides = stored.platformOverrides || {};
+  effective.roomOverrides = stored.roomOverrides || {};
+  effective.participationModeSource = participationModeSource;
+  effective.scope = {
+    platform: platformKey || null,
+    chatId: chatId ? String(chatId) : null,
+    isGroup: Boolean(isGroup),
+    roomKey: isGroup && platformKey && chatId ? roomConfigKey(platformKey, chatId) : null,
+  };
+  return effective;
+}
+
+function isModuleEnabled(config, moduleId) {
+  if (!config || config.enabled === false) return false;
+  const entry = config.modules?.[moduleId];
+  if (!entry) return false;
+  return entry.enabled !== false;
+}
+
+module.exports = {
+  SETTINGS_KEY,
+  getBehaviorConfig,
+  setBehaviorConfig,
+  resolveBehaviorConfig,
+  normalizeStoredConfig,
+  roomConfigKey,
+  isModuleEnabled,
+};

package/server/services/behavior/defaults.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const MODULE_IDS = Object.freeze([
+  'turn_taking',
+  'social_memory',
+  'norms',
+  'persona',
+  'agent_identity',
+  'channel_style',
+  'theory_of_mind',
+  'social_signals',
+  'social_observability',
+  'delivery',
+]);
+
+const DEFAULT_MODULE_CONFIG = Object.freeze({
+  schemaVersion: 1,
+  enabled: true,
+  participationMode: 'automatic',
+  minimumNeedScore: 0.72,
+  batchWindowMs: 900,
+  decisionContextMessageLimit: 12,
+  decisionModelId: null,
+  decisionModelPurpose: 'fast',
+  deliveryStyle: 'natural_bubbles',
+  maxBubbles: 4,
+  bubbleGapMs: 650,
+  normsRefreshMessageGap: 18,
+  observabilityIntervalMinutes: 360,
+});
+
+function cloneDefaults() {
+  return {
+    schemaVersion: DEFAULT_MODULE_CONFIG.schemaVersion,
+    enabled: DEFAULT_MODULE_CONFIG.enabled,
+    modules: {
+      turn_taking: { enabled: true },
+      social_memory: { enabled: true },
+      norms: { enabled: true },
+      persona: { enabled: true },
+      agent_identity: { enabled: true },
+      channel_style: { enabled: true },
+      theory_of_mind: { enabled: true },
+      social_signals: { enabled: true },
+      social_observability: { enabled: true },
+      delivery: { enabled: true },
+    },
+    participationMode: DEFAULT_MODULE_CONFIG.participationMode,
+    minimumNeedScore: DEFAULT_MODULE_CONFIG.minimumNeedScore,
+    batchWindowMs: DEFAULT_MODULE_CONFIG.batchWindowMs,
+    decisionContextMessageLimit: DEFAULT_MODULE_CONFIG.decisionContextMessageLimit,
+    decisionModelId: DEFAULT_MODULE_CONFIG.decisionModelId,
+    decisionModelPurpose: DEFAULT_MODULE_CONFIG.decisionModelPurpose,
+    deliveryStyle: DEFAULT_MODULE_CONFIG.deliveryStyle,
+    maxBubbles: DEFAULT_MODULE_CONFIG.maxBubbles,
+    bubbleGapMs: DEFAULT_MODULE_CONFIG.bubbleGapMs,
+    normsRefreshMessageGap: DEFAULT_MODULE_CONFIG.normsRefreshMessageGap,
+    observabilityIntervalMinutes: DEFAULT_MODULE_CONFIG.observabilityIntervalMinutes,
+    platformOverrides: {},
+    roomOverrides: {},
+  };
+}
+
+module.exports = {
+  MODULE_IDS,
+  DEFAULT_MODULE_CONFIG,
+  cloneDefaults,
+};