@auxiora/runtime 1.3.1 → 1.10.0

package/dist/index.js

@@ -10,12 +10,12 @@ import { audit } from '@auxiora/audit';
 import { getWorkspacePath, getSoulPath, getAgentsPath, getIdentityPath, getUserPath, getBehaviorsPath, getWebhooksPath, getScreenshotsDir, } from '@auxiora/core';
 import { createArchitect, ARCHITECT_BASE_PROMPT, VaultStorageAdapter } from '@auxiora/personality/architect';
 import { toolRegistry, toolExecutor, initializeToolExecutor, ToolPermission, setBrowserManager, setWebhookManager, setBehaviorManager, setProviderFactory, setOrchestrationEngine, setResearchEngine, setClipboardMonitor, setAppController, setSystemStateMonitor, setEmailIntelligence, setCalendarIntelligence, setContactGraph, setContextRecall, setComposeEngine, setGrammarChecker, setLanguageDetector, } from '@auxiora/tools';
-import { ResearchEngine } from '@auxiora/research';
+import { ResearchEngine, ResearchIntentDetector, DeepResearchOrchestrator, ReportGenerator } from '@auxiora/research';
 import { OrchestrationEngine } from '@auxiora/orchestrator';
 import * as crypto from 'node:crypto';
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
-import { BehaviorManager } from '@auxiora/behaviors';
+import { BehaviorManager, evaluateConditions } from '@auxiora/behaviors';
 import { BrowserManager } from '@auxiora/browser';
 import { ClipboardMonitor, AppController, SystemStateMonitor } from '@auxiora/os-bridge';
 import { VoiceManager } from '@auxiora/voice';
@@ -31,7 +31,8 @@ import { createLoopDetectionState, recordToolCall, recordToolOutcome, detectLoop
 import { UserManager } from '@auxiora/social';
 import { WorkflowEngine, ApprovalManager, AutonomousExecutor } from '@auxiora/workflows';
 import { AgentProtocol, MessageSigner, AgentDirectory } from '@auxiora/agent-protocol';
-import { AmbientPatternEngine, QuietNotificationManager, BriefingGenerator, AnticipationEngine, AmbientScheduler, DEFAULT_AMBIENT_SCHEDULER_CONFIG, NotificationOrchestrator } from '@auxiora/ambient';
+import { Updater, InstallationDetector, VersionChecker, HealthChecker, createStrategyMap } from '@auxiora/updater';
+import { AmbientPatternEngine, QuietNotificationManager, BriefingGenerator, AnticipationEngine, AmbientScheduler, DEFAULT_AMBIENT_SCHEDULER_CONFIG, NotificationOrchestrator, AmbientAwarenessCollector } from '@auxiora/ambient';
 import { NotificationHub, DoNotDisturbManager } from '@auxiora/notification-hub';
 import { ConnectorRegistry, AuthManager as ConnectorAuthManager, TriggerManager } from '@auxiora/connectors';
 import { googleWorkspaceConnector } from '@auxiora/connector-google-workspace';
@@ -48,6 +49,24 @@ import { ContactGraph, ContextRecall } from '@auxiora/contacts';
 import { ComposeEngine, GrammarChecker, LanguageDetector } from '@auxiora/compose';
 import { ScreenCapturer } from '@auxiora/screen';
 import { CapabilityCatalogImpl, HealthMonitorImpl, createIntrospectTool, generatePromptFragment } from '@auxiora/introspection';
+import { JobQueue } from '@auxiora/job-queue';
+import { Consciousness } from '@auxiora/consciousness';
+import { McpClientManager } from '@auxiora/mcp';
+import { GuardrailPipeline } from '@auxiora/guardrails';
+import { collectTransparencyMeta } from './transparency/index.js';
+import { IntentParser as NLIntentParser, AutomationBuilder } from '@auxiora/nl-automation';
+import { BranchManager } from '@auxiora/conversation-branch';
+import { ReActLoop } from '@auxiora/react-loop';
+import { AgentCardBuilder, TaskManager as A2ATaskManager } from '@auxiora/a2a';
+import { CanvasSession } from '@auxiora/canvas';
+import { DocumentStore, ContextBuilder } from '@auxiora/rag';
+import { GraphStore, EntityLinker } from '@auxiora/knowledge-graph';
+import { EvalRunner, EvalStore, exactMatch, containsExpected, lengthRatio, keywordCoverage, sentenceCompleteness, responseRelevance, toxicityScore } from '@auxiora/evaluation';
+import { CodeExecutor, SessionManager as CodeSessionManager } from '@auxiora/code-interpreter';
+import { ImageGenManager, OpenAIImageProvider, ReplicateImageProvider } from '@auxiora/image-gen';
+import { BackupManager } from '@auxiora/backup';
+import { ApprovalQueue } from '@auxiora/approval-queue';
+import { VectorStore } from '@auxiora/vector-store';
 import { setMemoryStore } from '@auxiora/tools';
 import { getAuditLogger } from '@auxiora/audit';
 import { Router } from 'express';
@@ -57,10 +76,20 @@ import { getModesDir } from '@auxiora/core';
 import { fileURLToPath } from 'node:url';
 import { getLogger, generateRequestId, runWithRequestId } from '@auxiora/logger';
 import { SelfAwarenessAssembler, InMemoryAwarenessStorage, ConversationReflector, CapacityMonitor, KnowledgeBoundary, RelationshipModel, TemporalTracker, EnvironmentSensor, MetaCognitor, } from '@auxiora/self-awareness';
+import { EnrichmentPipeline, MemoryStage, ModeStage, ArchitectStage, SelfAwarenessStage } from './enrichment/index.js';
 /**
  * Map Claude Code emulation tool calls to our actual tool names + input format.
  * The model may call CC tools (WebSearch, Bash, etc.) since they're in the request for OAuth compat.
  */
+/**
+ * Claude Code internal tools that have no Auxiora equivalent.
+ * When the model tries to call these, we return a helpful error message
+ * instead of letting them hit the tool executor and waste a round-trip.
+ */
+const CC_ONLY_TOOLS = new Set([
+    'EnterPlanMode', 'ExitPlanMode', 'AskUserQuestion',
+    'NotebookEdit', 'Skill', 'Task', 'TaskOutput',
+]);
 function mapCCToolCall(name, input) {
     switch (name) {
         case 'WebSearch':
@@ -73,7 +102,16 @@ function mapCCToolCall(name, input) {
             return { name: 'file_read', input: { path: input.file_path } };
         case 'Write':
             return { name: 'file_write', input: { path: input.file_path, content: input.content } };
+        case 'Edit':
+            return { name: 'file_write', input: { path: input.file_path, content: input.new_string } };
+        case 'Glob':
+            return { name: 'file_list', input: { path: input.path || '.', pattern: input.pattern } };
+        case 'Grep':
+            return { name: 'bash', input: { command: `grep -r "${(input.pattern || '').replace(/"/g, '\\"')}" ${input.path || '.'} --include="${input.glob || '*'}" -l 2>/dev/null | head -20` } };
         default:
+            if (CC_ONLY_TOOLS.has(name)) {
+                return { name, input, skip: `Tool "${name}" is not available. Do not use Claude Code internal tools. Respond using text only or use the available tools: bash, web_browser, file_read, file_write, file_list.` };
+            }
             return { name, input };
     }
 }
@@ -113,6 +151,7 @@ export class Auxiora {
     intentParser;
     actionPlanner;
     orchestrationEngine;
+    jobQueue;
     // [P14] Team / Social
     userManager;
     workflowEngine;
@@ -139,18 +178,58 @@ export class Auxiora {
     connectorAuthManager;
     triggerManager;
     ambientScheduler;
+    ambientDetectTimer;
+    ambientAwarenessCollector;
     notificationHub;
     dndManager;
     notificationOrchestrator;
+    researchEngine;
+    intentDetector = new ResearchIntentDetector();
+    researchJobs = new Map();
+    researchJobExpiry;
     capabilityCatalog;
     healthMonitor;
     capabilityPromptFragment = '';
     selfAwarenessAssembler;
     architect;
     architectBridge = null;
+    architectResetChats = new Set();
     architectAwarenessCollector = null;
+    enrichmentPipeline;
+    lastToolsUsed = new Map();
+    consciousness;
+    mcpClientManager;
+    selfModelCache;
+    userModelCache;
+    static MODEL_CACHE_TTL = 60_000;
     // Security floor
     securityFloor;
+    guardrailPipeline;
+    evalRunner;
+    evalStore;
+    documentStore;
+    contextBuilder;
+    knowledgeGraph;
+    entityLinker;
+    imageGenManager;
+    updater;
+    installationDetector;
+    versionChecker;
+    codeExecutor;
+    codeSessionManager;
+    backupManager;
+    backupStore = new Map();
+    nlIntentParser = new NLIntentParser();
+    automationBuilder = new AutomationBuilder();
+    branchManagers = new Map();
+    approvalQueue;
+    vectorStore;
+    reactLoops = new Map();
+    reactResults = new Map();
+    a2aTaskManager = new A2ATaskManager();
+    a2aAgentCard;
+    canvasSessions = new Map();
+    sandboxManager;
     sessionEscalation = new Map();
     /** Tracks the most recent channel ID for each connected channel type (e.g. discord → snowflake).
      *  Used for proactive delivery (behaviors, ambient briefings). Persisted to disk. */
@@ -178,6 +257,23 @@ export class Auxiora {
             this.logger.debug('Auto-approving tool', { toolName, params });
             return true;
         });
+        // Initialize MCP client connections
+        if (this.config.mcp && Object.keys(this.config.mcp.servers).length > 0) {
+            try {
+                this.mcpClientManager = new McpClientManager(toolRegistry, this.config.mcp);
+                await this.mcpClientManager.connectAll();
+                const status = this.mcpClientManager.getStatus();
+                this.logger.info('MCP client initialized', {
+                    servers: status.size,
+                    tools: [...status.values()].reduce((sum, s) => sum + s.toolCount, 0),
+                });
+            }
+            catch (err) {
+                this.logger.warn('Failed to initialize MCP client', {
+                    error: err instanceof Error ? err : new Error(String(err)),
+                });
+            }
+        }
         // Initialize sessions
         this.sessions = new SessionManager({
             maxContextTokens: this.config.session.maxContextTokens,
@@ -226,6 +322,7 @@ export class Auxiora {
                         searchTimeout: this.config.research?.searchTimeout ?? 10_000,
                         fetchTimeout: this.config.research?.fetchTimeout ?? 15_000,
                     });
+                    this.researchEngine = researchEngine;
                     setResearchEngine(researchEngine);
                     this.logger.info(`Research engine initialized (Brave Search configured${provider ? ', AI extraction enabled' : ''})`);
                 }
@@ -240,6 +337,104 @@ export class Auxiora {
         await this.loadPersonality();
         // Initialize modes system
         await this.initializeModes();
+        // Initialize guardrails pipeline (if enabled)
+        if (this.config.guardrails?.enabled !== false) {
+            this.guardrailPipeline = new GuardrailPipeline({
+                piiDetection: this.config.guardrails?.piiDetection,
+                promptInjection: this.config.guardrails?.promptInjection,
+                toxicityFilter: this.config.guardrails?.toxicityFilter,
+                blockThreshold: this.config.guardrails?.blockThreshold,
+                redactPii: this.config.guardrails?.redactPii,
+            });
+            this.logger.info('Guardrails pipeline initialized');
+        }
+        // Initialize evaluation system
+        this.evalStore = new EvalStore();
+        this.evalRunner = new EvalRunner({
+            exactMatch,
+            containsExpected,
+            lengthRatio,
+            keywordCoverage,
+            sentenceCompleteness,
+            responseRelevance,
+            toxicityScore,
+        });
+        this.logger.info('Evaluation system initialized');
+        // Initialize backup manager
+        this.backupManager = new BackupManager();
+        this.logger.info('Backup manager initialized');
+        // Initialize approval queue
+        this.approvalQueue = new ApprovalQueue();
+        this.logger.info('Approval queue initialized');
+        // Initialize vector store
+        this.vectorStore = new VectorStore({ dimensions: 1536, maxEntries: 100_000 });
+        this.logger.info('Vector store initialized');
+        // Initialize consciousness orchestrator (self-model, journal, monitor, repair)
+        if (this.architect && this.healthMonitor) {
+            try {
+                this.consciousness = new Consciousness({
+                    vault: this.vault,
+                    healthMonitor: this.healthMonitor,
+                    feedbackStore: {
+                        getInsights: () => {
+                            const raw = this.architect.getFeedbackInsights();
+                            return {
+                                ...raw,
+                                suggestedAdjustments: raw.suggestedAdjustments,
+                            };
+                        },
+                    },
+                    correctionStore: {
+                        getStats: () => this.architect.getCorrectionStats(),
+                    },
+                    preferenceHistory: {
+                        detectConflicts: () => this.architect.getPreferenceConflicts(),
+                    },
+                    getResourceMetrics: () => {
+                        const mem = process.memoryUsage();
+                        return {
+                            memoryUsageMb: Math.round(mem.heapUsed / 1024 / 1024),
+                            cpuPercent: 0, // CPU % requires sampling; omit for now
+                            activeConnections: this.gateway?.getConnections().length ?? 0,
+                            uptimeSeconds: Math.round(process.uptime()),
+                        };
+                    },
+                    getCapabilityMetrics: () => {
+                        const tools = toolRegistry.list();
+                        return {
+                            totalCapabilities: tools.length,
+                            healthyCapabilities: tools.length,
+                            degradedCapabilities: [],
+                        };
+                    },
+                    actionExecutor: async (command) => {
+                        this.logger.info('Consciousness repair action (log-only)', { command });
+                        return `[log-only] ${command}`;
+                    },
+                    onNotify: (diagnosis, action) => {
+                        this.logger.info('Consciousness repair notification', {
+                            diagnosis: diagnosis?.description,
+                            action: action.description,
+                        });
+                    },
+                    onApprovalRequest: async () => false, // deny auto-repair initially
+                    decisionLog: {
+                        query: (q) => this.architect.queryDecisions(q),
+                        getDueFollowUps: () => this.architect.getDueFollowUps(),
+                    },
+                    version: '1.4.0',
+                    monitorIntervalMs: 60_000,
+                });
+                await this.consciousness.initialize();
+                this.logger.info('Consciousness orchestrator initialized');
+            }
+            catch (err) {
+                this.logger.warn('Failed to initialize consciousness', { error: err instanceof Error ? err : new Error(String(err)) });
+            }
+        }
+        // Build enrichment pipeline from available subsystems
+        this.buildEnrichmentPipeline();
+        this.logger.info('Enrichment pipeline initialized');
         // Initialize gateway
         this.gateway = new Gateway({
             config: this.config,
@@ -265,20 +460,48 @@ export class Auxiora {
                 this.gateway.broadcast({ type: 'activity', payload: entry }, (client) => client.authenticated);
             }
         };
+        // Initialize durable job queue
+        const jobQueueDbPath = path.join(path.dirname(getBehaviorsPath()), 'jobs.db');
+        this.jobQueue = new JobQueue(jobQueueDbPath, {
+            pollIntervalMs: 2000,
+            concurrency: 5,
+        });
+        // Register behavior handler
+        this.jobQueue.register('behavior', async (payload) => {
+            if (this.behaviors) {
+                await this.behaviors.executeNow(payload.behaviorId);
+            }
+        });
+        // Register ambient pattern flush handler (re-enqueues itself)
+        this.jobQueue.register('ambient-flush', async (_payload, ctx) => {
+            if (this.ambientEngine) {
+                const serialized = this.ambientEngine.serialize();
+                ctx.checkpoint(serialized);
+            }
+            // Re-enqueue next flush in 5 minutes
+            if (this.jobQueue) {
+                this.jobQueue.enqueue('ambient-flush', {}, { scheduledAt: Date.now() + 5 * 60 * 1000 });
+            }
+        });
+        this.jobQueue.start();
+        this.logger.info('Durable job queue initialized');
         // Initialize behavior system
         if (this.providers) {
             this.behaviors = new BehaviorManager({
                 storePath: getBehaviorsPath(),
+                jobQueue: this.jobQueue,
                 executorDeps: {
                     getProvider: () => this.providers.getPrimaryProvider(),
                     sendToChannel: async (channelType, channelId, message) => {
                         this.logger.info('sendToChannel called', { channelType, channelId, hasChannels: !!this.channels });
+                        let delivered = false;
                         // Always broadcast to webchat + persist
                         this.gateway.broadcast({
                             type: 'message',
                             payload: { role: 'assistant', content: message.content },
                         });
                         this.persistToWebchat(message.content);
+                        delivered = true; // webchat broadcast is best-effort but counts
                         // Deliver to all connected external channels
                         if (this.channels) {
                             const connected = this.channels.getConnectedChannels();
@@ -290,12 +513,15 @@ export class Auxiora {
                                 if (!targetId)
                                     continue;
                                 const result = await this.channels.send(ct, targetId, { content: message.content });
-                                if (!result.success) {
+                                if (result.success) {
+                                    delivered = true;
+                                }
+                                else {
                                     this.logger.warn('Channel delivery failed', { channel: ct, targetId, error: new Error(result.error ?? 'unknown') });
                                 }
                             }
                         }
-                        return { success: true };
+                        return { success: delivered };
                     },
                     getSystemPrompt: () => this.systemPrompt,
                     executeWithTools: async (messages, systemPrompt) => {
@@ -779,6 +1005,10 @@ export class Auxiora {
                             if (updates.agent) {
                                 await this.loadPersonality();
                             }
+                            // Re-initialize channels when channel config changes
+                            if (updates.channels) {
+                                await this.reinitializeChannels();
+                            }
                         },
                         getAgentName: () => this.config.agent?.name ?? 'Auxiora',
                         getAgentPronouns: () => this.config.agent?.pronouns ?? 'they/them',
@@ -877,6 +1107,115 @@ export class Auxiora {
             this.gateway.mountRouter('/dashboard', spaRouter);
             this.logger.info('Dashboard enabled at /dashboard');
         }
+        // MCP management API routes
+        this.gateway.mountRouter('/api/v1/mcp', this.createMcpRouter());
+        // Personality management API routes
+        if (this.architect) {
+            const personalityRouter = this.createPersonalityRouter();
+            this.gateway.mountRouter('/api/v1/personality', personalityRouter);
+        }
+        // Ambient agent API routes
+        if (this.ambientEngine) {
+            const ambientRouter = this.createAmbientRouter();
+            this.gateway.mountRouter('/api/v1/ambient', ambientRouter);
+        }
+        // Deep research API routes
+        const researchRouter = this.createResearchRouter();
+        this.gateway.mountRouter('/api/v1/research', researchRouter);
+        // Agent protocol API routes
+        if (this.agentProtocol) {
+            this.gateway.mountRouter('/api/v1/agent-protocol', this.createAgentProtocolRouter());
+        }
+        // Webhooks management API routes
+        if (this.webhookManager) {
+            this.gateway.mountRouter('/api/v1/webhooks', this.createWebhooksRouter());
+        }
+        // Consciousness API routes
+        if (this.consciousness) {
+            this.gateway.mountRouter('/api/v1/consciousness', this.createConsciousnessRouter());
+        }
+        // Voice API routes
+        if (this.voiceManager) {
+            this.gateway.mountRouter('/api/v1/voice', this.createVoiceRouter());
+        }
+        // Trust engine API routes
+        if (this.trustEngine) {
+            this.gateway.mountRouter('/api/v1/trust', this.createTrustRouter());
+        }
+        // Workflow API routes
+        if (this.workflowEngine) {
+            this.gateway.mountRouter('/api/v1/workflows', this.createWorkflowRouter());
+        }
+        // Connector API routes
+        if (this.connectorRegistry) {
+            this.gateway.mountRouter('/api/v1/connectors', this.createConnectorRouter());
+        }
+        // Self-update API routes
+        if (this.updater) {
+            this.gateway.mountRouter('/api/v1/update', this.createUpdateRouter());
+        }
+        // RAG API routes
+        if (this.documentStore) {
+            this.gateway.mountRouter('/api/v1/rag', this.createRagRouter());
+        }
+        // Evaluation API routes
+        if (this.evalStore) {
+            this.gateway.mountRouter('/api/v1/eval', this.createEvalRouter());
+        }
+        // Image generation API routes
+        if (this.imageGenManager) {
+            this.gateway.mountRouter('/api/v1/images', this.createImageRouter());
+        }
+        // Knowledge graph API routes
+        if (this.knowledgeGraph) {
+            this.gateway.mountRouter('/api/v1/knowledge', this.createKnowledgeRouter());
+        }
+        // Code interpreter API routes
+        if (this.codeSessionManager) {
+            this.gateway.mountRouter('/api/v1/code', this.createCodeRouter());
+        }
+        // Backup API routes
+        if (this.backupManager) {
+            this.gateway.mountRouter('/api/v1/backup', this.createBackupRouter());
+        }
+        // Approval queue API routes
+        if (this.approvalQueue) {
+            this.gateway.mountRouter('/api/v1/approvals', this.createApprovalQueueRouter());
+        }
+        // Vector store API routes
+        if (this.vectorStore) {
+            this.gateway.mountRouter('/api/v1/vectors', this.createVectorRouter());
+        }
+        // NL Automation API routes
+        this.gateway.mountRouter('/api/v1/automation', this.createAutomationRouter());
+        // Conversation branch API routes
+        this.gateway.mountRouter('/api/v1/branches', this.createBranchRouter());
+        // ReAct loop API routes
+        this.gateway.mountRouter('/api/v1/react', this.createReactRouter());
+        // A2A (Agent-to-Agent) API routes
+        this.a2aAgentCard = new AgentCardBuilder()
+            .setName('Auxiora')
+            .setDescription('Auxiora AI assistant')
+            .setUrl(`http://${this.config.gateway.host}:${this.config.gateway.port}`)
+            .setVersion('1.0.0')
+            .build();
+        this.gateway.mountRouter('/api/v1/a2a', this.createA2ARouter());
+        // Canvas API routes
+        this.gateway.mountRouter('/api/v1/canvas', this.createCanvasRouter());
+        // Sandbox API routes
+        this.gateway.mountRouter('/api/v1/sandbox', this.createSandboxRouter());
+        // Job queue status endpoint
+        this.gateway.mountRouter('/api/v1/jobs', (() => {
+            const jobsRouter = Router();
+            jobsRouter.get('/status', (_req, res) => {
+                if (!this.jobQueue) {
+                    res.status(503).json({ error: 'Job queue not initialized' });
+                    return;
+                }
+                res.json(this.jobQueue.getStats());
+            });
+            return jobsRouter;
+        })());
         // Initialize plugin system (if enabled)
         if (this.config.plugins?.enabled !== false) {
             const pluginsDir = this.config.plugins?.dir || undefined;
@@ -954,12 +1293,90 @@ export class Auxiora {
         await this.agentDirectory.register(agentId, agentName, agentKeys.publicKey, `http://${agentHost}/api/v1/agent-protocol`);
         this.agentProtocol = new AgentProtocol(agentId, agentSigner, this.agentDirectory);
         this.logger.info('Agent protocol initialized');
+        // Initialize self-update system
+        try {
+            this.installationDetector = new InstallationDetector();
+            this.versionChecker = new VersionChecker('auxiora', 'auxiora');
+            const healthChecker = new HealthChecker(`http://${agentHost}`);
+            const strategies = createStrategyMap();
+            this.updater = new Updater({
+                detector: this.installationDetector,
+                versionChecker: this.versionChecker,
+                healthChecker,
+                strategies,
+            });
+            // Recover from any incomplete previous update
+            const recovery = await this.updater.recoverIfNeeded();
+            if (recovery) {
+                this.logger.warn('Recovered from incomplete update', {
+                    previousVersion: recovery.previousVersion,
+                    targetVersion: recovery.newVersion,
+                });
+            }
+            this.logger.info('Self-update system initialized');
+        }
+        catch (err) {
+            this.logger.warn('Failed to initialize self-update system', {
+                error: err instanceof Error ? err : new Error(String(err)),
+            });
+        }
         // [P15] Initialize ambient intelligence
-        this.ambientEngine = new AmbientPatternEngine();
+        // Restore persisted patterns from vault, or start fresh
+        try {
+            const storedPatterns = this.vault.get('ambient:patterns');
+            this.ambientEngine = storedPatterns
+                ? AmbientPatternEngine.deserialize(storedPatterns)
+                : new AmbientPatternEngine();
+        }
+        catch {
+            this.ambientEngine = new AmbientPatternEngine();
+        }
         this.ambientNotifications = new QuietNotificationManager();
         this.briefingGenerator = new BriefingGenerator();
         this.anticipationEngine = new AnticipationEngine();
+        this.ambientAwarenessCollector = new AmbientAwarenessCollector();
+        if (this.jobQueue) {
+            this.jobQueue.enqueue('ambient-flush', {}, { scheduledAt: Date.now() + 5 * 60 * 1000 });
+        }
         this.logger.info('Ambient intelligence initialized');
+        // Initialize RAG document store
+        this.documentStore = new DocumentStore();
+        this.contextBuilder = new ContextBuilder();
+        this.logger.info('RAG document store initialized');
+        // Initialize image generation (conditional on provider keys)
+        {
+            let openaiKey;
+            let replicateToken;
+            try {
+                openaiKey = this.vault.get('OPENAI_API_KEY');
+            }
+            catch { /* vault locked */ }
+            try {
+                replicateToken = this.vault.get('REPLICATE_API_TOKEN');
+            }
+            catch { /* vault locked */ }
+            if (openaiKey || replicateToken) {
+                this.imageGenManager = new ImageGenManager();
+                if (openaiKey) {
+                    this.imageGenManager.registerProvider(new OpenAIImageProvider(openaiKey));
+                }
+                if (replicateToken) {
+                    this.imageGenManager.registerProvider(new ReplicateImageProvider(replicateToken));
+                }
+                this.logger.info(`Image generation initialized with providers: ${this.imageGenManager.listProviders().join(', ')}`);
+            }
+            else {
+                this.logger.info('Image generation skipped: no OPENAI_API_KEY or REPLICATE_API_TOKEN in vault');
+            }
+        }
+        // Initialize knowledge graph
+        this.knowledgeGraph = new GraphStore();
+        this.entityLinker = new EntityLinker();
+        this.logger.info('Knowledge graph initialized');
+        // Initialize code interpreter
+        this.codeExecutor = new CodeExecutor();
+        this.codeSessionManager = new CodeSessionManager(this.codeExecutor);
+        this.logger.info('Code interpreter initialized');
         // Initialize notification orchestrator
         this.notificationHub = new NotificationHub();
         this.dndManager = new DoNotDisturbManager();
@@ -1060,6 +1477,38 @@ export class Auxiora {
             this.ambientScheduler.start();
             this.logger.info('Ambient scheduler started');
         }
+        // Run pattern detection and persist to vault every 5 minutes
+        const PATTERN_DETECT_INTERVAL = 5 * 60 * 1000;
+        this.ambientDetectTimer = setInterval(async () => {
+            // Poll triggers and route events
+            if (this.triggerManager) {
+                try {
+                    const events = await this.triggerManager.pollAll();
+                    await this.processEventTriggers(events);
+                }
+                catch { /* poll failure */ }
+            }
+            // Detect patterns and persist
+            if (this.ambientEngine) {
+                this.ambientEngine.detectPatterns();
+                try {
+                    await this.vault.add('ambient:patterns', this.ambientEngine.serialize());
+                }
+                catch { /* vault locked */ }
+                // Update awareness collector
+                if (this.ambientAwarenessCollector) {
+                    this.ambientAwarenessCollector.updatePatterns(this.ambientEngine.getPatterns());
+                    if (this.anticipationEngine) {
+                        const anticipations = this.anticipationEngine.generateAnticipations(this.ambientEngine.getPatterns());
+                        this.ambientAwarenessCollector.updateAnticipations(anticipations);
+                    }
+                    this.ambientAwarenessCollector.updateActivity({
+                        eventRate: this.ambientEngine.getEventCount(),
+                        activeBehaviors: 0,
+                    });
+                }
+            }
+        }, PATTERN_DETECT_INTERVAL);
         // [P15] Initialize conversation engine
         this.conversationEngine = new ConversationEngine();
         this.logger.info('Conversation engine initialized');
@@ -1103,12 +1552,13 @@ export class Auxiora {
                 toolCount: p.toolCount, behaviorNames: p.behaviorNames,
             })),
             getFeatures: () => ({
-                behaviors: this.config.features?.behaviors !== false,
-                browser: this.config.features?.browser !== false,
-                voice: !!this.config.features?.voice,
-                webhooks: !!this.config.features?.webhooks,
-                plugins: !!this.config.features?.plugins,
-                memory: this.config.memory?.enabled !== false,
+                behaviors: !!this.behaviors,
+                browser: !!this.browserManager,
+                voice: !!this.voiceManager,
+                webhooks: !!this.webhookManager,
+                plugins: !!(this.pluginLoader && this.pluginLoader.listPlugins().length > 0),
+                memory: !!this.memoryStore,
+                research: !!this.researchEngine,
             }),
             getAuditEntries: async (limit) => {
                 const al = getAuditLogger();
@@ -1121,10 +1571,51 @@ export class Auxiora {
         const initialHealth = { overall: 'healthy', subsystems: [], issues: [], lastCheck: new Date().toISOString() };
         this.capabilityPromptFragment = generatePromptFragment(this.capabilityCatalog.getCatalog(), initialHealth, this.getSelfAwarenessContext());
         const autoFixActions = {
-            reconnectChannel: async () => false,
-            restartBehavior: async (_id) => {
-                // BehaviorManager does not yet expose a resume() method
-                return false;
+            reconnectChannel: async (type) => {
+                if (!this.channels)
+                    return false;
+                try {
+                    await this.channels.disconnect(type);
+                    await this.channels.connect(type);
+                    this.logger.info('Auto-fix: reconnected channel', { type });
+                    return true;
+                }
+                catch (err) {
+                    this.logger.warn('Auto-fix: channel reconnect failed', { type, error: err instanceof Error ? err : new Error(String(err)) });
+                    return false;
+                }
+            },
+            restartBehavior: async (id) => {
+                if (!this.behaviors)
+                    return false;
+                try {
+                    const result = await this.behaviors.update(id, { status: 'active' });
+                    if (!result)
+                        return false;
+                    this.logger.info('Auto-fix: restarted behavior', { id });
+                    return true;
+                }
+                catch (err) {
+                    this.logger.warn('Auto-fix: behavior restart failed', { id, error: err instanceof Error ? err : new Error(String(err)) });
+                    return false;
+                }
+            },
+            switchToFallbackProvider: async () => {
+                const fallbackName = this.config.provider.fallback;
+                if (!fallbackName)
+                    return false;
+                const fallback = this.providers.getFallbackProvider();
+                if (!fallback)
+                    return false;
+                try {
+                    this.providers.setPrimary(fallbackName);
+                    this.logger.info('Auto-fix: switched to fallback provider', { name: fallbackName });
+                    return true;
+                }
+                catch (err) {
+                    this.logger.warn('Auto-fix: provider switch failed', { error: err instanceof Error ? err : new Error(String(err)) });
+                    return false;
+                }
             },
         };
         this.healthMonitor = new HealthMonitorImpl(introspectionSources, autoFixActions);
@@ -1503,6 +1994,38 @@ export class Auxiora {
             this.pluginLoader.setChannelManager(this.channels);
         }
     }
+    async reinitializeChannels() {
+        // Disconnect existing channels gracefully
+        if (this.channels) {
+            try {
+                await this.channels.disconnectAll();
+            }
+            catch (error) {
+                this.logger.warn('Error disconnecting channels during reinit', {
+                    error: error instanceof Error ? error : new Error(String(error)),
+                });
+            }
+            this.channels = undefined;
+        }
+        // Re-initialize with updated config and vault
+        await this.initializeChannels();
+        // Connect the newly initialized channels (cast needed: initializeChannels may set this.channels)
+        const channels = this.channels;
+        if (channels) {
+            try {
+                await channels.connectAll();
+                const connected = channels.getConnectedChannels();
+                if (connected.length > 0) {
+                    this.logger.info(`Channels reconnected: ${connected.join(', ')}`);
+                }
+            }
+            catch (error) {
+                this.logger.warn('Some channels failed to connect during reinit', {
+                    error: error instanceof Error ? error : new Error(String(error)),
+                });
+            }
+        }
+    }
     buildIdentityPreamble(agent) {
         const lines = ['# Agent Identity'];
         lines.push(`You are ${agent.name} (${agent.pronouns}).`);
@@ -1676,6 +2199,9 @@ export class Auxiora {
             if (this.architectAwarenessCollector) {
                 collectors.push(this.architectAwarenessCollector);
             }
+            if (this.ambientAwarenessCollector) {
+                collectors.push(this.ambientAwarenessCollector);
+            }
             this.selfAwarenessAssembler = new SelfAwarenessAssembler(collectors, {
                 tokenBudget: this.config.selfAwareness.tokenBudget ?? 500,
             });
@@ -1703,30 +2229,37 @@ export class Auxiora {
             personalityEngine: this.config.agent.personality ?? 'standard',
         };
     }
-    /** Append Architect context modifier when active, returning context metadata. */
-    applyArchitectEnrichment(prompt, userMessage, chatId) {
+    async getCachedSelfModel() {
+        if (!this.consciousness)
+            return null;
+        const now = Date.now();
+        if (this.selfModelCache && (now - this.selfModelCache.cachedAt) < Auxiora.MODEL_CACHE_TTL) {
+            return this.selfModelCache.snapshot;
+        }
+        try {
+            const snapshot = await this.consciousness.model.synthesize();
+            this.selfModelCache = { snapshot, cachedAt: now };
+            return snapshot;
+        }
+        catch {
+            return this.selfModelCache?.snapshot ?? null;
+        }
+    }
+    getCachedUserModel() {
         if (!this.architect)
-            return { prompt };
-        const output = this.architect.generatePrompt(userMessage);
-        // Bridge handles side effects: persistence, awareness feeding, escalation logging
-        if (this.architectBridge && chatId) {
-            this.architectBridge.afterPrompt(output.detectedContext, output.emotionalTrajectory, output.escalationAlert, chatId);
+            return null;
+        const now = Date.now();
+        if (this.userModelCache && (now - this.userModelCache.cachedAt) < Auxiora.MODEL_CACHE_TTL) {
+            return this.userModelCache.model;
         }
-        const mix = this.architect.getTraitMix(output.detectedContext);
-        const traitWeights = {};
-        for (const [key, val] of Object.entries(mix)) {
-            traitWeights[key] = val;
+        try {
+            const model = this.architect.getUserModel();
+            this.userModelCache = { model, cachedAt: now };
+            return model;
+        }
+        catch {
+            return this.userModelCache?.model ?? null;
         }
-        return {
-            prompt: prompt + '\n\n' + output.contextModifier,
-            architectMeta: {
-                detectedContext: output.detectedContext,
-                activeTraits: output.activeTraits,
-                traitWeights,
-                recommendation: output.recommendation,
-                escalationAlert: output.escalationAlert,
-            },
-        };
     }
     async initializeModes() {
         if (this.config.modes?.enabled === false)
@@ -1750,19 +2283,62 @@ export class Auxiora {
         }
         return state;
     }
-    /** Build enriched prompt with auto-detection (shared by handleMessage and handleChannelMessage). */
-    buildModeEnrichedPrompt(content, modeState, memorySection, channelType) {
-        if (modeState.activeMode === 'auto' && this.modeDetector && this.config.modes?.autoDetection !== false) {
-            const detection = this.modeDetector.detect(content, { currentState: modeState });
-            if (detection) {
-                modeState.lastAutoMode = detection.mode;
-                modeState.autoDetected = true;
-                modeState.lastSwitchAt = Date.now();
-                const tempState = { ...modeState, activeMode: detection.mode };
-                return this.promptAssembler.enrichForMessage(tempState, memorySection, this.userPreferences, undefined, channelType);
-            }
+    buildEnrichmentPipeline() {
+        this.enrichmentPipeline = new EnrichmentPipeline();
+        // Stage 1: Memory (order 100)
+        if (this.memoryStore && this.memoryRetriever) {
+            this.enrichmentPipeline.addStage(new MemoryStage(this.memoryStore, this.memoryRetriever));
+        }
+        // Stage 2: Mode detection + security (order 200)
+        if (this.modeDetector && this.promptAssembler) {
+            this.enrichmentPipeline.addStage(new ModeStage({
+                detector: this.modeDetector,
+                assembler: this.promptAssembler,
+                securityFloor: this.securityFloor,
+                userPreferences: this.userPreferences,
+                getModeState: (sessionId) => this.getSessionModeState(sessionId),
+            }));
+        }
+        // Stage 3: Architect (order 300)
+        if (this.architect) {
+            this.enrichmentPipeline.addStage(new ArchitectStage(this.architect, this.architectBridge ?? undefined, this.architectAwarenessCollector ?? undefined, () => this.getCachedSelfModel(), () => this.getCachedUserModel()));
+        }
+        // Stage 4: Self-awareness (order 400)
+        if (this.selfAwarenessAssembler) {
+            this.enrichmentPipeline.addStage(new SelfAwarenessStage(this.selfAwarenessAssembler));
+        }
+    }
+    GUARDRAIL_BLOCK_MESSAGE = 'I\'m not able to process that request. If you believe this is an error, please rephrase your message.';
+    buildModelIdentityFragment(provider, model) {
+        const activeModel = model ?? provider.defaultModel;
+        const caps = provider.metadata.models[activeModel];
+        return '\n\n[Model Identity]\n'
+            + `You are running as ${activeModel} via ${provider.metadata.displayName}.`
+            + (caps ? ` Context window: ${caps.maxContextTokens.toLocaleString()} tokens.` : '')
+            + (caps?.supportsVision ? ' You have vision capabilities.' : '')
+            + ` Today's date: ${new Date().toISOString().slice(0, 10)}.`;
+    }
+    checkInputGuardrails(content) {
+        if (!this.guardrailPipeline)
+            return null;
+        const result = this.guardrailPipeline.scanInput(content);
+        if (result.action !== 'allow') {
+            this.logger.debug('Input guardrail triggered', { action: result.action, threatCount: result.threats.length });
+        }
+        return result;
+    }
+    checkOutputGuardrails(response) {
+        if (!this.guardrailPipeline || this.config.guardrails?.scanOutput === false || !response) {
+            return { response, wasModified: false, action: 'allow' };
+        }
+        const result = this.guardrailPipeline.scanOutput(response);
+        if (result.action === 'block') {
+            return { response: this.GUARDRAIL_BLOCK_MESSAGE, wasModified: true, action: 'block' };
         }
-        return this.promptAssembler.enrichForMessage(modeState, memorySection, this.userPreferences, undefined, channelType);
+        if (result.action === 'redact' && result.redactedContent) {
+            return { response: result.redactedContent, wasModified: true, action: 'redact' };
+        }
+        return { response, wasModified: false, action: result.action };
     }
     async handleMessage(client, message) {
         const { id: requestId, payload } = message;
@@ -1774,6 +2350,55 @@ export class Auxiora {
             }
             return;
         }
+        // Handle message feedback (thumbs up/down for Architect learning)
+        if (message.type === 'message_feedback') {
+            const fbPayload = payload;
+            if (this.architect && fbPayload?.messageId && fbPayload?.rating) {
+                // Look up the message to get architectDomain from metadata
+                let domain = 'general';
+                if (fbPayload.sessionId) {
+                    const msgs = this.sessions.getMessages(fbPayload.sessionId);
+                    const msg = msgs.find((m) => m.id === fbPayload.messageId);
+                    if (msg?.metadata?.architectDomain) {
+                        domain = msg.metadata.architectDomain;
+                    }
+                }
+                const mapped = fbPayload.rating === 'up' ? 'helpful' : 'off_target';
+                await this.architect.recordFeedback({
+                    domain: domain,
+                    rating: mapped,
+                    note: fbPayload.note,
+                });
+                audit('personality.feedback', {
+                    sessionId: fbPayload.sessionId,
+                    messageId: fbPayload.messageId,
+                    rating: fbPayload.rating,
+                });
+            }
+            return;
+        }
+        // Handle deep research job requests
+        if (message.type === 'start_research') {
+            const researchPayload = payload;
+            if (researchPayload?.question) {
+                const job = {
+                    id: crypto.randomUUID(),
+                    question: researchPayload.question,
+                    depth: researchPayload.depth ?? 'deep',
+                    status: 'planning',
+                    createdAt: Date.now(),
+                    progress: [],
+                };
+                this.researchJobs.set(job.id, job);
+                audit('research.started', { jobId: job.id, question: job.question, depth: job.depth });
+                this.sendToClient(client, { type: 'research_started', id: requestId, payload: { jobId: job.id } });
+                this.runResearchJob(job, client).catch((err) => {
+                    job.status = 'failed';
+                    this.logger.error('Research job failed', { error: err instanceof Error ? err : new Error(String(err)), jobId: job.id });
+                });
+            }
+            return;
+        }
         const msgPayload = payload;
         const content = msgPayload?.content;
         const modelOverride = msgPayload?.model;
@@ -1788,6 +2413,28 @@ export class Auxiora {
             });
             return;
         }
+        // ── Research intent detection ──────────────────────────────────
+        const researchIntent = this.intentDetector.detect(content);
+        if (researchIntent.score >= 0.6) {
+            this.sendToClient(client, { type: 'research_suggestion', id: requestId, payload: researchIntent });
+        }
+        // ── Guardrail input scan ──────────────────────────────────────
+        const inputScan = this.checkInputGuardrails(content);
+        if (inputScan && inputScan.action === 'block') {
+            audit('guardrail.triggered', {
+                action: 'block',
+                direction: 'input',
+                threatCount: inputScan.threats.length,
+                channelType: 'webchat',
+            });
+            this.sendToClient(client, {
+                type: 'message',
+                id: requestId,
+                payload: { role: 'assistant', content: this.GUARDRAIL_BLOCK_MESSAGE },
+            });
+            this.sendToClient(client, { type: 'done', id: requestId, payload: {} });
+            return;
+        }
         // Handle commands
         if (content.startsWith('/')) {
             await this.handleCommand(client, content, requestId);
@@ -1816,8 +2463,29 @@ export class Auxiora {
                 senderId: client.senderId,
             });
         }
+        // Apply redaction if guardrails flagged PII
+        let processedContent = content;
+        if (inputScan?.action === 'redact' && inputScan.redactedContent) {
+            processedContent = inputScan.redactedContent;
+            audit('guardrail.triggered', {
+                action: 'redact',
+                direction: 'input',
+                threatCount: inputScan.threats.length,
+                channelType: 'webchat',
+                sessionId: session.id,
+            });
+        }
+        else if (inputScan?.action === 'warn') {
+            audit('guardrail.triggered', {
+                action: 'warn',
+                direction: 'input',
+                threatCount: inputScan.threats.length,
+                channelType: 'webchat',
+                sessionId: session.id,
+            });
+        }
         // Add user message
-        await this.sessions.addMessage(session.id, 'user', content);
+        await this.sessions.addMessage(session.id, 'user', processedContent);
         // Check if providers are available
         if (!this.providers) {
             this.sendToClient(client, {
@@ -1846,60 +2514,30 @@ export class Auxiora {
                 ? chatPersonality === 'the-architect'
                 : this.config.agent.personality === 'the-architect';
             const basePrompt = useArchitect ? this.architectPrompt : this.standardPrompt;
-            // Build enriched prompt with modes and memories
+            // Build enriched prompt through pipeline
             let enrichedPrompt = basePrompt;
-            let memorySection = null;
-            if (this.memoryRetriever && this.memoryStore) {
-                const memories = await this.memoryStore.getAll();
-                memorySection = this.memoryRetriever.retrieve(memories, content);
-            }
-            if (this.promptAssembler && this.config.modes?.enabled !== false) {
-                const modeState = this.getSessionModeState(session.id);
-                // Security context check — BEFORE mode detection
-                if (this.securityFloor) {
-                    const securityContext = this.securityFloor.detectSecurityContext({ userMessage: content });
-                    if (securityContext.active) {
-                        // Suspend current mode and use security floor prompt
-                        modeState.suspendedMode = modeState.activeMode;
-                        enrichedPrompt = this.promptAssembler.enrichForSecurityContext(securityContext, this.securityFloor, memorySection);
-                    }
-                    else if (modeState.suspendedMode) {
-                        // Restore suspended mode
-                        modeState.activeMode = modeState.suspendedMode;
-                        delete modeState.suspendedMode;
-                        enrichedPrompt = this.promptAssembler.enrichForMessage(modeState, memorySection, this.userPreferences, undefined, 'webchat');
-                    }
-                    else {
-                        // Normal mode detection
-                        enrichedPrompt = this.buildModeEnrichedPrompt(content, modeState, memorySection, 'webchat');
-                    }
-                }
-                else {
-                    // No security floor — normal mode detection
-                    enrichedPrompt = this.buildModeEnrichedPrompt(content, modeState, memorySection, 'webchat');
-                }
-            }
-            else if (memorySection) {
-                enrichedPrompt = basePrompt + memorySection;
+            let architectResult = { prompt: basePrompt };
+            // Reset Architect conversation state for new chats
+            if (useArchitect && this.architect && chatId && !this.architectResetChats.has(chatId)) {
+                this.architectResetChats.add(chatId);
+                this.architect.resetConversation();
+                audit('personality.reset', { sessionId: session.id, chatId });
             }
-            // Only apply Architect enrichment if this chat uses the Architect
-            const architectResult = useArchitect
-                ? this.applyArchitectEnrichment(enrichedPrompt, content, chatId)
-                : { prompt: enrichedPrompt };
-            enrichedPrompt = architectResult.prompt;
-            // Inject dynamic self-awareness context
-            if (this.selfAwarenessAssembler) {
-                const awarenessContext = {
-                    userId: client.senderId ?? 'anonymous',
-                    sessionId: session.id,
+            if (this.enrichmentPipeline) {
+                const enrichCtx = {
+                    basePrompt,
+                    userMessage: processedContent,
+                    history: contextMessages,
+                    channelType: 'webchat',
                     chatId: chatId ?? session.id,
-                    currentMessage: content,
-                    recentMessages: contextMessages,
+                    sessionId: session.id,
+                    userId: client.senderId ?? 'anonymous',
+                    toolsUsed: this.lastToolsUsed.get(session.id) ?? [],
+                    config: this.config,
                 };
-                const awarenessFragment = await this.selfAwarenessAssembler.assemble(awarenessContext);
-                if (awarenessFragment) {
-                    enrichedPrompt += '\n\n[Dynamic Self-Awareness]\n' + awarenessFragment;
-                }
+                const result = await this.enrichmentPipeline.run(enrichCtx);
+                enrichedPrompt = result.prompt;
+                architectResult = { prompt: enrichedPrompt, architectMeta: result.metadata.architect };
             }
             // Route to best model for this message
             let provider;
@@ -1910,7 +2548,7 @@ export class Auxiora {
             }
             else if (this.modelRouter && this.config.routing?.enabled !== false) {
                 try {
-                    routingResult = this.modelRouter.route(content, { hasImages: false });
+                    routingResult = this.modelRouter.route(processedContent, { hasImages: false });
                     provider = this.providers.getProvider(routingResult.selection.provider);
                 }
                 catch {
@@ -1920,30 +2558,89 @@ export class Auxiora {
             else {
                 provider = this.providers.getPrimaryProvider();
             }
+            // Inject model identity so the AI knows what it's running on
+            enrichedPrompt += this.buildModelIdentityFragment(provider, routingResult?.selection.model ?? modelOverride);
             // Execute streaming AI call with tool follow-up loop
+            const processingStartTime = Date.now();
             const fallbackCandidates = this.providers.resolveFallbackCandidates();
+            const toolsUsed = [];
+            let streamChunkCount = 0;
             const { response: fullResponse, usage } = await this.executeWithTools(session.id, chatMessages, enrichedPrompt, provider, (type, data) => {
                 if (type === 'text') {
+                    streamChunkCount++;
                     this.sendToClient(client, { type: 'chunk', id: requestId, payload: { content: data } });
                 }
                 else if (type === 'thinking') {
                     this.sendToClient(client, { type: 'thinking', id: requestId, payload: { content: data } });
                 }
                 else if (type === 'tool_use') {
+                    toolsUsed.push({ name: data?.name ?? 'unknown', success: true });
                     this.sendToClient(client, { type: 'tool_use', id: requestId, payload: data });
                 }
                 else if (type === 'tool_result') {
+                    // Update last tool's success based on result
+                    if (toolsUsed.length > 0 && data?.error) {
+                        toolsUsed[toolsUsed.length - 1].success = false;
+                    }
                     this.sendToClient(client, { type: 'tool_result', id: requestId, payload: data });
                 }
                 else if (type === 'status') {
                     this.sendToClient(client, { type: 'status', id: requestId, payload: data });
                 }
             }, { tools, fallbackCandidates });
+            // Feed tool usage to awareness collector
+            if (this.architectAwarenessCollector && toolsUsed.length > 0) {
+                this.architectAwarenessCollector.updateToolContext(toolsUsed);
+            }
+            // Store tools for next turn's enrichment context
+            this.lastToolsUsed.set(session.id, toolsUsed);
+            // ── Guardrail output scan ─────────────────────────────────────
+            const outputScan = this.checkOutputGuardrails(fullResponse);
+            const finalResponse = outputScan.response;
+            if (outputScan.wasModified) {
+                audit('guardrail.triggered', {
+                    action: outputScan.action,
+                    direction: 'output',
+                    channelType: 'webchat',
+                    sessionId: session.id,
+                });
+                // Send correction since chunks were already streamed
+                this.sendToClient(client, {
+                    type: 'guardrail_correction',
+                    id: requestId,
+                    payload: { content: finalResponse },
+                });
+            }
+            // Collect transparency metadata (best-effort)
+            let transparencyMeta;
+            try {
+                const modelId = routingResult?.selection.model ?? modelOverride ?? provider.defaultModel;
+                const caps = provider.metadata.models[modelId];
+                if (caps) {
+                    transparencyMeta = collectTransparencyMeta({
+                        enrichment: this.enrichmentPipeline
+                            ? { prompt: enrichedPrompt, metadata: { architect: architectResult.architectMeta, stages: architectResult.stages ?? [] } }
+                            : { prompt: enrichedPrompt, metadata: { stages: [] } },
+                        completion: { content: finalResponse, usage, model: modelId, finishReason: 'stop', toolUse: toolsUsed.map(t => ({ name: t.name })) },
+                        capabilities: { costPer1kInput: caps.costPer1kInput, costPer1kOutput: caps.costPer1kOutput },
+                        providerName: provider.name,
+                        awarenessSignals: [],
+                        responseText: finalResponse,
+                        processingStartTime,
+                    });
+                }
+            }
+            catch {
+                // Transparency is best-effort — never block message delivery
+            }
             // Save assistant message (skip if empty — happens when response is tool-only)
-            if (fullResponse) {
-                await this.sessions.addMessage(session.id, 'assistant', fullResponse, {
+            if (finalResponse) {
+                await this.sessions.addMessage(session.id, 'assistant', finalResponse, {
                     input: usage.inputTokens,
                     output: usage.outputTokens,
+                }, {
+                    ...(architectResult.architectMeta ? { architectDomain: architectResult.architectMeta.detectedContext.domain } : {}),
+                    ...(transparencyMeta ? { transparency: transparencyMeta } : {}),
                 });
             }
             // Record usage for cost tracking
@@ -1951,14 +2648,14 @@ export class Auxiora {
                 this.modelRouter.recordUsage(routingResult.selection.provider, routingResult.selection.model, usage.inputTokens, usage.outputTokens);
             }
             // Extract memories and learn from conversation (if auto-extract enabled)
-            if (this.config.memory?.autoExtract !== false && this.memoryStore && fullResponse && content.length > 20) {
-                void this.extractAndLearn(content, fullResponse, session.id);
+            if (this.config.memory?.autoExtract !== false && this.memoryStore && finalResponse && processedContent.length > 20) {
+                void this.extractAndLearn(processedContent, finalResponse, session.id);
             }
             // Auto-title webchat chats after first exchange
-            if (fullResponse &&
+            if (finalResponse &&
                 session.metadata.channelType === 'webchat' &&
                 session.messages.length <= 3) {
-                void this.generateChatTitle(session.id, content, fullResponse, client);
+                void this.generateChatTitle(session.id, processedContent, finalResponse, client);
             }
             // Send done signal
             this.sendToClient(client, {
@@ -1977,6 +2674,7 @@ export class Auxiora {
                         override: true,
                     } : undefined,
                     architect: architectResult.architectMeta,
+                    transparency: transparencyMeta,
                 },
             });
             // Background self-awareness analysis
@@ -1985,13 +2683,33 @@ export class Auxiora {
                     userId: client.senderId ?? 'anonymous',
                     sessionId: session.id,
                     chatId: chatId ?? session.id,
-                    currentMessage: content,
+                    currentMessage: processedContent,
                     recentMessages: contextMessages,
-                    response: fullResponse,
+                    response: finalResponse,
                     responseTime: Date.now() - (session.metadata.lastActiveAt ?? Date.now()),
                     tokensUsed: { input: usage?.inputTokens ?? 0, output: usage?.outputTokens ?? 0 },
+                    streamChunks: streamChunkCount,
                 }).catch(() => { });
             }
+            // Record conversation in consciousness journal
+            if (this.consciousness) {
+                const journalBase = {
+                    sessionId: session.id,
+                    type: 'message',
+                    context: {
+                        domains: architectResult.architectMeta
+                            ? [architectResult.architectMeta.detectedContext.domain]
+                            : ['general'],
+                    },
+                    selfState: {
+                        health: (this.healthMonitor?.getHealthState().overall === 'unhealthy' ? 'degraded' : this.healthMonitor?.getHealthState().overall ?? 'healthy'),
+                        activeProviders: [this.config.provider.primary],
+                        uptime: Math.round(process.uptime()),
+                    },
+                };
+                this.consciousness.journal.record({ ...journalBase, message: { role: 'user', content: processedContent } }).catch(() => { });
+                this.consciousness.journal.record({ ...journalBase, message: { role: 'assistant', content: finalResponse } }).catch(() => { });
+            }
             audit('message.sent', {
                 sessionId: session.id,
                 inputTokens: usage.inputTokens,
@@ -2268,6 +2986,14 @@ export class Auxiora {
             for (const toolUse of toolUses) {
                 // Map Claude Code emulation tool names to our actual tools
                 const mapped = mapCCToolCall(toolUse.name, toolUse.input);
+                // Skip CC-only tools that have no Auxiora equivalent
+                if (mapped.skip) {
+                    onChunk('tool_result', { tool: toolUse.name, success: false, error: mapped.skip });
+                    toolResultParts.push(`[${toolUse.name}]: Error: ${mapped.skip}`);
+                    recordToolCall(loopState, toolUse.id, mapped.name, mapped.input);
+                    recordToolOutcome(loopState, toolUse.id, mapped.skip);
+                    continue;
+                }
                 recordToolCall(loopState, toolUse.id, mapped.name, mapped.input);
                 try {
                     const result = await toolExecutor.execute(mapped.name, mapped.input, context);
@@ -2511,7 +3237,11 @@ export class Auxiora {
     persistToWebchat(content) {
         this.sessions.getOrCreate('webchat', { channelType: 'webchat' })
             .then(session => this.sessions.addMessage(session.id, 'assistant', content))
-            .catch(() => { });
+            .catch((err) => {
+            this.logger.warn('Failed to persist webchat message', {
+                error: err instanceof Error ? err : new Error(String(err)),
+            });
+        });
     }
     /** Deliver a proactive message to all connected channel adapters using tracked channel IDs.
      *  Also persists to the webchat session so messages appear in chat history.
@@ -2563,149 +3293,253 @@ export class Auxiora {
             if (inbound.attachments && inbound.attachments.length > 0 && this.mediaProcessor) {
                 messageContent = await this.mediaProcessor.process(inbound.attachments, inbound.content);
             }
-            await this.sessions.addMessage(session.id, 'user', messageContent);
-            // Check if providers are available
-            if (!this.providers) {
+            // ── Guardrail input scan ──────────────────────────────────────
+            const inputScan = this.checkInputGuardrails(messageContent);
+            if (inputScan && inputScan.action === 'block') {
+                audit('guardrail.triggered', {
+                    action: 'block',
+                    direction: 'input',
+                    threatCount: inputScan.threats.length,
+                    channelType: inbound.channelType,
+                    sessionId: session.id,
+                });
                 if (this.channels) {
                     await this.channels.send(inbound.channelType, inbound.channelId, {
-                        content: 'I need API keys to respond. Please configure them in the vault.',
+                        content: this.GUARDRAIL_BLOCK_MESSAGE,
                         replyToId: inbound.id,
                     });
                 }
                 return;
             }
-            // Get context messages
-            const contextMessages = this.sessions.getContextMessages(session.id, this.getProviderMaxTokens(this.providers.getPrimaryProvider()), 4096);
-            const chatMessages = sanitizeTranscript(contextMessages).map((m) => ({
-                role: m.role,
-                content: m.content,
-            }));
-            // Show typing indicator while generating response
-            const stopTyping = this.channels
-                ? await this.channels.startTyping(inbound.channelType, inbound.channelId)
-                : () => { };
+            // Apply redaction if guardrails flagged PII
+            if (inputScan?.action === 'redact' && inputScan.redactedContent) {
+                messageContent = inputScan.redactedContent;
+                audit('guardrail.triggered', {
+                    action: 'redact',
+                    direction: 'input',
+                    threatCount: inputScan.threats.length,
+                    channelType: inbound.channelType,
+                });
+            }
+            else if (inputScan?.action === 'warn') {
+                audit('guardrail.triggered', {
+                    action: 'warn',
+                    direction: 'input',
+                    threatCount: inputScan.threats.length,
+                    channelType: inbound.channelType,
+                });
+            }
+            await this.sessions.addMessage(session.id, 'user', messageContent);
+            // Check if providers are available
+            if (!this.providers) {
+                if (this.channels) {
+                    await this.channels.send(inbound.channelType, inbound.channelId, {
+                        content: 'I need API keys to respond. Please configure them in the vault.',
+                        replyToId: inbound.id,
+                    });
+                }
+                return;
+            }
+            // Get context messages — channel sessions use a capped token budget and turn limit
+            // to prevent excessively long API calls from models with huge context windows.
+            const contextMessages = this.sessions.getContextMessages(session.id, this.getProviderMaxTokens(this.providers.getPrimaryProvider()), 4096, { isChannel: true });
+            const chatMessages = sanitizeTranscript(contextMessages).map((m) => ({
+                role: m.role,
+                content: m.content,
+            }));
+            // Show typing indicator while generating response
+            const stopTyping = this.channels
+                ? await this.channels.startTyping(inbound.channelType, inbound.channelId)
+                : () => { };
             const channelAgentId = `channel:${inbound.channelType}:${inbound.channelId}:${Date.now()}`;
-            try {
-                // Get tool definitions from registry
-                const tools = toolRegistry.toProviderFormat();
-                // Build enriched prompt with modes and memories
-                let enrichedPrompt = this.systemPrompt;
-                let channelMemorySection = null;
-                if (this.memoryRetriever && this.memoryStore) {
-                    const memories = await this.memoryStore.getAll();
-                    channelMemorySection = this.memoryRetriever.retrieve(memories, inbound.content);
-                }
-                if (this.promptAssembler && this.config.modes?.enabled !== false) {
-                    const modeState = this.getSessionModeState(session.id);
-                    // Security context check — BEFORE mode detection
-                    if (this.securityFloor) {
-                        const securityContext = this.securityFloor.detectSecurityContext({ userMessage: inbound.content });
-                        if (securityContext.active) {
-                            modeState.suspendedMode = modeState.activeMode;
-                            enrichedPrompt = this.promptAssembler.enrichForSecurityContext(securityContext, this.securityFloor, channelMemorySection);
+            // 4-minute timeout for the entire LLM response cycle.
+            // Increased from 2min to accommodate auto-continuations (max_tokens → "Continue")
+            // and tool round-trips. If the provider stream hangs (network issue, overloaded API),
+            // this ensures the user gets an error message instead of infinite "typing…".
+            const CHANNEL_RESPONSE_TIMEOUT_MS = 240_000;
+            let draftLoop = null;
+            let draftMessageId = null;
+            try { // outer try — finally block guarantees stopTyping() runs
+                try {
+                    // Get tool definitions from registry
+                    const tools = toolRegistry.toProviderFormat();
+                    // Build enriched prompt through pipeline
+                    let enrichedPrompt = this.systemPrompt;
+                    const channelChatId = `${inbound.channelType}:${inbound.channelId}`;
+                    let channelArchitectResult = { prompt: this.systemPrompt };
+                    // Reset Architect conversation state for new channel chats
+                    const useChannelArchitect = this.config.agent.personality === 'the-architect';
+                    if (useChannelArchitect && this.architect && !this.architectResetChats.has(channelChatId)) {
+                        this.architectResetChats.add(channelChatId);
+                        this.architect.resetConversation();
+                        audit('personality.reset', { sessionId: session.id, chatId: channelChatId });
+                    }
+                    if (this.enrichmentPipeline) {
+                        const enrichCtx = {
+                            basePrompt: this.systemPrompt,
+                            userMessage: messageContent,
+                            history: contextMessages,
+                            channelType: inbound.channelType,
+                            chatId: channelChatId,
+                            sessionId: session.id,
+                            userId: inbound.senderId ?? 'anonymous',
+                            toolsUsed: this.lastToolsUsed.get(session.id) ?? [],
+                            config: this.config,
+                        };
+                        const result = await this.enrichmentPipeline.run(enrichCtx);
+                        enrichedPrompt = result.prompt;
+                        channelArchitectResult = { prompt: enrichedPrompt, architectMeta: result.metadata.architect };
+                    }
+                    // Use executeWithTools for channels — collect final text for channel reply
+                    const provider = this.providers.getPrimaryProvider();
+                    // Inject model identity so the AI knows what it's running on
+                    enrichedPrompt += this.buildModelIdentityFragment(provider);
+                    this.agentStart(channelAgentId, 'channel', `Processing message on ${inbound.channelType}`, inbound.channelType);
+                    // Draft streaming: edit message in place if adapter supports it
+                    const adapter = this.channels?.getAdapter(inbound.channelType);
+                    const supportsDraft = !!adapter?.editMessage;
+                    let accumulatedText = '';
+                    if (supportsDraft && this.channels) {
+                        const channels = this.channels;
+                        draftLoop = new DraftStreamLoop(async (text) => {
+                            try {
+                                if (!draftMessageId) {
+                                    const result = await channels.send(inbound.channelType, inbound.channelId, {
+                                        content: text,
+                                        replyToId: inbound.id,
+                                    });
+                                    if (result.success && result.messageId) {
+                                        draftMessageId = result.messageId;
+                                    }
+                                    return result.success;
+                                }
+                                else {
+                                    const result = await channels.editMessage(inbound.channelType, inbound.channelId, draftMessageId, { content: text });
+                                    return result.success;
+                                }
+                            }
+                            catch {
+                                return false;
+                            }
+                        }, 1000);
+                    }
+                    const fallbackCandidates = this.providers.resolveFallbackCandidates();
+                    const channelToolsUsed = [];
+                    const { response: channelResponse, usage: channelUsage } = await Promise.race([
+                        this.executeWithTools(session.id, chatMessages, enrichedPrompt, provider, (type, data) => {
+                            if (type === 'text' && data && draftLoop) {
+                                accumulatedText += data;
+                                draftLoop.update(accumulatedText);
+                            }
+                            else if (type === 'tool_use') {
+                                channelToolsUsed.push({ name: data?.name ?? 'unknown', success: true });
+                            }
+                            else if (type === 'tool_result') {
+                                if (channelToolsUsed.length > 0 && data?.error) {
+                                    channelToolsUsed[channelToolsUsed.length - 1].success = false;
+                                }
+                            }
+                        }, { tools, fallbackCandidates }),
+                        new Promise((_, reject) => setTimeout(() => reject(new Error('Response timed out — the AI provider did not respond within 4 minutes. Please try again.')), CHANNEL_RESPONSE_TIMEOUT_MS)),
+                    ]);
+                    // Feed tool usage to awareness collector
+                    if (this.architectAwarenessCollector && channelToolsUsed.length > 0) {
+                        this.architectAwarenessCollector.updateToolContext(channelToolsUsed);
+                    }
+                    this.lastToolsUsed.set(session.id, channelToolsUsed);
+                    // Flush final draft text
+                    if (draftLoop) {
+                        if (channelResponse && channelResponse !== accumulatedText) {
+                            draftLoop.update(channelResponse);
                         }
-                        else if (modeState.suspendedMode) {
-                            modeState.activeMode = modeState.suspendedMode;
-                            delete modeState.suspendedMode;
-                            enrichedPrompt = this.buildModeEnrichedPrompt(inbound.content, modeState, channelMemorySection, inbound.channelType);
+                        await draftLoop.flush();
+                        draftLoop.stop();
+                    }
+                    // ── Guardrail output scan ─────────────────────────────────────
+                    const channelOutputScan = this.checkOutputGuardrails(channelResponse);
+                    const finalChannelResponse = channelOutputScan.response;
+                    if (channelOutputScan.wasModified) {
+                        audit('guardrail.triggered', {
+                            action: channelOutputScan.action,
+                            direction: 'output',
+                            channelType: inbound.channelType,
+                            sessionId: session.id,
+                        });
+                        // If draft streaming already sent partial text, do a final edit with clean version
+                        if (draftMessageId && adapter?.editMessage) {
+                            await adapter.editMessage(inbound.channelId, draftMessageId, { content: finalChannelResponse });
                         }
-                        else {
-                            enrichedPrompt = this.buildModeEnrichedPrompt(inbound.content, modeState, channelMemorySection, inbound.channelType);
+                    }
+                    // Save assistant message
+                    await this.sessions.addMessage(session.id, 'assistant', finalChannelResponse, {
+                        input: channelUsage.inputTokens,
+                        output: channelUsage.outputTokens,
+                    }, channelArchitectResult.architectMeta ? { architectDomain: channelArchitectResult.architectMeta.detectedContext.domain } : undefined);
+                    // Extract memories and learn from conversation (if auto-extract enabled)
+                    if (this.config.memory?.autoExtract !== false && this.memoryStore && finalChannelResponse && messageContent.length > 20) {
+                        void this.extractAndLearn(messageContent, finalChannelResponse, session.id);
+                    }
+                    // Send final response. The draft stream loop edits a single message,
+                    // but Discord silently truncates edits at 2000 chars. For long responses,
+                    // replace the draft with a chunked send so nothing is lost.
+                    const DRAFT_SAFE_LENGTH = 1900; // leave margin below Discord's 2000 char limit
+                    if (draftMessageId && this.channels && finalChannelResponse.length > DRAFT_SAFE_LENGTH) {
+                        // Draft only showed partial content — replace it with a pointer and send full chunked response
+                        if (adapter?.editMessage) {
+                            await adapter.editMessage(inbound.channelId, draftMessageId, {
+                                content: '*\u2026 (full response below)*',
+                            });
                         }
+                        await this.channels.send(inbound.channelType, inbound.channelId, {
+                            content: finalChannelResponse,
+                        });
                     }
-                    else {
-                        enrichedPrompt = this.buildModeEnrichedPrompt(inbound.content, modeState, channelMemorySection, inbound.channelType);
+                    else if (!draftMessageId && this.channels) {
+                        await this.channels.send(inbound.channelType, inbound.channelId, {
+                            content: finalChannelResponse,
+                            replyToId: inbound.id,
+                        });
                     }
+                    audit('message.sent', {
+                        channelType: inbound.channelType,
+                        sessionId: session.id,
+                        inputTokens: channelUsage.inputTokens,
+                        outputTokens: channelUsage.outputTokens,
+                    });
+                    this.agentEnd(channelAgentId, true);
                 }
-                else if (channelMemorySection) {
-                    enrichedPrompt = this.systemPrompt + channelMemorySection;
-                }
-                const channelArchitectResult = this.applyArchitectEnrichment(enrichedPrompt, inbound.content);
-                enrichedPrompt = channelArchitectResult.prompt;
-                // Use executeWithTools for channels — collect final text for channel reply
-                const provider = this.providers.getPrimaryProvider();
-                this.agentStart(channelAgentId, 'channel', `Processing message on ${inbound.channelType}`, inbound.channelType);
-                // Draft streaming: edit message in place if adapter supports it
-                const adapter = this.channels?.getAdapter(inbound.channelType);
-                const supportsDraft = !!adapter?.editMessage;
-                let draftMessageId = null;
-                let accumulatedText = '';
-                let draftLoop = null;
-                if (supportsDraft && this.channels) {
-                    const channels = this.channels;
-                    draftLoop = new DraftStreamLoop(async (text) => {
-                        try {
-                            if (!draftMessageId) {
-                                const result = await channels.send(inbound.channelType, inbound.channelId, {
-                                    content: text,
+                catch (error) {
+                    if (draftLoop)
+                        draftLoop.stop();
+                    this.agentEnd(channelAgentId, false);
+                    const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                    audit('channel.error', { sessionId: session.id, error: errorMessage });
+                    if (this.channels) {
+                        const errorContent = `Error: ${errorMessage}`;
+                        // If a draft message exists, edit it with the error instead of sending a new one
+                        if (draftMessageId) {
+                            try {
+                                await this.channels.editMessage(inbound.channelType, inbound.channelId, draftMessageId, { content: errorContent });
+                            }
+                            catch {
+                                // Edit failed — fall back to new message
+                                await this.channels.send(inbound.channelType, inbound.channelId, {
+                                    content: errorContent,
                                     replyToId: inbound.id,
                                 });
-                                if (result.success && result.messageId) {
-                                    draftMessageId = result.messageId;
-                                }
-                                return result.success;
-                            }
-                            else {
-                                const result = await channels.editMessage(inbound.channelType, inbound.channelId, draftMessageId, { content: text });
-                                return result.success;
                             }
                         }
-                        catch {
-                            return false;
+                        else {
+                            await this.channels.send(inbound.channelType, inbound.channelId, {
+                                content: errorContent,
+                                replyToId: inbound.id,
+                            });
                         }
-                    }, 1000);
-                }
-                const fallbackCandidates = this.providers.resolveFallbackCandidates();
-                const { response: channelResponse, usage: channelUsage } = await this.executeWithTools(session.id, chatMessages, enrichedPrompt, provider, (type, data) => {
-                    if (type === 'text' && data && draftLoop) {
-                        accumulatedText += data;
-                        draftLoop.update(accumulatedText);
-                    }
-                }, { tools, fallbackCandidates });
-                // Flush final draft text
-                if (draftLoop) {
-                    if (channelResponse && channelResponse !== accumulatedText) {
-                        draftLoop.update(channelResponse);
                     }
-                    await draftLoop.flush();
-                    draftLoop.stop();
                 }
-                stopTyping();
-                // Save assistant message
-                await this.sessions.addMessage(session.id, 'assistant', channelResponse, {
-                    input: channelUsage.inputTokens,
-                    output: channelUsage.outputTokens,
-                });
-                // Extract memories and learn from conversation (if auto-extract enabled)
-                if (this.config.memory?.autoExtract !== false && this.memoryStore && channelResponse && inbound.content.length > 20) {
-                    void this.extractAndLearn(inbound.content, channelResponse, session.id);
-                }
-                // Send response (skip if draft streaming already delivered it)
-                if (!draftMessageId && this.channels) {
-                    await this.channels.send(inbound.channelType, inbound.channelId, {
-                        content: channelResponse,
-                        replyToId: inbound.id,
-                    });
-                }
-                audit('message.sent', {
-                    channelType: inbound.channelType,
-                    sessionId: session.id,
-                    inputTokens: channelUsage.inputTokens,
-                    outputTokens: channelUsage.outputTokens,
-                });
-                this.agentEnd(channelAgentId, true);
             }
-            catch (error) {
+            finally {
                 stopTyping();
-                this.agentEnd(channelAgentId, false);
-                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-                audit('channel.error', { sessionId: session.id, error: errorMessage });
-                if (this.channels) {
-                    await this.channels.send(inbound.channelType, inbound.channelId, {
-                        content: `Error: ${errorMessage}`,
-                        replyToId: inbound.id,
-                    });
-                }
             }
         }); // end runWithRequestId
     }
@@ -2912,10 +3746,52 @@ export class Auxiora {
         }
         // Load persisted channel targets for proactive delivery (behaviors, ambient)
         await this.loadChannelTargets();
+        // Research job expiry (every 60s, prune jobs older than 1 hour)
+        this.researchJobExpiry = setInterval(() => {
+            const ONE_HOUR = 3_600_000;
+            const now = Date.now();
+            for (const [id, job] of this.researchJobs) {
+                if (now - job.createdAt > ONE_HOUR)
+                    this.researchJobs.delete(id);
+            }
+        }, 60_000);
         this.running = true;
         console.log(`\n${this.getAgentName()} is ready!`);
         console.log(`Open http://${this.config.gateway.host}:${this.config.gateway.port} in your browser\n`);
     }
+    async processEventTriggers(events) {
+        if (!this.behaviors || events.length === 0)
+            return;
+        const allBehaviors = await this.behaviors.list();
+        const eventBehaviors = allBehaviors.filter((b) => b.type === 'event' && b.status === 'active' && b.eventTrigger);
+        for (const event of events) {
+            // Feed to ambient pattern engine
+            this.ambientEngine?.observe({
+                type: `${event.connectorId}:${event.triggerId}`,
+                timestamp: event.timestamp,
+                data: event.data,
+            });
+            // Match against event behaviors
+            for (const behavior of eventBehaviors) {
+                const trigger = behavior.eventTrigger;
+                if (trigger.source !== event.connectorId || trigger.event !== event.triggerId)
+                    continue;
+                if (evaluateConditions(event.data, trigger.conditions, trigger.combinator)) {
+                    try {
+                        await this.behaviors.executeNow(behavior.id);
+                        await audit('behavior.event_triggered', {
+                            behaviorId: behavior.id,
+                            source: event.connectorId,
+                            event: event.triggerId,
+                        });
+                    }
+                    catch {
+                        // Execution failures tracked by BehaviorManager
+                    }
+                }
+            }
+        }
+    }
     async stop() {
         if (!this.running)
             return;
@@ -2938,6 +3814,9 @@ export class Auxiora {
         if (this.ambientScheduler) {
             this.ambientScheduler.stop();
         }
+        if (this.ambientDetectTimer) {
+            clearInterval(this.ambientDetectTimer);
+        }
         if (this.autonomousExecutor) {
             this.autonomousExecutor.stop();
         }
@@ -2945,6 +3824,17 @@ export class Auxiora {
             clearInterval(this.memoryCleanupInterval);
             this.memoryCleanupInterval = undefined;
         }
+        if (this.researchJobExpiry) {
+            clearInterval(this.researchJobExpiry);
+            this.researchJobExpiry = undefined;
+        }
+        if (this.mcpClientManager) {
+            await this.mcpClientManager.disconnectAll();
+        }
+        if (this.jobQueue) {
+            await this.jobQueue.stop(30000);
+        }
+        this.consciousness?.shutdown();
         this.sessions.destroy();
         this.vault.lock();
         this.running = false;
@@ -2955,6 +3845,2119 @@ export class Auxiora {
     getAgentName() {
         return this.config.agent?.name ?? 'Auxiora';
     }
+    createPersonalityRouter() {
+        const router = Router();
+        const guard = (_req, res) => {
+            if (!this.architect) {
+                res.status(503).json({ error: 'Architect not available' });
+                return false;
+            }
+            return true;
+        };
+        // --- Decisions (Gap 4) ---
+        router.post('/decisions', async (req, res) => {
+            if (!guard(req, res))
+                return;
+            const { domain, summary, context, followUpDate } = req.body ?? {};
+            if (!domain || !summary || !context) {
+                res.status(400).json({ error: 'Missing required fields: domain, summary, context' });
+                return;
+            }
+            try {
+                const decision = await this.architect.recordDecision({ domain, summary, context, followUpDate, status: 'active' });
+                audit('personality.decision.created', { decisionId: decision.id, domain });
+                res.status(201).json(decision);
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message ?? 'Failed to record decision' });
+            }
+        });
+        router.patch('/decisions/:id', async (req, res) => {
+            if (!guard(req, res))
+                return;
+            const { status, outcome, followUpDate } = req.body ?? {};
+            try {
+                await this.architect.updateDecision(req.params.id, { status, outcome, followUpDate });
+                audit('personality.decision.updated', { decisionId: req.params.id });
+                res.json({ ok: true });
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message ?? 'Failed to update decision' });
+            }
+        });
+        router.get('/decisions', async (req, res) => {
+            if (!guard(req, res))
+                return;
+            try {
+                const { domain, status, since, search, limit } = req.query;
+                const query = {};
+                if (domain)
+                    query.domain = domain;
+                if (status)
+                    query.status = status;
+                if (since)
+                    query.since = since;
+                if (search)
+                    query.search = search;
+                if (limit)
+                    query.limit = Number(limit);
+                const decisions = await this.architect.queryDecisions(query);
+                res.json({ decisions });
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message ?? 'Failed to query decisions' });
+            }
+        });
+        router.get('/decisions/due', async (req, res) => {
+            if (!guard(req, res))
+                return;
+            try {
+                const due = await this.architect.getDueFollowUps();
+                res.json({ decisions: due });
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message ?? 'Failed to get due follow-ups' });
+            }
+        });
+        // --- Traits (Gap 5) ---
+        router.get('/traits', (req, res) => {
+            if (!guard(req, res))
+                return;
+            try {
+                const mix = this.architect.getTraitMix({
+                    domain: 'general',
+                    emotionalRegister: 'neutral',
+                    stakes: 'moderate',
+                    complexity: 'moderate',
+                    mode: 'solo_work',
+                });
+                const overrides = this.architect.getActiveOverrides();
+                res.json({ mix, overrides });
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message ?? 'Failed to get traits' });
+            }
+        });
+        router.put('/traits/:trait', async (req, res) => {
+            if (!guard(req, res))
+                return;
+            const { offset, source, reason } = req.body ?? {};
+            if (typeof offset !== 'number') {
+                res.status(400).json({ error: 'Missing or invalid field: offset must be a number' });
+                return;
+            }
+            try {
+                await this.architect.setTraitOverride(req.params.trait, offset);
+                audit('personality.trait.override', { trait: req.params.trait, offset, source, reason });
+                res.json({ ok: true });
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message ?? 'Failed to set trait override' });
+            }
+        });
+        router.delete('/traits/:trait', async (req, res) => {
+            if (!guard(req, res))
+                return;
+            try {
+                await this.architect.removeTraitOverride(req.params.trait);
+                audit('personality.trait.override', { trait: req.params.trait, action: 'removed' });
+                res.json({ ok: true });
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message ?? 'Failed to remove trait override' });
+            }
+        });
+        // --- Presets (Gap 5) ---
+        router.get('/presets', (req, res) => {
+            if (!guard(req, res))
+                return;
+            try {
+                const presets = this.architect.listPresets();
+                res.json({ presets });
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message ?? 'Failed to list presets' });
+            }
+        });
+        router.post('/presets/:name/apply', async (req, res) => {
+            if (!guard(req, res))
+                return;
+            try {
+                await this.architect.loadPreset(req.params.name);
+                audit('personality.preset.applied', { preset: req.params.name });
+                res.json({ ok: true });
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message ?? 'Failed to apply preset' });
+            }
+        });
+        // --- Preferences (Gap 12) ---
+        router.get('/preferences', async (req, res) => {
+            if (!guard(req, res))
+                return;
+            try {
+                const prefs = await this.architect.getPreferences();
+                res.json(prefs);
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message ?? 'Failed to get preferences' });
+            }
+        });
+        router.put('/preferences', async (req, res) => {
+            if (!guard(req, res))
+                return;
+            const body = req.body ?? {};
+            try {
+                for (const [key, value] of Object.entries(body)) {
+                    await this.architect.updatePreference(key, value);
+                }
+                audit('personality.preferences.updated', { keys: Object.keys(body) });
+                res.json({ ok: true });
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message ?? 'Failed to update preferences' });
+            }
+        });
+        // --- Feedback insights ---
+        router.get('/feedback/insights', (req, res) => {
+            if (!guard(req, res))
+                return;
+            try {
+                const insights = this.architect.getFeedbackInsights();
+                res.json(insights);
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message ?? 'Failed to get feedback insights' });
+            }
+        });
+        // --- User model ---
+        router.get('/user-model', (_req, res) => {
+            if (!guard(_req, res))
+                return;
+            const model = this.getCachedUserModel();
+            if (!model) {
+                res.status(404).json({ error: 'User model not available' });
+                return;
+            }
+            res.json(model);
+        });
+        // --- Corrections (Gap 8) ---
+        router.post('/corrections', async (req, res) => {
+            if (!guard(req, res))
+                return;
+            const { userMessage, detectedDomain, correctedDomain } = req.body ?? {};
+            if (!userMessage || !detectedDomain || !correctedDomain) {
+                res.status(400).json({ error: 'Missing required fields: userMessage, detectedDomain, correctedDomain' });
+                return;
+            }
+            try {
+                await this.architect.recordCorrection(userMessage, detectedDomain, correctedDomain);
+                audit('personality.correction', { detectedDomain, correctedDomain });
+                res.status(201).json({ ok: true });
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message ?? 'Failed to record correction' });
+            }
+        });
+        router.get('/corrections/stats', (req, res) => {
+            if (!guard(req, res))
+                return;
+            try {
+                const stats = this.architect.getCorrectionStats();
+                res.json(stats);
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message ?? 'Failed to get correction stats' });
+            }
+        });
+        // --- Data portability (Gap 10) ---
+        router.get('/export', async (req, res) => {
+            if (!guard(req, res))
+                return;
+            try {
+                const data = await this.architect.exportData();
+                audit('personality.data.exported', {});
+                res.set('Content-Type', 'application/json');
+                res.send(data);
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message ?? 'Failed to export data' });
+            }
+        });
+        router.delete('/data', async (req, res) => {
+            if (!guard(req, res))
+                return;
+            try {
+                await this.architect.clearAllData();
+                audit('personality.data.cleared', {});
+                res.json({ ok: true });
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message ?? 'Failed to clear data' });
+            }
+        });
+        // --- Conversation export (Gap 9 / Task 7) ---
+        router.get('/sessions/:sessionId/export', (req, res) => {
+            if (!guard(req, res))
+                return;
+            const format = req.query.format || 'json';
+            if (!['json', 'markdown', 'csv'].includes(format)) {
+                res.status(400).json({ error: 'Invalid format. Must be json, markdown, or csv' });
+                return;
+            }
+            try {
+                const msgs = this.sessions.getMessages(req.params.sessionId);
+                const chatMessages = msgs
+                    .filter((m) => m.role === 'user' || m.role === 'assistant')
+                    .map((m) => ({
+                    role: m.role,
+                    content: m.content,
+                    timestamp: m.timestamp,
+                    metadata: m.metadata,
+                }));
+                const exported = this.architect.exportConversationAs(chatMessages, req.params.sessionId, format);
+                if (format === 'json') {
+                    res.set('Content-Type', 'application/json');
+                }
+                else if (format === 'markdown') {
+                    res.set('Content-Type', 'text/markdown');
+                }
+                else {
+                    res.set('Content-Type', 'text/csv');
+                }
+                res.send(exported);
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message ?? 'Failed to export conversation' });
+            }
+        });
+        // --- Feedback REST (Task 9) ---
+        router.post('/sessions/:sessionId/messages/:messageId/feedback', async (req, res) => {
+            if (!guard(req, res))
+                return;
+            const { rating, note } = req.body ?? {};
+            if (!rating || !['up', 'down'].includes(rating)) {
+                res.status(400).json({ error: 'Missing or invalid rating. Must be "up" or "down"' });
+                return;
+            }
+            try {
+                let domain = 'general';
+                const msgs = this.sessions.getMessages(req.params.sessionId);
+                const msg = msgs.find((m) => m.id === req.params.messageId);
+                if (msg?.metadata?.architectDomain) {
+                    domain = msg.metadata.architectDomain;
+                }
+                const mapped = rating === 'up' ? 'helpful' : 'off_target';
+                await this.architect.recordFeedback({
+                    domain: domain,
+                    rating: mapped,
+                    note,
+                });
+                audit('personality.feedback', {
+                    sessionId: req.params.sessionId,
+                    messageId: req.params.messageId,
+                    rating,
+                });
+                res.status(201).json({ ok: true });
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message ?? 'Failed to record feedback' });
+            }
+        });
+        return router;
+    }
+    async runResearchJob(job, client) {
+        const onProgress = (event) => {
+            job.progress.push(event);
+            this.sendToClient(client, { type: 'research_progress', payload: { jobId: job.id, ...event } });
+        };
+        const provider = this.providers.getPrimaryProvider();
+        // NOTE: DeepResearchOrchestrator does not currently accept a DocumentStore parameter.
+        // When it gains that support, pass this.documentStore here.
+        const orchestrator = new DeepResearchOrchestrator(provider, undefined, this.researchEngine);
+        const result = await orchestrator.research(job.question, job.depth, onProgress);
+        if (job.depth === 'deep') {
+            const reportGen = new ReportGenerator(provider);
+            job.report = await reportGen.generateReport({
+                ...result,
+                question: job.question,
+                depth: job.depth,
+            });
+        }
+        job.status = 'completed';
+        job.completedAt = Date.now();
+        await audit('research.completed', {
+            jobId: job.id,
+            sourceCount: result.sources.length,
+            duration: job.completedAt - job.createdAt,
+        });
+        this.sendToClient(client, { type: 'research_completed', payload: { jobId: job.id } });
+    }
+    createResearchRouter() {
+        const router = Router();
+        const self = this;
+        router.post('/', (req, res) => {
+            const { question, depth = 'deep' } = req.body;
+            if (!question || typeof question !== 'string') {
+                return res.status(400).json({ error: 'question required' });
+            }
+            const job = {
+                id: crypto.randomUUID(),
+                question,
+                depth,
+                status: 'planning',
+                createdAt: Date.now(),
+                progress: [],
+            };
+            self.researchJobs.set(job.id, job);
+            audit('research.started', { jobId: job.id, question: job.question, depth: job.depth });
+            res.status(202).json({ jobId: job.id, status: job.status });
+        });
+        router.get('/', (_req, res) => {
+            const limit = Number(_req.query.limit) || 20;
+            const offset = Number(_req.query.offset) || 0;
+            const all = [...self.researchJobs.values()].sort((a, b) => b.createdAt - a.createdAt);
+            res.json({ jobs: all.slice(offset, offset + limit), total: all.length });
+        });
+        router.get('/:jobId', (req, res) => {
+            const job = self.researchJobs.get(req.params.jobId);
+            if (!job)
+                return res.status(404).json({ error: 'not found' });
+            res.json(job);
+        });
+        router.delete('/:jobId', (req, res) => {
+            const job = self.researchJobs.get(req.params.jobId);
+            if (!job)
+                return res.status(404).json({ error: 'not found' });
+            if (job.status === 'completed' || job.status === 'failed') {
+                return res.status(409).json({ error: 'job already finished' });
+            }
+            job.status = 'cancelled';
+            audit('research.cancelled', { jobId: job.id });
+            res.json({ jobId: job.id, status: 'cancelled' });
+        });
+        router.get('/:jobId/sources', (req, res) => {
+            const job = self.researchJobs.get(req.params.jobId);
+            if (!job)
+                return res.status(404).json({ error: 'not found' });
+            res.json({ sources: job.report?.sources ?? [] });
+        });
+        return router;
+    }
+    createAmbientRouter() {
+        const router = Router();
+        const self = this;
+        function guard(res) {
+            if (!self.ambientEngine || !self.ambientNotifications) {
+                res.status(503).json({ error: 'Ambient system not available' });
+                return false;
+            }
+            return true;
+        }
+        // Pattern management
+        router.get('/patterns', (_req, res) => {
+            if (!guard(res))
+                return;
+            res.json({ patterns: self.ambientEngine.getPatterns() });
+        });
+        router.get('/patterns/:id', (req, res) => {
+            if (!guard(res))
+                return;
+            const pattern = self.ambientEngine.getPattern(req.params.id);
+            if (!pattern)
+                return res.status(404).json({ error: 'Pattern not found' });
+            res.json(pattern);
+        });
+        router.post('/patterns/detect', async (_req, res) => {
+            if (!guard(res))
+                return;
+            const detected = self.ambientEngine.detectPatterns();
+            await audit('ambient.patterns.detected', { count: detected.length });
+            res.json({ detected: detected.length });
+        });
+        router.delete('/patterns', async (_req, res) => {
+            if (!guard(res))
+                return;
+            self.ambientEngine.reset();
+            await audit('ambient.patterns.reset', {});
+            res.json({ ok: true });
+        });
+        // Anticipations
+        router.get('/anticipations', (_req, res) => {
+            if (!self.anticipationEngine)
+                return res.status(503).json({ error: 'Anticipation engine not available' });
+            res.json({ anticipations: self.anticipationEngine.getAnticipations() });
+        });
+        // Notifications
+        router.get('/notifications', (req, res) => {
+            if (!guard(res))
+                return;
+            const priority = req.query.priority;
+            const items = priority
+                ? self.ambientNotifications.getByPriority(priority)
+                : self.ambientNotifications.getQueue();
+            res.json({ notifications: items });
+        });
+        router.post('/notifications/:id/dismiss', (req, res) => {
+            if (!guard(res))
+                return;
+            const ok = self.ambientNotifications.dismiss(req.params.id);
+            if (!ok)
+                return res.status(404).json({ error: 'Notification not found' });
+            res.json({ ok: true });
+        });
+        router.get('/notifications/stats', (_req, res) => {
+            if (!guard(res))
+                return;
+            res.json({ pending: self.ambientNotifications.getPendingCount() });
+        });
+        // Scheduler control
+        router.get('/scheduler/status', (_req, res) => {
+            if (!self.ambientScheduler)
+                return res.status(503).json({ error: 'Scheduler not available' });
+            res.json({ running: self.ambientScheduler.isRunning(), config: self.ambientScheduler.getConfig() });
+        });
+        router.post('/scheduler/start', async (_req, res) => {
+            if (!self.ambientScheduler)
+                return res.status(503).json({ error: 'Scheduler not available' });
+            self.ambientScheduler.start();
+            await audit('ambient.scheduler.started', {});
+            res.json({ ok: true });
+        });
+        router.post('/scheduler/stop', async (_req, res) => {
+            if (!self.ambientScheduler)
+                return res.status(503).json({ error: 'Scheduler not available' });
+            self.ambientScheduler.stop();
+            await audit('ambient.scheduler.stopped', {});
+            res.json({ ok: true });
+        });
+        router.put('/scheduler/config', (_req, res) => {
+            if (!self.ambientScheduler)
+                return res.status(503).json({ error: 'Scheduler not available' });
+            res.json({ config: self.ambientScheduler.getConfig() });
+        });
+        return router;
+    }
+    createVoiceRouter() {
+        const router = Router();
+        router.get('/status', (_req, res) => {
+            try {
+                if (!this.voiceManager) {
+                    return res.json({ enabled: false });
+                }
+                res.json({ enabled: true });
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message });
+            }
+        });
+        router.get('/sessions/:clientId', (req, res) => {
+            try {
+                if (!this.voiceManager) {
+                    return res.status(503).json({ error: 'Voice not initialized' });
+                }
+                const active = this.voiceManager.hasActiveSession(req.params.clientId);
+                res.json({ active });
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message });
+            }
+        });
+        return router;
+    }
+    createWebhooksRouter() {
+        const router = Router();
+        router.get('/', async (_req, res) => {
+            if (!this.webhookManager)
+                return res.status(503).json({ error: 'Webhooks not configured' });
+            try {
+                const webhooks = await this.webhookManager.list();
+                res.json({ webhooks });
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message });
+            }
+        });
+        router.post('/', async (req, res) => {
+            if (!this.webhookManager)
+                return res.status(503).json({ error: 'Webhooks not configured' });
+            try {
+                const webhook = await this.webhookManager.create(req.body);
+                res.json(webhook);
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message });
+            }
+        });
+        router.put('/:id', async (req, res) => {
+            if (!this.webhookManager)
+                return res.status(503).json({ error: 'Webhooks not configured' });
+            try {
+                const updated = await this.webhookManager.update(req.params.id, req.body);
+                if (!updated)
+                    return res.status(404).json({ error: 'Webhook not found' });
+                res.json(updated);
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message });
+            }
+        });
+        router.delete('/:id', async (req, res) => {
+            if (!this.webhookManager)
+                return res.status(503).json({ error: 'Webhooks not configured' });
+            try {
+                const deleted = await this.webhookManager.delete(req.params.id);
+                if (!deleted)
+                    return res.status(404).json({ error: 'Webhook not found' });
+                res.json({ deleted: true });
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message });
+            }
+        });
+        return router;
+    }
+    createConsciousnessRouter() {
+        const router = Router();
+        const self = this;
+        router.get('/pulse', (_req, res) => {
+            if (!self.consciousness)
+                return res.status(503).json({ error: 'Consciousness not initialized' });
+            try {
+                const pulse = self.consciousness.monitor.getPulse();
+                res.json(pulse);
+            }
+            catch (err) {
+                res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+            }
+        });
+        router.get('/self-model', async (_req, res) => {
+            if (!self.consciousness)
+                return res.status(503).json({ error: 'Consciousness not initialized' });
+            try {
+                const snapshot = await self.consciousness.model.synthesize();
+                res.json(snapshot);
+            }
+            catch (err) {
+                res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+            }
+        });
+        router.get('/journal/sessions', async (req, res) => {
+            if (!self.consciousness)
+                return res.status(503).json({ error: 'Consciousness not initialized' });
+            try {
+                const limit = Number(req.query.limit) || 10;
+                const sessions = await self.consciousness.journal.getRecentSessions(limit);
+                res.json(sessions);
+            }
+            catch (err) {
+                res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+            }
+        });
+        router.get('/journal/sessions/:sessionId', async (req, res) => {
+            if (!self.consciousness)
+                return res.status(503).json({ error: 'Consciousness not initialized' });
+            try {
+                const session = await self.consciousness.journal.getSession(req.params.sessionId);
+                res.json(session);
+            }
+            catch (err) {
+                res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+            }
+        });
+        router.get('/repairs', async (req, res) => {
+            if (!self.consciousness)
+                return res.status(503).json({ error: 'Consciousness not initialized' });
+            try {
+                const limit = Number(req.query.limit) || 20;
+                const history = await self.consciousness.repair.getRepairHistory(limit);
+                res.json(history);
+            }
+            catch (err) {
+                res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+            }
+        });
+        router.get('/repairs/pending', async (_req, res) => {
+            if (!self.consciousness)
+                return res.status(503).json({ error: 'Consciousness not initialized' });
+            try {
+                const pending = await self.consciousness.repair.getPendingApprovals();
+                res.json(pending);
+            }
+            catch (err) {
+                res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+            }
+        });
+        return router;
+    }
+    createAgentProtocolRouter() {
+        const router = Router();
+        router.get('/identity', (_req, res) => {
+            if (!this.agentProtocol || !this.agentDirectory) {
+                return res.status(503).json({ error: 'Agent protocol not initialized' });
+            }
+            try {
+                const identity = this.agentProtocol.getIdentity();
+                res.json(identity);
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message });
+            }
+        });
+        router.get('/inbox', (_req, res) => {
+            if (!this.agentProtocol || !this.agentDirectory) {
+                return res.status(503).json({ error: 'Agent protocol not initialized' });
+            }
+            try {
+                const limit = _req.query.limit ? parseInt(_req.query.limit, 10) : 50;
+                const messages = this.agentProtocol.getInbox(limit);
+                res.json({ messages });
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message });
+            }
+        });
+        router.post('/messages', async (req, res) => {
+            if (!this.agentProtocol || !this.agentDirectory) {
+                return res.status(503).json({ error: 'Agent protocol not initialized' });
+            }
+            try {
+                const { to, type, payload, replyTo } = req.body;
+                const message = await this.agentProtocol.send(to, type, payload, replyTo);
+                res.json(message);
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message });
+            }
+        });
+        router.post('/receive', async (req, res) => {
+            if (!this.agentProtocol || !this.agentDirectory) {
+                return res.status(503).json({ error: 'Agent protocol not initialized' });
+            }
+            try {
+                const response = await this.agentProtocol.receive(req.body);
+                res.json(response ?? { accepted: true });
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message });
+            }
+        });
+        router.get('/directory', async (_req, res) => {
+            if (!this.agentProtocol || !this.agentDirectory) {
+                return res.status(503).json({ error: 'Agent protocol not initialized' });
+            }
+            try {
+                const agents = await this.agentDirectory.listAll();
+                res.json({ agents });
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message });
+            }
+        });
+        router.get('/directory/search', async (req, res) => {
+            if (!this.agentProtocol || !this.agentDirectory) {
+                return res.status(503).json({ error: 'Agent protocol not initialized' });
+            }
+            try {
+                const results = await this.agentDirectory.search(req.query.q);
+                res.json({ results });
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message });
+            }
+        });
+        return router;
+    }
+    createTrustRouter() {
+        const router = Router();
+        const self = this;
+        router.get('/levels', (_req, res) => {
+            if (!self.trustEngine)
+                return res.status(503).json({ error: 'Trust engine not initialized' });
+            try {
+                const levels = self.trustEngine.getAllLevels();
+                res.json({ levels });
+            }
+            catch (err) {
+                res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+            }
+        });
+        router.get('/levels/:domain', (_req, res) => {
+            if (!self.trustEngine)
+                return res.status(503).json({ error: 'Trust engine not initialized' });
+            try {
+                const domain = _req.params.domain;
+                const level = self.trustEngine.getTrustLevel(domain);
+                const evidence = self.trustEngine.getEvidence(domain);
+                res.json({ domain, level, evidence });
+            }
+            catch (err) {
+                res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+            }
+        });
+        router.put('/levels/:domain', async (req, res) => {
+            if (!self.trustEngine)
+                return res.status(503).json({ error: 'Trust engine not initialized' });
+            try {
+                const domain = req.params.domain;
+                const { level, reason } = req.body;
+                await self.trustEngine.setTrustLevel(domain, level, reason);
+                res.json({ success: true });
+            }
+            catch (err) {
+                res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+            }
+        });
+        router.get('/audit', (_req, res) => {
+            if (!self.trustEngine)
+                return res.status(503).json({ error: 'Trust engine not initialized' });
+            try {
+                const history = self.trustAuditTrail ? self.trustAuditTrail.getAll() : [];
+                res.json({ history });
+            }
+            catch (err) {
+                res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+            }
+        });
+        return router;
+    }
+    createWorkflowRouter() {
+        const router = Router();
+        const self = this;
+        // Static routes MUST come before parameterized /:id routes
+        // GET / — list all workflows
+        router.get('/', async (_req, res) => {
+            if (!self.workflowEngine)
+                return res.status(503).json({ error: 'Workflow engine not initialized' });
+            try {
+                const workflows = await self.workflowEngine.listAll();
+                res.json({ workflows });
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message });
+            }
+        });
+        // POST / — create workflow
+        router.post('/', async (req, res) => {
+            if (!self.workflowEngine)
+                return res.status(503).json({ error: 'Workflow engine not initialized' });
+            try {
+                const workflow = await self.workflowEngine.createWorkflow(req.body);
+                res.json(workflow);
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message });
+            }
+        });
+        // GET /active — list active workflows
+        router.get('/active', async (_req, res) => {
+            if (!self.workflowEngine)
+                return res.status(503).json({ error: 'Workflow engine not initialized' });
+            try {
+                const workflows = await self.workflowEngine.listActive();
+                res.json({ workflows });
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message });
+            }
+        });
+        // GET /approvals/pending — list pending approvals
+        router.get('/approvals/pending', async (req, res) => {
+            if (!self.approvalManager)
+                return res.status(503).json({ error: 'Workflow engine not initialized' });
+            try {
+                const approvals = await self.approvalManager.getPending(req.query.userId);
+                res.json({ approvals });
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message });
+            }
+        });
+        // POST /approvals/:id/approve
+        router.post('/approvals/:id/approve', async (req, res) => {
+            if (!self.approvalManager)
+                return res.status(503).json({ error: 'Workflow engine not initialized' });
+            try {
+                const approval = await self.approvalManager.approve(req.params.id, req.body.decidedBy, req.body.reason);
+                if (!approval)
+                    return res.status(404).json({ error: 'Approval not found' });
+                res.json(approval);
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message });
+            }
+        });
+        // POST /approvals/:id/reject
+        router.post('/approvals/:id/reject', async (req, res) => {
+            if (!self.approvalManager)
+                return res.status(503).json({ error: 'Workflow engine not initialized' });
+            try {
+                const rejection = await self.approvalManager.reject(req.params.id, req.body.decidedBy, req.body.reason);
+                if (!rejection)
+                    return res.status(404).json({ error: 'Approval not found' });
+                res.json(rejection);
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message });
+            }
+        });
+        // GET /:id — get workflow by ID
+        router.get('/:id', async (req, res) => {
+            if (!self.workflowEngine)
+                return res.status(503).json({ error: 'Workflow engine not initialized' });
+            try {
+                const workflow = await self.workflowEngine.getWorkflow(req.params.id);
+                if (!workflow)
+                    return res.status(404).json({ error: 'Workflow not found' });
+                res.json(workflow);
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message });
+            }
+        });
+        // GET /:id/status — get workflow status
+        router.get('/:id/status', async (req, res) => {
+            if (!self.workflowEngine)
+                return res.status(503).json({ error: 'Workflow engine not initialized' });
+            try {
+                const status = await self.workflowEngine.getStatus(req.params.id);
+                if (!status)
+                    return res.status(404).json({ error: 'Workflow not found' });
+                res.json(status);
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message });
+            }
+        });
+        // POST /:id/start — start workflow
+        router.post('/:id/start', async (req, res) => {
+            if (!self.workflowEngine)
+                return res.status(503).json({ error: 'Workflow engine not initialized' });
+            try {
+                const workflow = await self.workflowEngine.startWorkflow(req.params.id);
+                if (!workflow)
+                    return res.status(404).json({ error: 'Workflow not found' });
+                res.json(workflow);
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message });
+            }
+        });
+        // POST /:id/cancel — cancel workflow
+        router.post('/:id/cancel', async (req, res) => {
+            if (!self.workflowEngine)
+                return res.status(503).json({ error: 'Workflow engine not initialized' });
+            try {
+                const result = await self.workflowEngine.cancelWorkflow(req.params.id);
+                if (!result)
+                    return res.status(404).json({ error: 'Workflow not found' });
+                res.json({ cancelled: true });
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message });
+            }
+        });
+        return router;
+    }
+    createUpdateRouter() {
+        const router = Router();
+        const self = this;
+        // GET /status — installation info + current version
+        router.get('/status', async (_req, res) => {
+            if (!self.installationDetector || !self.versionChecker) {
+                return res.status(503).json({ error: 'Update system not initialized' });
+            }
+            try {
+                const info = self.installationDetector.detect();
+                res.json({
+                    method: info.method,
+                    currentVersion: info.currentVersion,
+                    installPath: info.installPath,
+                    canSelfUpdate: info.canSelfUpdate,
+                    requiresSudo: info.requiresSudo,
+                });
+            }
+            catch (err) {
+                res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+            }
+        });
+        // POST /check — check for available updates
+        router.post('/check', async (req, res) => {
+            if (!self.installationDetector || !self.versionChecker) {
+                return res.status(503).json({ error: 'Update system not initialized' });
+            }
+            try {
+                const channel = (req.body?.channel ?? 'stable');
+                const info = self.installationDetector.detect();
+                const result = await self.versionChecker.check(info.currentVersion, channel);
+                res.json(result);
+            }
+            catch (err) {
+                res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+            }
+        });
+        // POST /apply — trigger an update
+        router.post('/apply', async (req, res) => {
+            if (!self.updater) {
+                return res.status(503).json({ error: 'Update system not initialized' });
+            }
+            try {
+                const channel = (req.body?.channel ?? 'stable');
+                const result = await self.updater.update(channel);
+                res.json(result);
+            }
+            catch (err) {
+                res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+            }
+        });
+        // POST /rollback — rollback a staged update
+        router.post('/rollback', async (_req, res) => {
+            if (!self.updater) {
+                return res.status(503).json({ error: 'Update system not initialized' });
+            }
+            try {
+                await self.updater.rollback();
+                res.json({ success: true });
+            }
+            catch (err) {
+                res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+            }
+        });
+        return router;
+    }
+    createConnectorRouter() {
+        const router = Router();
+        // GET / — list all connectors
+        router.get('/', (_req, res) => {
+            if (!this.connectorRegistry)
+                return res.status(503).json({ error: 'Connectors not configured' });
+            try {
+                res.json({ connectors: this.connectorRegistry.list() });
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message });
+            }
+        });
+        // GET /:id — get connector by id
+        router.get('/:id', (req, res) => {
+            if (!this.connectorRegistry)
+                return res.status(503).json({ error: 'Connectors not configured' });
+            try {
+                const connector = this.connectorRegistry.get(req.params.id);
+                if (!connector)
+                    return res.status(404).json({ error: 'Connector not found' });
+                res.json(connector);
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message });
+            }
+        });
+        // GET /:id/actions — get actions for connector
+        router.get('/:id/actions', (req, res) => {
+            if (!this.connectorRegistry)
+                return res.status(503).json({ error: 'Connectors not configured' });
+            try {
+                if (!this.connectorRegistry.has(req.params.id))
+                    return res.status(404).json({ error: 'Connector not found' });
+                const actions = this.connectorRegistry.getActions(req.params.id);
+                res.json({ actions });
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message });
+            }
+        });
+        // GET /:id/triggers — get triggers for connector
+        router.get('/:id/triggers', (req, res) => {
+            if (!this.connectorRegistry)
+                return res.status(503).json({ error: 'Connectors not configured' });
+            try {
+                if (!this.connectorRegistry.has(req.params.id))
+                    return res.status(404).json({ error: 'Connector not found' });
+                const triggers = this.connectorRegistry.getTriggers(req.params.id);
+                res.json({ triggers });
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message });
+            }
+        });
+        // POST /:id/authenticate — authenticate connector
+        router.post('/:id/authenticate', async (req, res) => {
+            if (!this.connectorRegistry)
+                return res.status(503).json({ error: 'Connectors not configured' });
+            if (!this.connectorAuthManager)
+                return res.status(503).json({ error: 'Auth manager not configured' });
+            try {
+                if (!this.connectorRegistry.has(req.params.id))
+                    return res.status(404).json({ error: 'Connector not found' });
+                await this.connectorAuthManager.authenticate(req.params.id, req.params.id, req.body.credentials);
+                res.json({ authenticated: true });
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message });
+            }
+        });
+        // POST /:id/disconnect — revoke connector token
+        router.post('/:id/disconnect', async (req, res) => {
+            if (!this.connectorRegistry)
+                return res.status(503).json({ error: 'Connectors not configured' });
+            if (!this.connectorAuthManager)
+                return res.status(503).json({ error: 'Auth manager not configured' });
+            try {
+                if (!this.connectorRegistry.has(req.params.id))
+                    return res.status(404).json({ error: 'Connector not found' });
+                await this.connectorAuthManager.revokeToken(req.params.id);
+                res.json({ disconnected: true });
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message });
+            }
+        });
+        // GET /:id/status — get connector auth status
+        router.get('/:id/status', (req, res) => {
+            if (!this.connectorRegistry)
+                return res.status(503).json({ error: 'Connectors not configured' });
+            if (!this.connectorAuthManager)
+                return res.status(503).json({ error: 'Auth manager not configured' });
+            try {
+                if (!this.connectorRegistry.has(req.params.id))
+                    return res.status(404).json({ error: 'Connector not found' });
+                res.json({
+                    connected: this.connectorAuthManager.hasToken(req.params.id),
+                    expired: this.connectorAuthManager.isTokenExpired(req.params.id),
+                });
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message });
+            }
+        });
+        return router;
+    }
+    createImageRouter() {
+        const router = Router();
+        router.get('/providers', (_req, res) => {
+            const providers = this.imageGenManager.listProviders();
+            const details = providers.map((name) => {
+                const p = this.imageGenManager.getProvider(name);
+                return {
+                    name,
+                    supportedSizes: p?.supportedSizes ?? [],
+                    supportedFormats: p?.supportedFormats ?? [],
+                    defaultModel: p?.defaultModel ?? '',
+                };
+            });
+            res.json({ providers: details });
+        });
+        router.post('/generate', async (req, res) => {
+            const { prompt, size, format, provider, negativePrompt, count, model, seed, style } = req.body;
+            if (!prompt || typeof prompt !== 'string') {
+                return res.status(400).json({ error: 'prompt required' });
+            }
+            const request = {
+                prompt,
+                ...(size && { size }),
+                ...(format && { format }),
+                ...(provider && { provider }),
+                ...(negativePrompt && { negativePrompt }),
+                ...(count && { count }),
+                ...(model && { model }),
+                ...(seed !== undefined && { seed }),
+                ...(style && { style }),
+            };
+            const result = await this.imageGenManager.generate(request);
+            if (!result.success) {
+                return res.status(502).json({ error: result.error, durationMs: result.durationMs });
+            }
+            res.json(result);
+        });
+        return router;
+    }
+    createRagRouter() {
+        const router = Router();
+        router.get('/documents', (_req, res) => {
+            res.json({ documents: this.documentStore.listDocuments() });
+        });
+        router.post('/documents', (req, res) => {
+            const { title, content, type, metadata } = req.body;
+            if (!title || typeof title !== 'string') {
+                return res.status(400).json({ error: 'title required' });
+            }
+            if (!content || typeof content !== 'string') {
+                return res.status(400).json({ error: 'content required' });
+            }
+            if (!type || typeof type !== 'string') {
+                return res.status(400).json({ error: 'type required' });
+            }
+            const doc = this.documentStore.ingest(title, content, type, metadata);
+            res.status(201).json(doc);
+        });
+        router.get('/documents/:id', (req, res) => {
+            const doc = this.documentStore.getDocument(req.params.id);
+            if (!doc)
+                return res.status(404).json({ error: 'document not found' });
+            res.json(doc);
+        });
+        router.delete('/documents/:id', (req, res) => {
+            const doc = this.documentStore.getDocument(req.params.id);
+            if (!doc)
+                return res.status(404).json({ error: 'document not found' });
+            this.documentStore.removeDocument(req.params.id);
+            res.json({ deleted: true });
+        });
+        router.post('/search', (req, res) => {
+            const { query, limit, minScore, type } = req.body;
+            if (!query || typeof query !== 'string') {
+                return res.status(400).json({ error: 'query required' });
+            }
+            const results = this.documentStore.search(query, { limit, minScore, type });
+            res.json({ results });
+        });
+        router.post('/context', (req, res) => {
+            const { query, maxTokens, maxChunks } = req.body;
+            if (!query || typeof query !== 'string') {
+                return res.status(400).json({ error: 'query required' });
+            }
+            const context = this.contextBuilder.buildContext(query, this.documentStore, { maxTokens, maxChunks });
+            res.json({ context });
+        });
+        router.get('/stats', (_req, res) => {
+            res.json(this.documentStore.stats());
+        });
+        return router;
+    }
+    createMcpRouter() {
+        const router = Router();
+        router.get('/servers', (_req, res) => {
+            if (!this.mcpClientManager) {
+                return res.json({ servers: {} });
+            }
+            const status = this.mcpClientManager.getStatus();
+            const servers = {};
+            for (const [name, s] of status) {
+                servers[name] = s;
+            }
+            res.json({ servers });
+        });
+        router.post('/servers/:name/connect', async (req, res) => {
+            if (!this.mcpClientManager) {
+                return res.status(503).json({ error: 'MCP not configured' });
+            }
+            try {
+                await this.mcpClientManager.connect(req.params.name);
+                await audit('connector.connected', { connector: req.params.name, type: 'mcp' });
+                res.json({ status: 'connected' });
+            }
+            catch (err) {
+                res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+            }
+        });
+        router.post('/servers/:name/disconnect', async (req, res) => {
+            if (!this.mcpClientManager) {
+                return res.status(503).json({ error: 'MCP not configured' });
+            }
+            try {
+                await this.mcpClientManager.disconnect(req.params.name);
+                await audit('connector.disconnected', { connector: req.params.name, type: 'mcp' });
+                res.json({ status: 'disconnected' });
+            }
+            catch (err) {
+                res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+            }
+        });
+        router.get('/servers/:name/tools', (req, res) => {
+            if (!this.mcpClientManager) {
+                return res.status(503).json({ error: 'MCP not configured' });
+            }
+            const tools = this.mcpClientManager.getToolsForServer(req.params.name);
+            res.json({ tools });
+        });
+        return router;
+    }
+    createEvalRouter() {
+        const router = Router();
+        // GET /history/:suiteName — returns suite run history
+        router.get('/history/:suiteName', (_req, res) => {
+            if (!this.evalStore) {
+                return res.status(503).json({ error: 'Evaluation system not initialized' });
+            }
+            try {
+                const history = this.evalStore.getHistory(_req.params.suiteName);
+                res.json({ history });
+            }
+            catch (err) {
+                res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+            }
+        });
+        // GET /latest/:suiteName — returns latest suite result or 404
+        router.get('/latest/:suiteName', (_req, res) => {
+            if (!this.evalStore) {
+                return res.status(503).json({ error: 'Evaluation system not initialized' });
+            }
+            try {
+                const latest = this.evalStore.getLatest(_req.params.suiteName);
+                if (!latest) {
+                    return res.status(404).json({ error: 'No results found for suite' });
+                }
+                res.json(latest);
+            }
+            catch (err) {
+                res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+            }
+        });
+        // GET /trend/:suiteName/:metricName — returns score trend for a metric
+        router.get('/trend/:suiteName/:metricName', (_req, res) => {
+            if (!this.evalStore) {
+                return res.status(503).json({ error: 'Evaluation system not initialized' });
+            }
+            try {
+                const trend = this.evalStore.getTrend(_req.params.suiteName, _req.params.metricName);
+                res.json({ trend });
+            }
+            catch (err) {
+                res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+            }
+        });
+        // POST /run — run evaluation suite
+        router.post('/run', async (req, res) => {
+            if (!this.evalRunner || !this.evalStore) {
+                return res.status(503).json({ error: 'Evaluation system not initialized' });
+            }
+            try {
+                const { suiteName, cases, mode } = req.body;
+                if (!suiteName || !cases || !Array.isArray(cases) || cases.length === 0) {
+                    return res.status(400).json({ error: 'suiteName and non-empty cases array required' });
+                }
+                const handler = mode === 'echo' || !mode
+                    ? async (input) => input
+                    : async (input) => input;
+                const result = await this.evalRunner.runSuite(suiteName, cases, handler);
+                this.evalStore.record(result);
+                res.json(result);
+            }
+            catch (err) {
+                res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+            }
+        });
+        // POST /compare — compare latest results of two suites
+        router.post('/compare', (_req, res) => {
+            if (!this.evalRunner || !this.evalStore) {
+                return res.status(503).json({ error: 'Evaluation system not initialized' });
+            }
+            try {
+                const { suiteNameA, suiteNameB } = _req.body;
+                if (!suiteNameA || !suiteNameB) {
+                    return res.status(400).json({ error: 'suiteNameA and suiteNameB required' });
+                }
+                const latestA = this.evalStore.getLatest(suiteNameA);
+                const latestB = this.evalStore.getLatest(suiteNameB);
+                if (!latestA) {
+                    return res.status(404).json({ error: `No results found for suite: ${suiteNameA}` });
+                }
+                if (!latestB) {
+                    return res.status(404).json({ error: `No results found for suite: ${suiteNameB}` });
+                }
+                const comparison = this.evalRunner.compareSuites(latestA, latestB);
+                res.json(comparison);
+            }
+            catch (err) {
+                res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+            }
+        });
+        return router;
+    }
+    createCodeRouter() {
+        const router = Router();
+        // POST /execute — one-shot code execution (no session required)
+        router.post('/execute', async (req, res) => {
+            try {
+                const { language, code, timeout } = req.body;
+                if (!language || typeof language !== 'string') {
+                    return res.status(400).json({ error: 'language required' });
+                }
+                if (!code || typeof code !== 'string') {
+                    return res.status(400).json({ error: 'code required' });
+                }
+                const validLanguages = ['javascript', 'typescript', 'python', 'shell'];
+                if (!validLanguages.includes(language)) {
+                    return res.status(400).json({ error: `Invalid language. Allowed: ${validLanguages.join(', ')}` });
+                }
+                const result = await this.codeExecutor.execute({
+                    language: language,
+                    code,
+                    timeoutMs: timeout,
+                });
+                res.json(result);
+            }
+            catch (err) {
+                res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+            }
+        });
+        // GET /sessions — list active sessions
+        router.get('/sessions', (_req, res) => {
+            const sessions = this.codeSessionManager.listSessions().map((s) => ({
+                id: s.id,
+                language: s.language,
+                createdAt: s.createdAt,
+                lastActivity: s.lastActivity,
+                historyLength: s.history.length,
+            }));
+            res.json({ sessions });
+        });
+        // POST /sessions — create a new REPL session
+        router.post('/sessions', (req, res) => {
+            try {
+                const { language } = req.body;
+                if (!language || typeof language !== 'string') {
+                    return res.status(400).json({ error: 'language required' });
+                }
+                const validLanguages = ['javascript', 'typescript', 'python', 'shell'];
+                if (!validLanguages.includes(language)) {
+                    return res.status(400).json({ error: `Invalid language. Allowed: ${validLanguages.join(', ')}` });
+                }
+                const session = this.codeSessionManager.createSession(language);
+                res.status(201).json({
+                    id: session.id,
+                    language: session.language,
+                    createdAt: session.createdAt,
+                });
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                const status = message.includes('Maximum number of sessions') ? 409 : 500;
+                res.status(status).json({ error: message });
+            }
+        });
+        // GET /sessions/:id — get session details
+        router.get('/sessions/:id', (req, res) => {
+            const session = this.codeSessionManager.getSession(req.params.id);
+            if (!session) {
+                return res.status(404).json({ error: 'session not found' });
+            }
+            res.json({
+                id: session.id,
+                language: session.language,
+                createdAt: session.createdAt,
+                lastActivity: session.lastActivity,
+                historyLength: session.history.length,
+                history: session.history,
+            });
+        });
+        // POST /sessions/:id/execute — execute code in a session
+        router.post('/sessions/:id/execute', async (req, res) => {
+            try {
+                const { code } = req.body;
+                if (!code || typeof code !== 'string') {
+                    return res.status(400).json({ error: 'code required' });
+                }
+                const result = await this.codeSessionManager.execute(req.params.id, code);
+                res.json(result);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                if (message.includes('not found')) {
+                    return res.status(404).json({ error: message });
+                }
+                res.status(500).json({ error: message });
+            }
+        });
+        // DELETE /sessions/:id — destroy a session
+        router.delete('/sessions/:id', (req, res) => {
+            const session = this.codeSessionManager.getSession(req.params.id);
+            if (!session) {
+                return res.status(404).json({ error: 'session not found' });
+            }
+            this.codeSessionManager.destroySession(req.params.id);
+            res.json({ deleted: true });
+        });
+        return router;
+    }
+    createBackupRouter() {
+        const router = Router();
+        let nextId = 1;
+        // POST /create — create a new backup
+        router.post('/create', async (req, res) => {
+            if (!this.backupManager) {
+                return res.status(503).json({ error: 'Backup system not initialized' });
+            }
+            try {
+                const { categories } = req.body;
+                const result = await this.backupManager.createBackup(categories);
+                if (result.status === 'failed') {
+                    return res.status(500).json({ error: result.error ?? 'Backup failed' });
+                }
+                const id = `backup-${nextId++}`;
+                this.backupStore.set(id, result);
+                res.status(201).json({ id, ...result });
+            }
+            catch (err) {
+                res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+            }
+        });
+        // GET /list — list all stored backups
+        router.get('/list', (_req, res) => {
+            const backups = [...this.backupStore.entries()].map(([id, b]) => ({
+                id,
+                status: b.status,
+                manifest: b.manifest,
+            }));
+            res.json({ backups });
+        });
+        // POST /restore — restore from a backup
+        router.post('/restore', async (req, res) => {
+            if (!this.backupManager) {
+                return res.status(503).json({ error: 'Backup system not initialized' });
+            }
+            try {
+                const { backupId, categories } = req.body;
+                if (!backupId || typeof backupId !== 'string') {
+                    return res.status(400).json({ error: 'backupId required' });
+                }
+                const backup = this.backupStore.get(backupId);
+                if (!backup) {
+                    return res.status(404).json({ error: 'Backup not found' });
+                }
+                const result = await this.backupManager.restore(backup, categories);
+                if (result.status === 'failed') {
+                    return res.status(500).json({ error: result.error ?? 'Restore failed' });
+                }
+                res.json(result);
+            }
+            catch (err) {
+                res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+            }
+        });
+        // DELETE /:id — delete a stored backup
+        router.delete('/:id', (req, res) => {
+            const { id } = req.params;
+            if (!this.backupStore.has(id)) {
+                return res.status(404).json({ error: 'Backup not found' });
+            }
+            this.backupStore.delete(id);
+            res.json({ deleted: true });
+        });
+        return router;
+    }
+    createKnowledgeRouter() {
+        const router = Router();
+        router.post('/entities', (req, res) => {
+            const { name, type, properties, aliases } = req.body;
+            if (!name || typeof name !== 'string')
+                return res.status(400).json({ error: 'name required' });
+            if (!type || typeof type !== 'string')
+                return res.status(400).json({ error: 'type required' });
+            try {
+                const node = this.knowledgeGraph.addNode({ name, type: type, aliases: aliases ?? [], properties: properties ?? {}, confidence: 1.0 });
+                res.status(201).json(node);
+            }
+            catch (err) {
+                res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+            }
+        });
+        router.get('/entities', (req, res) => {
+            const query = req.query.query;
+            if (query) {
+                const extracted = this.entityLinker.extractEntities(query);
+                const nodes = extracted.map((e) => this.knowledgeGraph.getNode(e.name)).filter(Boolean);
+                return res.json({ entities: nodes });
+            }
+            return res.json({ entities: [], stats: this.knowledgeGraph.stats() });
+        });
+        router.get('/entities/:id', (req, res) => {
+            const node = this.knowledgeGraph.getNode(req.params.id);
+            if (!node)
+                return res.status(404).json({ error: 'entity not found' });
+            res.json(node);
+        });
+        router.delete('/entities/:id', (req, res) => {
+            const node = this.knowledgeGraph.getNode(req.params.id);
+            if (!node)
+                return res.status(404).json({ error: 'entity not found' });
+            this.knowledgeGraph.removeNode(node.id);
+            res.json({ deleted: true });
+        });
+        router.post('/relations', (req, res) => {
+            const { from, to, type, properties, weight, label, evidence } = req.body;
+            if (!from || typeof from !== 'string')
+                return res.status(400).json({ error: 'from required' });
+            if (!to || typeof to !== 'string')
+                return res.status(400).json({ error: 'to required' });
+            if (!type || typeof type !== 'string')
+                return res.status(400).json({ error: 'type required' });
+            try {
+                const edge = this.knowledgeGraph.addEdge(from, to, type, { weight, label, evidence, properties });
+                res.status(201).json(edge);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                if (message.includes('not found'))
+                    return res.status(404).json({ error: message });
+                res.status(500).json({ error: message });
+            }
+        });
+        router.get('/relations', (req, res) => {
+            const nodeId = req.query.nodeId;
+            const direction = req.query.direction ?? 'both';
+            if (!nodeId)
+                return res.status(400).json({ error: 'nodeId query parameter required' });
+            const node = this.knowledgeGraph.getNode(nodeId);
+            if (!node)
+                return res.status(404).json({ error: 'node not found' });
+            res.json({ relations: this.knowledgeGraph.getEdges(node.id, direction) });
+        });
+        router.post('/query', (req, res) => {
+            const { startNode, relation, targetType, maxDepth, minConfidence } = req.body;
+            try {
+                res.json(this.knowledgeGraph.query({ startNode, relation, targetType, maxDepth, minConfidence }));
+            }
+            catch (err) {
+                res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+            }
+        });
+        router.post('/extract', (req, res) => {
+            const { text } = req.body;
+            if (!text || typeof text !== 'string')
+                return res.status(400).json({ error: 'text required' });
+            try {
+                const result = this.entityLinker.linkToGraph(text, this.knowledgeGraph);
+                res.json({ newNodes: result.newNodes, newEdges: result.newEdges });
+            }
+            catch (err) {
+                res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+            }
+        });
+        router.get('/stats', (_req, res) => {
+            res.json(this.knowledgeGraph.stats());
+        });
+        return router;
+    }
+    createAutomationRouter() {
+        const router = Router();
+        router.post('/parse', (req, res) => {
+            const { input } = req.body;
+            if (!input || typeof input !== 'string') {
+                return res.status(400).json({ error: 'input required' });
+            }
+            const spec = this.nlIntentParser.parse(input);
+            res.json({ spec });
+        });
+        router.post('/build', (req, res) => {
+            const { spec } = req.body;
+            if (!spec || typeof spec !== 'object') {
+                return res.status(400).json({ error: 'spec required' });
+            }
+            try {
+                const behavior = this.automationBuilder.build(spec);
+                res.json({ behavior });
+            }
+            catch (err) {
+                res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+            }
+        });
+        router.post('/validate', (req, res) => {
+            const { spec } = req.body;
+            if (!spec || typeof spec !== 'object') {
+                return res.status(400).json({ error: 'spec required' });
+            }
+            const result = this.automationBuilder.validate(spec, [], []);
+            res.json({ result });
+        });
+        return router;
+    }
+    createBranchRouter() {
+        const router = Router();
+        const getOrCreateManager = (conversationId) => {
+            let mgr = this.branchManagers.get(conversationId);
+            if (!mgr) {
+                mgr = new BranchManager(conversationId);
+                this.branchManagers.set(conversationId, mgr);
+            }
+            return mgr;
+        };
+        router.get('/:conversationId', (req, res) => {
+            const mgr = getOrCreateManager(req.params.conversationId);
+            res.json({ branches: mgr.listBranches(), active: mgr.getActiveBranch() });
+        });
+        router.post('/:conversationId/fork', (req, res) => {
+            const mgr = getOrCreateManager(req.params.conversationId);
+            const { messageId, label } = req.body;
+            try {
+                const branch = mgr.fork(messageId, label);
+                res.status(201).json(branch);
+            }
+            catch (err) {
+                res.status(400).json({ error: err instanceof Error ? err.message : String(err) });
+            }
+        });
+        router.post('/:conversationId/switch', (req, res) => {
+            const mgr = getOrCreateManager(req.params.conversationId);
+            const { branchId } = req.body;
+            if (!branchId || typeof branchId !== 'string') {
+                return res.status(400).json({ error: 'branchId required' });
+            }
+            try {
+                const branch = mgr.switchBranch(branchId);
+                res.json(branch);
+            }
+            catch (err) {
+                res.status(400).json({ error: err instanceof Error ? err.message : String(err) });
+            }
+        });
+        router.get('/:conversationId/tree', (req, res) => {
+            const mgr = getOrCreateManager(req.params.conversationId);
+            res.json({ tree: mgr.getTree() });
+        });
+        router.post('/:conversationId/merge', (req, res) => {
+            const mgr = getOrCreateManager(req.params.conversationId);
+            const { sourceBranchId, targetBranchId } = req.body;
+            if (!sourceBranchId || typeof sourceBranchId !== 'string') {
+                return res.status(400).json({ error: 'sourceBranchId required' });
+            }
+            if (!targetBranchId || typeof targetBranchId !== 'string') {
+                return res.status(400).json({ error: 'targetBranchId required' });
+            }
+            try {
+                mgr.mergeBranch(sourceBranchId, targetBranchId);
+                res.json({ merged: true });
+            }
+            catch (err) {
+                res.status(400).json({ error: err instanceof Error ? err.message : String(err) });
+            }
+        });
+        router.delete('/:conversationId/:branchId', (req, res) => {
+            const mgr = getOrCreateManager(req.params.conversationId);
+            try {
+                mgr.deleteBranch(req.params.branchId);
+                res.json({ deleted: true });
+            }
+            catch (err) {
+                res.status(400).json({ error: err instanceof Error ? err.message : String(err) });
+            }
+        });
+        return router;
+    }
+    createApprovalQueueRouter() {
+        const router = Router();
+        // GET / — list all approval requests
+        router.get('/', (_req, res) => {
+            if (!this.approvalQueue) {
+                return res.status(503).json({ error: 'Approval queue not initialized' });
+            }
+            res.json(this.approvalQueue.listAll());
+        });
+        // GET /pending — list pending approval requests
+        router.get('/pending', (_req, res) => {
+            if (!this.approvalQueue) {
+                return res.status(503).json({ error: 'Approval queue not initialized' });
+            }
+            res.json(this.approvalQueue.listPending());
+        });
+        // POST /expire — expire stale requests
+        router.post('/expire', (_req, res) => {
+            if (!this.approvalQueue) {
+                return res.status(503).json({ error: 'Approval queue not initialized' });
+            }
+            const expired = this.approvalQueue.expireStale();
+            res.json({ expired });
+        });
+        // GET /:id — get a specific approval request
+        router.get('/:id', (req, res) => {
+            if (!this.approvalQueue) {
+                return res.status(503).json({ error: 'Approval queue not initialized' });
+            }
+            const request = this.approvalQueue.get(req.params.id);
+            if (!request) {
+                return res.status(404).json({ error: 'Approval request not found' });
+            }
+            res.json(request);
+        });
+        // POST /:id/approve — approve a request
+        router.post('/:id/approve', (req, res) => {
+            if (!this.approvalQueue) {
+                return res.status(503).json({ error: 'Approval queue not initialized' });
+            }
+            try {
+                const { decidedBy } = req.body;
+                const result = this.approvalQueue.approve(req.params.id, decidedBy);
+                res.json(result);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                if (message.includes('not found')) {
+                    return res.status(404).json({ error: message });
+                }
+                if (message.includes('already')) {
+                    return res.status(409).json({ error: message });
+                }
+                res.status(500).json({ error: message });
+            }
+        });
+        // POST /:id/deny — deny a request
+        router.post('/:id/deny', (req, res) => {
+            if (!this.approvalQueue) {
+                return res.status(503).json({ error: 'Approval queue not initialized' });
+            }
+            try {
+                const { decidedBy, reason } = req.body;
+                const result = this.approvalQueue.deny(req.params.id, reason, decidedBy);
+                res.json(result);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                if (message.includes('not found')) {
+                    return res.status(404).json({ error: message });
+                }
+                if (message.includes('already')) {
+                    return res.status(409).json({ error: message });
+                }
+                res.status(500).json({ error: message });
+            }
+        });
+        return router;
+    }
+    createVectorRouter() {
+        const router = Router();
+        // GET /stats — get store statistics
+        router.get('/stats', (_req, res) => {
+            if (!this.vectorStore) {
+                return res.status(503).json({ error: 'Vector store not initialized' });
+            }
+            res.json({ size: this.vectorStore.size() });
+        });
+        // POST / — add a vector entry
+        router.post('/', (req, res) => {
+            if (!this.vectorStore) {
+                return res.status(503).json({ error: 'Vector store not initialized' });
+            }
+            try {
+                const { id, vector, content, metadata } = req.body;
+                if (!id || typeof id !== 'string') {
+                    return res.status(400).json({ error: 'id required' });
+                }
+                if (!vector || !Array.isArray(vector)) {
+                    return res.status(400).json({ error: 'vector required' });
+                }
+                const entry = this.vectorStore.add(id, vector, content ?? '', metadata);
+                res.status(201).json(entry);
+            }
+            catch (err) {
+                res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+            }
+        });
+        // POST /search — search vectors
+        router.post('/search', (req, res) => {
+            if (!this.vectorStore) {
+                return res.status(503).json({ error: 'Vector store not initialized' });
+            }
+            try {
+                const { vector, limit, minScore } = req.body;
+                if (!vector || !Array.isArray(vector)) {
+                    return res.status(400).json({ error: 'vector required' });
+                }
+                const results = this.vectorStore.search(vector, limit, minScore);
+                res.json(results);
+            }
+            catch (err) {
+                res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+            }
+        });
+        // GET /:id — get a vector entry by ID
+        router.get('/:id', (req, res) => {
+            if (!this.vectorStore) {
+                return res.status(503).json({ error: 'Vector store not initialized' });
+            }
+            const entry = this.vectorStore.get(req.params.id);
+            if (!entry) {
+                return res.status(404).json({ error: 'Vector entry not found' });
+            }
+            res.json(entry);
+        });
+        // DELETE /:id — remove a vector entry
+        router.delete('/:id', (req, res) => {
+            if (!this.vectorStore) {
+                return res.status(503).json({ error: 'Vector store not initialized' });
+            }
+            const removed = this.vectorStore.remove(req.params.id);
+            if (!removed) {
+                return res.status(404).json({ error: 'Vector entry not found' });
+            }
+            res.json({ deleted: true });
+        });
+        return router;
+    }
+    createReactRouter() {
+        const router = Router();
+        // POST /run — start a new ReAct loop
+        router.post('/run', (req, res) => {
+            const { goal, maxSteps } = req.body;
+            if (!goal || typeof goal !== 'string') {
+                return res.status(400).json({ error: 'goal is required' });
+            }
+            const id = crypto.randomUUID();
+            const config = {};
+            if (maxSteps) {
+                config.maxSteps = maxSteps;
+            }
+            const callbacks = {
+                think: async (g, history) => {
+                    // Simple stub: produce an answer after gathering context
+                    if (history.length > 0) {
+                        return { thought: `Analyzed goal: ${g}`, answer: `Completed goal: ${g}` };
+                    }
+                    return { thought: `Planning approach for: ${g}` };
+                },
+                executeTool: async (toolName, params) => {
+                    try {
+                        const result = await toolExecutor.execute(toolName, params, {
+                            sessionId: id,
+                            userId: 'react-loop',
+                        });
+                        return typeof result === 'string' ? result : JSON.stringify(result);
+                    }
+                    catch (err) {
+                        return `Error: ${err instanceof Error ? err.message : String(err)}`;
+                    }
+                },
+            };
+            const loop = new ReActLoop(callbacks, config);
+            this.reactLoops.set(id, loop);
+            // Run async — do not await
+            loop.run(goal).then((result) => {
+                this.reactResults.set(id, result);
+            }).catch(() => {
+                // Errors captured in result
+            });
+            res.status(201).json({ id, status: loop.getStatus() });
+        });
+        // GET /:id/status — get loop status
+        router.get('/:id/status', (req, res) => {
+            const loop = this.reactLoops.get(req.params.id);
+            if (!loop) {
+                return res.status(404).json({ error: 'Loop not found' });
+            }
+            const result = this.reactResults.get(req.params.id);
+            res.json({ status: loop.getStatus(), result: result ?? null });
+        });
+        // GET /:id/steps — get loop steps
+        router.get('/:id/steps', (req, res) => {
+            const loop = this.reactLoops.get(req.params.id);
+            if (!loop) {
+                return res.status(404).json({ error: 'Loop not found' });
+            }
+            res.json(loop.getSteps());
+        });
+        // POST /:id/pause — pause loop
+        router.post('/:id/pause', (req, res) => {
+            const loop = this.reactLoops.get(req.params.id);
+            if (!loop) {
+                return res.status(404).json({ error: 'Loop not found' });
+            }
+            loop.pause();
+            res.json({ status: loop.getStatus() });
+        });
+        // POST /:id/resume — resume loop
+        router.post('/:id/resume', (req, res) => {
+            const loop = this.reactLoops.get(req.params.id);
+            if (!loop) {
+                return res.status(404).json({ error: 'Loop not found' });
+            }
+            loop.resume();
+            res.json({ status: loop.getStatus() });
+        });
+        // POST /:id/abort — abort loop
+        router.post('/:id/abort', (req, res) => {
+            const loop = this.reactLoops.get(req.params.id);
+            if (!loop) {
+                return res.status(404).json({ error: 'Loop not found' });
+            }
+            loop.abort(req.body?.reason);
+            res.json({ status: loop.getStatus() });
+        });
+        return router;
+    }
+    createA2ARouter() {
+        const router = Router();
+        // GET /card — return this agent's capability card
+        router.get('/card', (_req, res) => {
+            if (!this.a2aAgentCard) {
+                return res.status(503).json({ error: 'A2A not initialized' });
+            }
+            res.json(this.a2aAgentCard);
+        });
+        // POST /tasks — send a task (create via task manager)
+        router.post('/tasks', (req, res) => {
+            const { targetUrl, task } = req.body;
+            if (!task?.message) {
+                return res.status(400).json({ error: 'task.message is required' });
+            }
+            const a2aTask = this.a2aTaskManager.createTask({
+                role: 'user',
+                parts: [{ type: 'text', text: task.message }],
+                timestamp: Date.now(),
+            });
+            if (targetUrl) {
+                // Store target URL as metadata for potential forwarding
+                a2aTask.metadata = { targetUrl };
+            }
+            res.status(201).json(a2aTask);
+        });
+        // GET /tasks/:id — get task status
+        router.get('/tasks/:id', (req, res) => {
+            const task = this.a2aTaskManager.getTask(req.params.id);
+            if (!task) {
+                return res.status(404).json({ error: 'Task not found' });
+            }
+            res.json(task);
+        });
+        // POST /tasks/:id/cancel — cancel task
+        router.post('/tasks/:id/cancel', (req, res) => {
+            const task = this.a2aTaskManager.getTask(req.params.id);
+            if (!task) {
+                return res.status(404).json({ error: 'Task not found' });
+            }
+            try {
+                this.a2aTaskManager.cancelTask(req.params.id);
+                res.json(this.a2aTaskManager.getTask(req.params.id));
+            }
+            catch (err) {
+                res.status(400).json({ error: err instanceof Error ? err.message : String(err) });
+            }
+        });
+        return router;
+    }
+    createCanvasRouter() {
+        const router = Router();
+        // POST /sessions — create a new canvas session
+        router.post('/sessions', (req, res) => {
+            const { width, height } = req.body;
+            const session = new CanvasSession({ width, height });
+            this.canvasSessions.set(session.id, session);
+            res.status(201).json({ id: session.id, ...session.getSize() });
+        });
+        // GET /sessions/:id — get session state
+        router.get('/sessions/:id', (req, res) => {
+            const session = this.canvasSessions.get(req.params.id);
+            if (!session) {
+                return res.status(404).json({ error: 'Session not found' });
+            }
+            res.json({ id: session.id, objects: session.getObjects(), size: session.getSize() });
+        });
+        // POST /sessions/:id/objects — add object
+        router.post('/sessions/:id/objects', (req, res) => {
+            const session = this.canvasSessions.get(req.params.id);
+            if (!session) {
+                return res.status(404).json({ error: 'Session not found' });
+            }
+            try {
+                const obj = session.addObject(req.body);
+                res.status(201).json(obj);
+            }
+            catch (err) {
+                res.status(400).json({ error: err instanceof Error ? err.message : String(err) });
+            }
+        });
+        // PUT /sessions/:id/objects/:objectId — update object
+        router.put('/sessions/:id/objects/:objectId', (req, res) => {
+            const session = this.canvasSessions.get(req.params.id);
+            if (!session) {
+                return res.status(404).json({ error: 'Session not found' });
+            }
+            const updated = session.updateObject(req.params.objectId, req.body);
+            if (!updated) {
+                return res.status(404).json({ error: 'Object not found' });
+            }
+            res.json(updated);
+        });
+        // DELETE /sessions/:id/objects/:objectId — remove object
+        router.delete('/sessions/:id/objects/:objectId', (req, res) => {
+            const session = this.canvasSessions.get(req.params.id);
+            if (!session) {
+                return res.status(404).json({ error: 'Session not found' });
+            }
+            const removed = session.removeObject(req.params.objectId);
+            if (!removed) {
+                return res.status(404).json({ error: 'Object not found' });
+            }
+            res.json({ deleted: true });
+        });
+        // DELETE /sessions/:id — delete session
+        router.delete('/sessions/:id', (req, res) => {
+            const existed = this.canvasSessions.delete(req.params.id);
+            if (!existed) {
+                return res.status(404).json({ error: 'Session not found' });
+            }
+            res.json({ deleted: true });
+        });
+        return router;
+    }
+    createSandboxRouter() {
+        const router = Router();
+        // POST /sessions — create a sandbox session
+        router.post('/sessions', async (req, res) => {
+            if (!this.sandboxManager) {
+                return res.status(503).json({ error: 'Sandbox not initialized' });
+            }
+            const { workspaceDir } = req.body;
+            if (!workspaceDir || typeof workspaceDir !== 'string') {
+                return res.status(400).json({ error: 'workspaceDir is required' });
+            }
+            try {
+                const sessionId = crypto.randomUUID();
+                const session = await this.sandboxManager.createSession(sessionId, workspaceDir);
+                res.status(201).json(session.getInfo());
+            }
+            catch (err) {
+                res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+            }
+        });
+        // POST /sessions/:id/run — run command in sandbox
+        router.post('/sessions/:id/run', async (req, res) => {
+            if (!this.sandboxManager) {
+                return res.status(503).json({ error: 'Sandbox not initialized' });
+            }
+            const { command } = req.body;
+            if (!command || !Array.isArray(command)) {
+                return res.status(400).json({ error: 'command array is required' });
+            }
+            try {
+                const result = await this.sandboxManager.runInSandbox(req.params.id, command);
+                res.json(result);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                if (message.includes('No sandbox session found')) {
+                    return res.status(404).json({ error: message });
+                }
+                res.status(500).json({ error: message });
+            }
+        });
+        // GET /sessions/:id — get session info
+        router.get('/sessions/:id', (req, res) => {
+            if (!this.sandboxManager) {
+                return res.status(503).json({ error: 'Sandbox not initialized' });
+            }
+            const session = this.sandboxManager.getSession(req.params.id);
+            if (!session) {
+                return res.status(404).json({ error: 'Session not found' });
+            }
+            res.json(session.getInfo());
+        });
+        // DELETE /sessions/:id — stop and remove
+        router.delete('/sessions/:id', async (req, res) => {
+            if (!this.sandboxManager) {
+                return res.status(503).json({ error: 'Sandbox not initialized' });
+            }
+            try {
+                const removed = await this.sandboxManager.destroySession(req.params.id);
+                if (!removed) {
+                    return res.status(404).json({ error: 'Session not found' });
+                }
+                res.json({ deleted: true });
+            }
+            catch (err) {
+                res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+            }
+        });
+        return router;
+    }
 }
 function deepMerge(target, source) {
     const result = { ...target };