#!/usr/bin/env node

const http = require('http');

const fs = require('fs');

const path = require('path');

const NCRequestManager = require('./src/lib/nc-request-manager');

const CredentialCache = require('./src/lib/credential-cache');

const CredentialBroker = require('./src/lib/credential-broker');

const TalkSignatureVerifier = require('./src/lib/talk-signature-verifier');

const { createErrorHandler } = require('./src/lib/errors/error-handler');

const { TalkSendQueue } = require('./src/lib/talk/talk-send-queue');

const appConfig = require('./src/lib/config');

const { createServerComponents } = require('./src/lib/server/index');

let ContextLoader, LearningLog;

try {

({ ContextLoader } = require('./src/lib/knowledge/context-loader'));

({ LearningLog } = require('./src/lib/knowledge/learning-log'));

} catch {

console.warn('[WARN] Knowledge modules not available, agent memory disabled');

let LLMRouter, AuditLogger, CalendarHandler, EmailHandler, CalDAVClient;

try {

const llmModule = require('./src/lib/llm');

LLMRouter = llmModule.LLMRouter;

} catch {

console.warn('[WARN] LLM Router not available, using stub');

LLMRouter = null;

try {

AuditLogger = require('./lib/audit-logger');

} catch {

console.warn('[WARN] Audit Logger not available, using console');

AuditLogger = null;

try {

CalDAVClient = require('./src/lib/integrations/caldav-client');

} catch {

console.warn('[WARN] CalDAV Client not available');

CalDAVClient = null;

try {

CalendarHandler = require('./src/lib/handlers/calendar-handler');

} catch {

console.warn('[WARN] Calendar Handler not available');

CalendarHandler = null;

try {

EmailHandler = require('./src/lib/handlers/email-handler');

} catch {

console.warn('[WARN] Email Handler not available');

EmailHandler = null;

let DeckClient;

try {

DeckClient = require('./src/lib/integrations/deck-client');

} catch {

console.warn('[WARN] Deck Client not available');

DeckClient = null;

let NewsClient;

try {

({ NewsClient } = require('./src/lib/integrations/news-client'));

} catch {

console.warn('[WARN] NewsClient not available');

NewsClient = null;

let NCFilesClient, NCSearchClient, TextExtractor;

try {

({ NCFilesClient } = require('./src/lib/integrations/nc-files-client'));

} catch {

console.warn('[WARN] NCFilesClient not available');

NCFilesClient = null;

try {

({ NCSearchClient } = require('./src/lib/integrations/nc-search-client'));

} catch {

console.warn('[WARN] NCSearchClient not available');

NCSearchClient = null;

try {

({ TextExtractor } = require('./src/lib/extraction/text-extractor'));

} catch {

console.warn('[WARN] TextExtractor not available');

TextExtractor = null;

let CollectivesClient;

try {

CollectivesClient = require('./src/lib/integrations/collectives-client');

} catch {

console.warn('[WARN] CollectivesClient not available');

CollectivesClient = null;

const ResilientWikiWriter = require('./src/lib/integrations/resilient-wiki-writer');

let SearXNGClient, WebReader;

try {

({ SearXNGClient } = require('./src/lib/integrations/searxng-client'));

({ WebReader } = require('./src/lib/integrations/web-reader'));

} catch {

console.warn('[WARN] Web tools not available');

SearXNGClient = null;

WebReader = null;

let ContactsClient;

try {

ContactsClient = require('./src/lib/integrations/contacts-client');

} catch {

console.warn('[WARN] ContactsClient not available');

ContactsClient = null;

let CockpitManager;

try {

CockpitManager = require('./src/lib/integrations/cockpit-manager');

} catch {

console.warn('[WARN] CockpitManager not available');

CockpitManager = null;

let PersonalBoardManager;

try {

PersonalBoardManager = require('./src/lib/integrations/personal-board-manager');

} catch {

console.warn('[WARN] PersonalBoardManager not available');

PersonalBoardManager = null;

let SelfRecovery;

try {

SelfRecovery = require('./src/lib/agent/self-recovery');

} catch {

console.warn('[WARN] SelfRecovery not available');

SelfRecovery = null;

let RSVPTracker;

try {

RSVPTracker = require('./src/lib/integrations/rsvp-tracker');

} catch {

console.warn('[WARN] RSVPTracker not available');

RSVPTracker = null;

let MeetingComposer;

try {

MeetingComposer = require('./src/lib/calendar/meeting-composer');

} catch {

console.warn('[WARN] MeetingComposer not available');

MeetingComposer = null;

let ensureMeetingsBoard;

try {

ensureMeetingsBoard = require('./src/lib/calendar/ensure-meetings-board');

} catch {

console.warn('[WARN] ensureMeetingsBoard not available');

ensureMeetingsBoard = null;

let BotEnroller;

try {

BotEnroller = require('./src/lib/integrations/bot-enroller');

} catch {

console.warn('[WARN] BotEnroller not available');

BotEnroller = null;

let RoomMonitor;

try {

RoomMonitor = require('./src/lib/integrations/room-monitor');

} catch {

console.warn('[WARN] RoomMonitor not available');

RoomMonitor = null;

let SessionPersister;

try {

SessionPersister = require('./src/lib/integrations/session-persister');

} catch {

console.warn('[WARN] SessionPersister not available');

SessionPersister = null;

let MemorySearcher;

try {

MemorySearcher = require('./src/lib/integrations/memory-searcher');

} catch {

console.warn('[WARN] MemorySearcher not available');

MemorySearcher = null;

let WarmMemory;

try {

WarmMemory = require('./src/lib/integrations/warm-memory');

} catch {

console.warn('[WARN] WarmMemory not available');

WarmMemory = null;

let NCStatusIndicator;

try {

NCStatusIndicator = require('./src/lib/integrations/nc-status-indicator');

} catch {

console.warn('[WARN] NCStatusIndicator not available');

NCStatusIndicator = null;

let HeartbeatManager;

try {

HeartbeatManager = require('./src/lib/integrations/heartbeat-manager');

} catch {

console.warn('[WARN] HeartbeatManager not available');

HeartbeatManager = null;

let HeartbeatIntelligence;

try {

HeartbeatIntelligence = require('./src/lib/integrations/heartbeat-intelligence');

} catch {

console.warn('[WARN] HeartbeatIntelligence not available');

HeartbeatIntelligence = null;

let WorkflowBoardDetector, WorkflowEngine;

try {

WorkflowBoardDetector = require('./src/lib/workflows/workflow-board-detector');

WorkflowEngine = require('./src/lib/workflows/workflow-engine');

} catch {

console.warn('[WARN] Workflow Engine modules not available');

WorkflowBoardDetector = null;

WorkflowEngine = null;

let InfraMonitor;

try {

InfraMonitor = require('./src/lib/integrations/infra-monitor');

} catch {

console.warn('[WARN] InfraMonitor not available');

InfraMonitor = null;

let SelfHealClient;

try {

SelfHealClient = require('./src/lib/clients/self-heal-client');

} catch {

console.warn('[WARN] SelfHealClient not available');

SelfHealClient = null;

let WhisperClient, AudioConverter;

try {

WhisperClient = require('./src/lib/providers/whisper-client');

AudioConverter = require('./src/lib/providers/audio-converter');

} catch {

console.warn('[WARN] Voice pipeline modules not available');

WhisperClient = null;

AudioConverter = null;

let FallbackNotifier;

try {

FallbackNotifier = require('./src/lib/llm/fallback-notifier');

} catch {

console.warn('[WARN] FallbackNotifier not available');

FallbackNotifier = null;

let SpeachesClient, VoiceManager;

try {

({ SpeachesClient, VoiceManager } = require('./src/lib/voice'));

} catch {

console.warn('[WARN] VoiceManager modules not available');

SpeachesClient = null;

VoiceManager = null;

let KnowledgeBoard;

try {

({ KnowledgeBoard } = require('./src/lib/knowledge/knowledge-board'));

} catch {

console.warn('[WARN] KnowledgeBoard not available');

KnowledgeBoard = null;

let ActivityPoller, WebhookReceiver;

try {

({ ActivityPoller } = require('./src/lib/nc-flow/activity-poller'));

({ WebhookReceiver } = require('./src/lib/nc-flow/webhook-receiver'));

} catch {

console.warn('[WARN] NC Flow heartbeat modules not available');

ActivityPoller = null;

WebhookReceiver = null;

let DocumentIngestor;

try {

DocumentIngestor = require('./src/lib/integrations/document-ingestor');

} catch {

console.warn('[WARN] DocumentIngestor not available');

DocumentIngestor = null;

let IngestionCache;

try {

IngestionCache = require('./src/lib/memory/ingestion-cache');

} catch {

console.warn('[WARN] IngestionCache not available');

IngestionCache = null;

let SkillForgeHandler, TemplateLoader, TemplateEngine, SecurityScanner, SkillActivator, ToolActivator, HttpToolExecutor, OAuthBroker;

try {

({ SkillForgeHandler } = require('./src/lib/handlers/skill-forge-handler'));

({ TemplateLoader, TemplateEngine, SecurityScanner, SkillActivator, ToolActivator, HttpToolExecutor, OAuthBroker } = require('./src/skill-forge'));

} catch {

console.warn('[WARN] Skill Forge modules not available');

SkillForgeHandler = null;

let EmailMonitor;

try {

EmailMonitor = require('./src/lib/services/email-monitor');

} catch {

console.warn('[WARN] Email Monitor not available');

EmailMonitor = null;

let SessionManager;

try {

SessionManager = require('./src/security/session-manager');

} catch {

console.warn('[WARN] SessionManager not available');

SessionManager = null;

let DailyBriefing;

try {

({ DailyBriefing } = require('./src/lib/agent/daily-briefing'));

} catch {

console.warn('[WARN] DailyBriefing not available');

DailyBriefing = null;

let ProactiveEvaluator;

try {

({ ProactiveEvaluator } = require('./src/lib/agent/proactive-evaluator'));

} catch {

console.warn('[WARN] ProactiveEvaluator not available');

ProactiveEvaluator = null;

let ReferenceResolver;

try {

({ ReferenceResolver } = require('./src/lib/agent/reference-resolver'));

} catch {

console.warn('[WARN] ReferenceResolver not available');

ReferenceResolver = null;

let AgentLoop, ToolRegistry, OllamaToolsProvider, SecretsGuard, ToolGuard, PromptGuard, SystemTagsClient, ProviderChain, RouterChatBridge, GuardrailEnforcer;

try {

({ AgentLoop } = require('./src/lib/agent/agent-loop'));

({ ToolRegistry } = require('./src/lib/agent/tool-registry'));

({ OllamaToolsProvider } = require('./src/lib/agent/providers/ollama-tools'));

({ ProviderChain } = require('./src/lib/agent/providers/provider-chain'));

({ RouterChatBridge } = require('./src/lib/agent/providers/router-chat-bridge'));

({ SecretsGuard } = require('./src/security/guards/secrets-guard'));

({ ToolGuard } = require('./src/security/guards/tool-guard'));

({ PromptGuard } = require('./src/security/guards/prompt-guard'));

({ SystemTagsClient } = require('./src/lib/nc-flow/system-tags'));

({ GuardrailEnforcer } = require('./src/lib/agent/guardrail-enforcer'));

} catch (err) {

console.warn(`[WARN] AgentLoop modules not fully available: ${err.message}`);

AgentLoop = null;

const CostTracker = require('./src/lib/llm/cost-tracker');

let ModelScout, MicroPipeline, MemoryContextEnricher, DeferralQueue;

try {

({ ModelScout } = require('./src/lib/providers/model-scout'));

MicroPipeline = require('./src/lib/agent/micro-pipeline');

MemoryContextEnricher = require('./src/lib/agent/memory-context-enricher');

DeferralQueue = require('./src/lib/agent/deferral-queue');

} catch (err) {

console.warn(`[WARN] Local Intelligence modules not available: ${err.message}`);

ModelScout = null;

MicroPipeline = null;

MemoryContextEnricher = null;

DeferralQueue = null;

const CONFIG = {

port: parseInt(process.env.PORT) || appConfig.server.port,

nc: {

url: process.env.NC_URL || appConfig.nextcloud.url,

username: process.env.NC_USER || appConfig.nextcloud.username

},

security: {

// Backend URLs allowed to send webhooks (populated from config or env)

allowedBackends: (process.env.NC_TALK_BACKENDS || '')

.split(',')

.map(s => s.trim())

.filter(Boolean),

strictMode: process.env.STRICT_MODE !== 'false'

},

claude: {

modelPremium: process.env.CLAUDE_MODEL_PREMIUM || appConfig.claude.modelPremium,

modelStandard: process.env.CLAUDE_MODEL_STANDARD || appConfig.claude.modelStandard

},

ollama: {

url: process.env.OLLAMA_URL || appConfig.ollama.url,

model: process.env.OLLAMA_MODEL || appConfig.ollama.model,

modelCredential: process.env.OLLAMA_MODEL_CREDENTIAL || process.env.OLLAMA_MODEL || appConfig.ollama.modelCredential,

timeout: appConfig.ollama.timeout,

toolTimeout: appConfig.ollama.toolTimeout

},

deck: {

boardId: parseInt(process.env.DECK_BOARD_ID) || appConfig.deck.boardId

},

heartbeat: {

intervalMs: parseInt(process.env.HEARTBEAT_INTERVAL) || appConfig.heartbeat.intervalMs,

quietHoursStart: parseInt(process.env.QUIET_START) || appConfig.heartbeat.quietHoursStart,

quietHoursEnd: parseInt(process.env.QUIET_END) || appConfig.heartbeat.quietHoursEnd,

deckEnabled: appConfig.heartbeat.deckEnabled,

caldavEnabled: appConfig.heartbeat.caldavEnabled,

maxTasksPerCycle: appConfig.heartbeat.maxTasksPerCycle

}

if (CONFIG.security.allowedBackends.length === 0) {

CONFIG.security.allowedBackends.push(...appConfig.security.allowedBackends);

let ncRequestManager = null;

let credentialCache = null;

let credentialBroker = null;

let signatureVerifier = null;

let llmRouter = null;

let llmProviderConfigs = {}; // YAML provider definitions (adapter, credentialName, model)

let auditLogger = null;

let caldavClient = null;

let calendarHandler = null;

let emailHandler = null;

let emailMonitor = null;

let deckClient2 = null; // DeckClient for message routing (separate from heartbeat)

let ncFilesClient = null;

let ncSearchClient = null;

let textExtractor = null;

let collectivesClient = null;

let resilientWriter = null;

let contactsClient = null;

let rsvpTracker = null; // Initialized here; consumed by HeartbeatManager in bot.js

let meetingComposer = null;

let skillForgeHandler = null;

let talkQueue = null;

let defaultTalkToken = appConfig.talk.primaryRoom || null; // Primary room for proactive notifications

let contextLoader = null;

let learningLog = null;

let agentLoop = null; // Session 14: AgentLoop instance

let routerChatBridge = null; // Session B2: RouterChatBridge for dynamic provider registration

let costTracker = null; // Cost metering: per-call audit + enriched cost reporting

let dailyBriefing = null; // First-message-of-day briefing

let cockpitManager = null; // Session 27: Cockpit (Deck as control plane)

let botEnroller = null; // Auto-enable Talk bot in rooms

let sessionManager = null; // Session 29b: shared session manager

let sessionPersister = null; // Session 29b: persist expired session summaries to wiki

let memorySearcher = null; // Session 29b: keyword-based memory search over wiki pages

let warmMemory = null; // Session M1: warm memory layer (WARM.md)

let sessionCleanupTimer = null; // Periodic SessionManager cleanup

let webhookErrorHandler = null;

let serverComponents = null; // Decomposed server components (webhook, command, health, message processor)

let heartbeatManager = null; // HeartbeatManager instance (proactive operations)

let oauthBroker = null; // OAuth 2.0 broker for SkillForge token lifecycle

let knowledgeBoard = null; // KnowledgeBoard for verification tracking

let ncFlowActivityPoller = null; // NC Flow activity poller for heartbeat events

let ncFlowWebhookReceiver = null; // NC Flow webhook receiver for heartbeat events

let ncStatusIndicator = null; // NC Status Indicator (sets Molti's NC user status)

let roomMonitor = null; // RoomMonitor (instant welcome messages for new rooms)

let whisperClient = null; // Session 37: WhisperClient for STT transcription

let audioConverter = null; // Session 37: AudioConverter for audio format conversion

let voiceManager = null; // Session V2: VoiceManager for mode-aware voice orchestration

let infraMonitor = null; // Session 38: InfraMonitor for service health probing

let selfHealClient = null; // Self-heal daemon client for remote service restarts

let microPipeline = null; // Local Intelligence: MicroPipeline for local-only mode

let activityLogger = null; // Two-Layer Memory: Layer 1 raw activity log

let deferralQueue = null; // Local Intelligence: DeferralQueue for deferred complex tasks

let intentRouter = null; // IntentRouter: LLM-powered intent classification

let coAccessGraph = null; // Semantic Awareness: co-access pattern graph

let documentIngestor = null; // Document Ingestion: file → text → entities → knowledge

let embeddingClient = null; // Semantic Awareness: Ollama embedding client

let vectorStore = null; // Semantic Awareness: SQLite vector store

let gapDetector = null; // Semantic Awareness: knowledge gap detection

let rhythmTracker = null; // Semantic Awareness: user rhythm tracking

let knowledgeGraph = null; // Knowledge Graph: entity/triple store

let entityExtractor = null; // Knowledge Graph: entity extraction from text

let dailyDigest = null; // Episodic Memory: daily digest page generation

async function consoleAuditLog(event, data) {

const timestamp = new Date().toISOString();

console.log(`[AUDIT] ${timestamp} ${event}:`, JSON.stringify(data).substring(0, 200));

function _extractSection(markdown, sectionName) {

function _buildProactiveEvaluator(agentLoop, llmRouter, talkQueue, appConfig) {

function _buildReferenceResolver(llmRouter) {

async function notifyUser(notification) {

async function initialize() {