neoagent 3.2.1-beta.10 → 3.2.1-beta.12

package/server/services/ai/toolEvidence.js

@@ -200,41 +200,6 @@ function isSubstantiveProgressToolName(toolName = '') {
   return true;
 }
 
-const PRIMARY_RESEARCH_SOURCES = new Set([
-  'browser',
-  'http',
-  'integration',
-  'files',
-  'command',
-  'mcp',
-  'android',
-  'data',
-  'vision',
-  'skills',
-  'subagent',
-]);
-
-const SECONDARY_RESEARCH_SOURCES = new Set([
-  'search',
-  'memory',
-]);
-
-// External/source-backed tools only. Local file/edit/shell work must not
-// inherit a research burden just because inspection tools are available.
-const RESEARCH_TOOL_HINTS = new Set([
-  'web_search',
-  'http_request',
-  'browser_navigate',
-  'browser_open',
-  'browser_click',
-  'browser_type',
-  'browser_snapshot',
-  'browser_evaluate',
-  'analyze_image',
-  'spawn_subagent',
-  'delegate_to_agent',
-]);
-
 function clampResearchText(value, maxChars = 220) {
   const text = String(value || '').replace(/\s+/g, ' ').trim();
   if (!text) return '';
@@ -266,18 +231,20 @@ function collectResearchTargets(analysis = null, goalContext = null) {
   ], { limit: 8 });
 }
 
-function hasResearchToolHint(analysis = null) {
-  const tools = Array.isArray(analysis?.suggested_tools) ? analysis.suggested_tools : [];
-  return tools.some((name) => {
-    const tool = String(name || '').trim().toLowerCase();
-    if (!tool) return false;
-    if (RESEARCH_TOOL_HINTS.has(tool)) return true;
-    // Tool-schema identity only: family prefixes, not free-text phrase matching.
-    return tool.startsWith('browser_') || tool.startsWith('mcp_');
-  });
-}
-
 function resolveResearchIntensity(analysis = null, goalContext = null) {
+  const declaredDepth = String(
+    analysis?.research_depth
+    || analysis?.researchDepth
+    || '',
+  ).trim().toLowerCase();
+  const declaredTargets = collectResearchTargets(analysis, goalContext);
+  if (
+    ['none', 'light', 'deep'].includes(declaredDepth)
+    && !(declaredDepth === 'none' && declaredTargets.length > 0)
+  ) {
+    return declaredDepth;
+  }
+
   const mode = String(analysis?.mode || '').trim().toLowerCase();
   const complexity = String(
     goalContext?.effectiveComplexity
@@ -297,21 +264,16 @@ function resolveResearchIntensity(analysis = null, goalContext = null) {
   const verificationNeed = String(analysis?.verification_need || '').trim().toLowerCase();
   const freshnessRisk = String(analysis?.freshness_risk || '').trim().toLowerCase();
   const planningDepth = String(analysis?.planning_depth || '').trim().toLowerCase();
-  const targets = collectResearchTargets(analysis, goalContext);
-  const researchToolHint = hasResearchToolHint(analysis);
+  const targets = declaredTargets;
 
   if (mode === 'direct_answer' && verificationNeed === 'none' && freshnessRisk === 'none') {
     return 'none';
   }
 
-  // External/source-backed work only. Pure local implementation tasks must not
-  // inherit a research burden just because they are complex or multi-step.
   const needsExternalEvidence = (
     targets.length > 0
-    || researchToolHint
     || freshnessRisk === 'possible'
     || freshnessRisk === 'high'
-    || verificationNeed === 'required'
   );
   if (!needsExternalEvidence) {
     return 'none';
@@ -342,32 +304,32 @@ function isSuccessfulResearchExecution(item = {}) {
   return Boolean(item.evidenceRelevant || item.dependsOnOutput || item.stateChanged);
 }
 
-function isPrimaryResearchSource(source = '') {
-  return PRIMARY_RESEARCH_SOURCES.has(String(source || '').trim().toLowerCase());
+function selectResearchEvidenceCandidates(toolExecutions = [], maxItems = 80) {
+  const candidates = (Array.isArray(toolExecutions) ? toolExecutions : [])
+    .map((execution, index) => ({ execution, evidenceIndex: index + 1 }))
+    .filter(({ execution }) => isSuccessfulResearchExecution(execution));
+  if (candidates.length <= maxItems) return candidates;
+
+  const firstCount = Math.floor(maxItems / 4);
+  return [
+    ...candidates.slice(0, firstCount),
+    ...candidates.slice(-(maxItems - firstCount)),
+  ];
 }
 
-function isSecondaryResearchSource(source = '') {
-  return SECONDARY_RESEARCH_SOURCES.has(String(source || '').trim().toLowerCase());
+function summarizeResearchEvidenceCatalog(toolExecutions = [], maxItems = 80) {
+  return selectResearchEvidenceCandidates(toolExecutions, maxItems)
+    .map(({ execution, evidenceIndex }) => (
+      `E${evidenceIndex}. ${execution.toolName} [${execution.evidenceSource || 'tool'}] :: ${clampRunContext(execution.summary || '', 160)}`
+    ))
+    .join('\n');
 }
 
-function executionMentionsTarget(execution = {}, target = '') {
-  const needle = String(target || '').trim().toLowerCase();
-  if (!needle) return false;
-  const haystack = [
-    execution.summary,
-    execution.toolName,
-    execution.evidenceSource,
-    JSON.stringify(execution.input || {}),
-  ].join(' ').toLowerCase();
-  if (haystack.includes(needle)) return true;
-
-  const tokens = needle
-    .split(/[^a-z0-9+]+/i)
-    .map((token) => token.trim())
-    .filter((token) => token.length >= 3);
-  if (tokens.length === 0) return false;
-  const matched = tokens.filter((token) => haystack.includes(token)).length;
-  return matched >= Math.min(2, tokens.length);
+function researchExecutionSignature(execution = {}) {
+  return JSON.stringify([
+    String(execution.toolName || '').trim(),
+    execution.input && typeof execution.input === 'object' ? execution.input : {},
+  ]);
 }
 
 function assessResearchAdequacy({
@@ -380,111 +342,53 @@ function assessResearchAdequacy({
 
   const successful = (Array.isArray(toolExecutions) ? toolExecutions : [])
     .filter(isSuccessfulResearchExecution);
-  const primary = successful.filter((item) => isPrimaryResearchSource(item.evidenceSource));
-  const secondary = successful.filter((item) => isSecondaryResearchSource(item.evidenceSource));
-  const coveredTargets = targets.filter((target) => (
-    successful.some((item) => executionMentionsTarget(item, target))
-  ));
-  const primaryCoveredTargets = targets.filter((target) => (
-    primary.some((item) => executionMentionsTarget(item, target))
-  ));
-  const uncoveredTargets = targets.filter((target) => !coveredTargets.includes(target));
-  const primaryUncoveredTargets = targets.filter((target) => !primaryCoveredTargets.includes(target));
-
-  const requiredPrimarySources = intensity === 'deep'
-    ? (targets.length > 0 ? Math.min(4, targets.length) : 2)
-    : intensity === 'light'
-      ? 1
-      : 0;
-  const requiredSecondarySources = intensity === 'deep' ? 1 : 0;
-  const requiredTargetCoverage = intensity === 'deep'
-    ? targets.length
-    : intensity === 'light'
-      ? Math.min(targets.length, 1)
-      : 0;
-  const requiredPrimaryTargetCoverage = intensity === 'deep'
-    ? targets.length
-    : 0;
-
-  const missing = [];
-  if (primary.length < requiredPrimarySources) {
-    missing.push(
-      `Need ${requiredPrimarySources} primary source open/fetch/inspect step(s); have ${primary.length}.`,
-    );
-  }
-  if (secondary.length < requiredSecondarySources && primary.length < requiredPrimarySources) {
-    missing.push('Need at least one search lead before finishing deep research.');
-  }
-  if (targets.length > 0 && coveredTargets.length < requiredTargetCoverage) {
-    missing.push(
-      `Need evidence for: ${uncoveredTargets.slice(0, 4).join('; ') || targets.slice(0, 4).join('; ')}.`,
-    );
-  }
-  if (targets.length > 0 && primaryCoveredTargets.length < requiredPrimaryTargetCoverage) {
-    missing.push(
-      `Need primary-source evidence for: ${primaryUncoveredTargets.slice(0, 4).join('; ') || targets.slice(0, 4).join('; ')}.`,
-    );
-  }
-  if (intensity === 'deep' && primary.length === 0 && secondary.length > 0) {
-    missing.push('Search snippets alone are not enough; open primary sources for the key claims.');
-  }
-  if (intensity === 'light' && primary.length === 0 && secondary.length === 0) {
-    missing.push('Need at least one successful search or primary-source check before finishing.');
-  }
-
-  const adequate = intensity === 'none' ? true : missing.length === 0;
+  const uniqueEvidenceCandidateCount = new Set(
+    successful.map((item) => researchExecutionSignature(item)),
+  ).size;
+  const structurallyReady = intensity === 'none' || uniqueEvidenceCandidateCount > 0;
+  const missing = structurallyReady
+    ? []
+    : ['No successful source-bearing tool evidence is available for semantic review.'];
   const nextActions = [];
-  if (!adequate) {
-    if (primaryUncoveredTargets.length > 0) {
-      nextActions.push(
-        `Open or fetch primary sources for each remaining target: ${primaryUncoveredTargets.slice(0, 4).join('; ')}.`,
-      );
-    } else if (uncoveredTargets.length > 0) {
-      nextActions.push(
-        `Research each remaining target separately: ${uncoveredTargets.slice(0, 4).join('; ')}.`,
-      );
-    }
-    if (primary.length < requiredPrimarySources) {
-      nextActions.push('Open or fetch primary pages/docs for the remaining claims instead of guessing from memory or snippets.');
-    }
-    if (secondary.length === 0 && intensity === 'deep') {
-      nextActions.push('Run targeted searches, then open the strongest sources.');
-    }
+  if (!structurallyReady) {
+    nextActions.push('Gather source-backed evidence before requesting completion.');
+  } else if (intensity !== 'none') {
+    nextActions.push('Have the completion judge map each requested target to concrete evidence entries and assess source quality.');
   }
 
   return {
     intensity,
-    adequate,
-    requiredPrimarySources,
-    requiredSecondarySources,
-    requiredTargetCoverage,
-    requiredPrimaryTargetCoverage,
-    primarySourceCount: primary.length,
-    secondarySourceCount: secondary.length,
+    adequate: structurallyReady,
+    structurallyReady,
+    semanticReviewRequired: intensity !== 'none',
+    evidenceCandidateCount: successful.length,
+    uniqueEvidenceCandidateCount,
     targets,
-    coveredTargets,
-    primaryCoveredTargets,
-    uncoveredTargets,
-    primaryUncoveredTargets,
+    coveredTargets: [],
+    primaryCoveredTargets: [],
+    uncoveredTargets: intensity === 'none' ? [] : targets,
+    primaryUncoveredTargets: intensity === 'none' ? [] : targets,
     missing,
     nextActions,
-    reason: adequate
+    reason: structurallyReady
       ? (intensity === 'none'
         ? 'No research burden for this run.'
-        : 'Research evidence covers the requested targets.')
+        : 'Source candidates exist; the AI completion judge must still validate target coverage and source quality.')
       : clampResearchText(missing.join(' ') || 'Research evidence is still incomplete.', 320),
   };
 }
 
 function formatResearchAdequacyGuidance(assessment = null) {
-  if (!assessment || assessment.adequate !== false) return '';
+  if (!assessment || assessment.intensity === 'none') return '';
   const lines = [
-    'Research self-check: evidence is still incomplete for this run.',
+    assessment.structurallyReady
+      ? 'Research self-check: source candidates exist, but semantic target coverage is not inferred from tool names, arguments, or token overlap.'
+      : 'Research self-check: no successful source evidence is available yet.',
     assessment.reason ? `Gap: ${assessment.reason}` : '',
     assessment.nextActions?.length
       ? `Next safe steps:\n- ${assessment.nextActions.join('\n- ')}`
       : '',
-    'Do not complete with memory, guesses, or a partial comparison while these gaps remain. Gather the missing evidence first, or return a blocker that names exactly what could not be verified.',
+    'The completion judge must explicitly map every requested target to supporting evidence and judge whether that evidence is primary, secondary, or merely contextual.',
   ];
   return lines.filter(Boolean).join('\n');
 }
@@ -569,6 +473,8 @@ module.exports = {
   isSubstantiveProgressEvidence,
   isSubstantiveProgressToolName,
   resolveResearchIntensity,
+  selectResearchEvidenceCandidates,
+  summarizeResearchEvidenceCatalog,
   summarizeProgressToolExecutions,
   summarizeToolExecutions,
   summarizeAvailableTools,

package/server/services/ai/tools.js

@@ -2400,6 +2400,13 @@ async function executeTool(toolName, args, context, engine) {
             if (!engine || !runId) {
                 return { error: 'Interim updates require an active run.' };
             }
+            if (engine.getRunMeta(runId)?.messagingContext?.behavior?.isGroup === true) {
+                return {
+                    sent: false,
+                    skipped: true,
+                    reason: 'Interim progress updates are suppressed in shared rooms.',
+                };
+            }
             const interimContent = typeof args.content === 'string' ? args.content : '';
             const expectsReply = args.expects_reply === true;
             const deferFollowUp = args.defer_follow_up === true;
@@ -2495,13 +2502,58 @@ async function executeTool(toolName, args, context, engine) {
             if (triggerSource === 'messaging' && originDelivery) {
                 await engine?.stopMessagingProgressSupervisor?.(runId);
             }
-            const sendResult = await manager.sendMessage(userId, args.platform, args.to, args.content, {
-                agentId,
-                mediaPath: args.media_path,
-                runId,
-                persistConversation: triggerSource === 'schedule' || triggerSource === 'tasks',
-                signal,
-            });
+            const behavior = runState?.messagingContext?.behavior;
+            const behaviorPipeline = app?.locals?.behaviorPipeline;
+            let deliveredContent = normalizedMessage;
+            let sendResult;
+            if (
+                originDelivery
+                && behavior
+                && behavior.enabled !== false
+                && behaviorPipeline
+                && typeof behaviorPipeline.refineAndMaybeDeliver === 'function'
+            ) {
+                const behaviorResult = await behaviorPipeline.refineAndMaybeDeliver({
+                    userId,
+                    agentId,
+                    msg: behavior.message,
+                    config: behavior.config,
+                    draft: normalizedMessage,
+                    messagingManager: manager,
+                    runId,
+                    signal,
+                    mediaPath: args.media_path,
+                    turnEpoch: behavior.turnEpoch,
+                    deliver: true,
+                });
+                deliveredContent = behaviorResult.content;
+                if (behaviorResult.delivered) {
+                    sendResult = { success: true, behavior: true, result: behaviorResult.delivery };
+                } else if (behaviorResult.suppressed) {
+                    markProactiveNoResponse({ runState, deliveryState });
+                    sendResult = {
+                        success: true,
+                        sent: false,
+                        suppressed: true,
+                        reason: behaviorResult.reasonCodes?.[0] || 'behavior_suppressed',
+                    };
+                } else {
+                    sendResult = {
+                        success: false,
+                        error: behaviorResult.delivery?.error
+                            || behaviorResult.delivery?.reason
+                            || 'Behavior delivery was not confirmed.',
+                    };
+                }
+            } else {
+                sendResult = await manager.sendMessage(userId, args.platform, args.to, args.content, {
+                    agentId,
+                    mediaPath: args.media_path,
+                    runId,
+                    persistConversation: triggerSource === 'schedule' || triggerSource === 'tasks',
+                    signal,
+                });
+            }
             // Track that the agent explicitly sent a message during this run
             if (
                 !suppressReply
@@ -2509,7 +2561,7 @@ async function executeTool(toolName, args, context, engine) {
                 && sendResult?.suppressed !== true
                 && originDelivery
             ) {
-                markProactiveMessageSent({ runState, deliveryState, content: normalizedMessage });
+                markProactiveMessageSent({ runState, deliveryState, content: deliveredContent });
                 if (runState && triggerSource === 'messaging') {
                     runState.explicitMessageSent = true;
                 }

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,
+};