aiden-runtime 3.16.0

package/dist/core/failureAnalyzer.js

@@ -0,0 +1,166 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAILURE_KEYWORDS = void 0;
+exports.detectFailureSignal = detectFailureSignal;
+exports.analyzeFailureTrace = analyzeFailureTrace;
+// core/failureAnalyzer.ts — N+32 Deep GEPA failure trace analysis.
+//
+// Detects when a task failed (via keyword signal, consecutive tool errors,
+// budget exhaustion, or /failed command), calls an LLM to identify the root
+// cause, appends a lesson to workspace/LESSONS.md, and degrades the skill's
+// confidence score so future lookups are aware of the failure history.
+//
+// callLLM is imported DYNAMICALLY to avoid a circular dependency:
+//   server.ts → failureAnalyzer → agentLoop → server.ts  (would deadlock)
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const lessonsBrowser_1 = require("./lessonsBrowser");
+// ── Failure keyword detection ─────────────────────────────────
+exports.FAILURE_KEYWORDS = [
+    "that's wrong", "thats wrong",
+    "no that's not", "no thats not",
+    "wrong answer",
+    "didn't work", "didnt work",
+    "failed",
+    "incorrect",
+    "you got it wrong",
+    "not what i asked",
+    "that was wrong",
+    "that's not right", "thats not right",
+    "not right",
+    "that's incorrect",
+    "you're wrong", "youre wrong",
+    "wrong result",
+];
+function detectFailureSignal(message) {
+    const lower = message.toLowerCase();
+    return exports.FAILURE_KEYWORDS.some(kw => lower.includes(kw));
+}
+// ── Main analyzer ─────────────────────────────────────────────
+async function analyzeFailureTrace(trace) {
+    // Dynamic import — prevents circular dep agentLoop ↔ server
+    let callLLM;
+    try {
+        const mod = await Promise.resolve().then(() => __importStar(require('./agentLoop')));
+        callLLM = mod.callLLM;
+    }
+    catch {
+        console.warn('[failureAnalyzer] could not import callLLM — writing minimal lesson');
+        _writeMinimalLesson(trace);
+        return;
+    }
+    const transcript = [
+        `User request: ${trace.userMessage}`,
+        `AI response (truncated): ${trace.aiReply.slice(0, 600)}`,
+        `Tools used: ${trace.toolsUsed.join(', ') || 'none'}`,
+        `Errors: ${trace.errors.join('; ') || 'none'}`,
+        `Failure signal: ${trace.signal}`,
+    ].join('\n');
+    const prompt = `You are a failure analyzer for an AI assistant. Analyze why the following task produced a bad result.
+
+${transcript}
+
+Respond with ONLY valid JSON and nothing else:
+{
+  "rootCause": "1-sentence technical root cause",
+  "pattern": "one of: wrong_tool | hallucination | scope_creep | api_error | missing_context | bad_plan | timeout | unknown",
+  "lesson": "1-2 sentence actionable rule for the AI — start with When / Always / Never / If",
+  "failedSkill": "skill folder name if a learned/approved/installed skill was the culprit, or null"
+}`;
+    let analysis = null;
+    try {
+        // callLLM signature: (prompt, apiKey?, model?, provider?) — pass nulls to use defaults
+        const raw = await callLLM(prompt, null, null, null);
+        const text = typeof raw === 'string' ? raw : (raw?.content ?? '');
+        const json = text.match(/\{[\s\S]*\}/);
+        if (json)
+            analysis = JSON.parse(json[0]);
+    }
+    catch (e) {
+        console.warn('[failureAnalyzer] LLM analysis failed:', e.message);
+    }
+    if (!analysis) {
+        _writeMinimalLesson(trace);
+        return;
+    }
+    // Write lesson to LESSONS.md
+    const lessonText = `[${analysis.pattern}] ${analysis.lesson} (rootCause: ${analysis.rootCause})`;
+    (0, lessonsBrowser_1.appendLesson)(lessonText);
+    console.log(`[failureAnalyzer] lesson appended: ${lessonText.slice(0, 80)}…`);
+    // Degrade skill confidence if a skill was identified
+    if (analysis.failedSkill) {
+        _degradeSkill(analysis.failedSkill, analysis.rootCause);
+    }
+}
+// ── Helpers ───────────────────────────────────────────────────
+function _writeMinimalLesson(trace) {
+    const text = `[unknown] When the user signals failure (${trace.signal}), review tool outputs carefully before responding. Tools used: ${trace.toolsUsed.join(', ') || 'none'}.`;
+    (0, lessonsBrowser_1.appendLesson)(text);
+    console.log('[failureAnalyzer] minimal lesson written (no LLM analysis)');
+}
+function _degradeSkill(skillName, rootCause) {
+    const cwd = process.cwd();
+    const folders = ['learned', 'approved', 'installed'];
+    for (const folder of folders) {
+        const metaPath = path_1.default.join(cwd, 'workspace', 'skills', folder, skillName, 'meta.json');
+        if (!fs_1.default.existsSync(metaPath))
+            continue;
+        try {
+            const meta = JSON.parse(fs_1.default.readFileSync(metaPath, 'utf-8'));
+            meta.failCount = (meta.failCount ?? 0) + 1;
+            meta.lastFailureReason = rootCause;
+            meta.confidence = Math.max(0.1, (meta.confidence ?? 1.0) - 0.15);
+            // Auto-deprecate after 3 consecutive failures
+            if (meta.failCount >= 3) {
+                meta.deprecated = true;
+                console.warn(`[failureAnalyzer] skill "${skillName}" auto-deprecated after ${meta.failCount} failures`);
+            }
+            fs_1.default.writeFileSync(metaPath, JSON.stringify(meta, null, 2) + '\n', 'utf-8');
+            console.log(`[failureAnalyzer] degraded skill "${skillName}" → confidence ${meta.confidence.toFixed(2)}, failCount ${meta.failCount}`);
+        }
+        catch (e) {
+            console.warn(`[failureAnalyzer] could not update meta for "${skillName}":`, e.message);
+        }
+        break; // only update the first match
+    }
+}

package/dist/core/fastPathExpansion.js

@@ -0,0 +1,82 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchFastPath = matchFastPath;
+// core/fastPathExpansion.ts — Phase 5 of Prompt 10.
+//
+// Classifies messages that can be answered directly by streamChat without
+// going through the planner, cutting 2–8s of planner latency for ~60% of
+// typical user messages.
+//
+// A message is a FAST-PATH candidate when it:
+//   - Is a direct knowledge/conversational question (no tools required)
+//   - Requests explanation, definition, translation, or opinion
+//   - Asks for short creative output (joke, quote, haiku)
+//   - Does NOT contain signals for file I/O, code execution, web search,
+//     git, screen control, or multi-step planning keywords.
+// ── Patterns that indicate a tool-less, plannable-free response ──────────────
+/** Positive patterns: message can likely be answered without any tools. */
+const FAST_PATH_PATTERNS = [
+    // Knowledge / explanation
+    /^(what (is|are|was|were)|who (is|are|was|were)|where (is|are)|when (is|are|did|was)|why (is|are|do|does|did)|how (do|does|did|can|to)\b)/i,
+    // Definition
+    /^(define|explain|describe|tell me (about|what)|what does .+ mean)/i,
+    // Math / conversion
+    /^\d[\d\s+\-*/^().]*=?\s*\??\s*$|^(convert|calculate|what is \d|how (many|much) (is|are|does))/i,
+    // Translation
+    /^(translate|how do you say|what is .+ in (spanish|french|german|japanese|hindi|arabic|chinese|portuguese|italian|russian|korean))/i,
+    // Opinion / recommendation (no research needed)
+    /^(what (should|do) (i|you)|which (is better|do you prefer|would you recommend)|can you recommend)/i,
+    // Short creative
+    /^(tell me a (joke|story|fact|riddle)|give me a (quote|joke|haiku|limerick|fun fact)|write (a|me a) (poem|haiku|limerick|joke|quote|one-liner))/i,
+    // Simple yes/no questions
+    /^(is (it|that|this)|are (you|there|they)|does (it|that)|can (you|i|we)\b)/i,
+    // Casual conversational
+    /^(sounds good|makes sense|that makes sense|i see|understood|got it|noted|alright|sure|of course|no problem|nevermind|never mind|forget it|never mind that)/i,
+];
+/** Negative patterns: if ANY match, the message needs the planner even if a positive matched. */
+const PLANNER_REQUIRED_PATTERNS = [
+    // File operations
+    /\b(read|write|save|create|delete|move|copy|rename|open|close|download|upload)\b.*\b(file|folder|directory|document|pdf|csv|json|txt|xlsx|zip)\b/i,
+    /\.(txt|csv|json|md|pdf|py|js|ts|sh|bat|ps1|xlsx|docx)\b/i,
+    // Code execution
+    /\b(run|execute|build|compile|deploy|install|start|launch|npm|pip|python|node|powershell|bash|terminal|shell|script)\b/i,
+    // Web / research
+    /\b(search|google|find (online|on the web)|browse|fetch|scrape|web|http|url|website|news|latest|current|today's|real.?time)\b/i,
+    // Screen / system control
+    /\b(click|type (in|into)|screenshot|screen|mouse|keyboard|open (app|browser|chrome|window)|close (app|window))\b/i,
+    // Git
+    /\b(git|commit|push|pull|branch|merge|diff|repository|repo)\b/i,
+    // Multi-step planning keywords
+    /\b(then|after that|next|first .+ then|step by step|automate|workflow|pipeline|schedule|every (day|hour|minute)|on a schedule)\b/i,
+    // Email / calendar
+    /\b(send (email|mail|message)|check (email|calendar)|schedule (meeting|call)|remind me)\b/i,
+];
+/**
+ * Returns true if this message can skip the planner and go directly to streamChat.
+ * False means: use the planner (may need tool calls or multi-step execution).
+ */
+function matchFastPath(message) {
+    const trimmed = message.trim();
+    // Very short messages are usually conversational
+    if (trimmed.length < 20 && !/\b(run|exec|create|write|search|find|git)\b/i.test(trimmed)) {
+        return true;
+    }
+    // Any planner-required signal vetoes fast-path
+    if (PLANNER_REQUIRED_PATTERNS.some(p => p.test(trimmed)))
+        return false;
+    // Check positive patterns
+    if (FAST_PATH_PATTERNS.some(p => p.test(trimmed)))
+        return true;
+    // Messages over 300 chars with no positive match go to planner
+    // (likely a detailed task description)
+    if (trimmed.length > 300)
+        return false;
+    // Medium-length messages with question marks are likely knowledge questions
+    if (trimmed.includes('?') && trimmed.length < 200)
+        return true;
+    return false;
+}

package/dist/core/faultEngine.js

@@ -0,0 +1,106 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.faultEngine = void 0;
+// ── Classification rules ───────────────────────────────────────
+const RULES = [
+    {
+        test: m => /timeout|timed out/i.test(m),
+        errorType: 'TIMEOUT',
+        retryable: true,
+        severity: 'medium',
+        repairCommand: 'retry with longer timeoutMs',
+        manualFix: 'Increase timeoutMs in action options or check network latency.',
+    },
+    {
+        test: m => /ECONNREFUSED|ENOTFOUND|network|fetch/i.test(m),
+        errorType: 'NETWORK',
+        retryable: true,
+        severity: 'medium',
+        repairCommand: 'check network connectivity',
+        manualFix: 'Verify the target host is reachable. Check DEVOS_API_URL env var.',
+    },
+    {
+        test: m => /401|403|unauthorized|forbidden|auth/i.test(m),
+        errorType: 'AUTH',
+        retryable: false,
+        severity: 'high',
+        repairCommand: 'refresh credentials',
+        manualFix: 'API key or token may be expired. Refresh in config/api-keys.json.',
+    },
+    {
+        test: m => /404|not found|no such/i.test(m),
+        errorType: 'NOT_FOUND',
+        retryable: false,
+        severity: 'medium',
+        repairCommand: 'verify resource path',
+        manualFix: 'The resource was not found. Check the endpoint or file path.',
+    },
+    {
+        test: m => /permission|access denied|EACCES/i.test(m),
+        errorType: 'PERMISSION',
+        retryable: false,
+        severity: 'high',
+        repairCommand: 'check file/API permissions',
+        manualFix: 'Permission denied. Check file ownership or API scope.',
+    },
+    {
+        test: m => /selector|element|click|visible change|no visible/i.test(m),
+        errorType: 'SCREEN_CHANGE',
+        retryable: true,
+        severity: 'medium',
+        repairCommand: 'retry action with longer wait',
+        manualFix: 'Screen element not found or did not change. The UI may have changed.',
+    },
+    {
+        test: m => /docker|container|vault/i.test(m),
+        errorType: 'DOCKER',
+        retryable: true,
+        severity: 'high',
+        repairCommand: 'docker info && docker ps',
+        manualFix: 'Docker daemon may not be running. Run: docker info',
+    },
+    {
+        test: m => /ollama|llm|model|llava/i.test(m),
+        errorType: 'LLM',
+        retryable: true,
+        severity: 'medium',
+        repairCommand: 'ollama serve',
+        manualFix: 'LLM unavailable. Ensure Ollama is running: ollama serve',
+    },
+];
+// ── FaultEngine class ─────────────────────────────────────────
+class FaultEngine {
+    /**
+     * Classify an error message and return repair strategies.
+     * Context is optional metadata (e.g. actionType, workspacePath).
+     * Can be called with 1 or 2 arguments.
+     */
+    classify(message, context) {
+        const msg = message ?? '';
+        for (const rule of RULES) {
+            if (rule.test(msg)) {
+                return {
+                    errorType: rule.errorType,
+                    message: msg,
+                    retryable: rule.retryable,
+                    severity: rule.severity,
+                    repairCommand: rule.repairCommand,
+                    manualFix: rule.manualFix,
+                };
+            }
+        }
+        return {
+            errorType: 'UNKNOWN',
+            message: msg,
+            retryable: false,
+            severity: 'medium',
+            repairCommand: undefined,
+            manualFix: 'An unexpected error occurred. Check the DevOS logs for details.',
+        };
+    }
+}
+exports.faultEngine = new FaultEngine();

package/dist/core/featureGates.js

@@ -0,0 +1,70 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFeatureLimits = getFeatureLimits;
+exports.canUseFeature = canUseFeature;
+exports.getLimit = getLimit;
+exports.getTierLabel = getTierLabel;
+// core/featureGates.ts — Free vs Pro feature limits
+//
+// All checks are synchronous and read from the local license cache.
+// No network requests are made here — call verifyLicense() at startup
+// to keep the cache fresh.
+const licenseManager_1 = require("./licenseManager");
+// ── Limit tables ──────────────────────────────────────────────
+const FREE_LIMITS = {
+    maxGoals: 5,
+    maxMemories: 50,
+    maxRoutines: 10,
+    maxMachines: 1,
+    nightMode: false, // Dream Engine
+    persistentRules: false, // Standing Orders
+    watchdog: false, // Heartbeat Monitor
+    personaEngine: false, // SOUL customisation
+    exportBackup: false,
+};
+const PRO_LIMITS = {
+    maxGoals: Infinity,
+    maxMemories: Infinity,
+    maxRoutines: Infinity,
+    maxMachines: 2,
+    nightMode: true,
+    persistentRules: true,
+    watchdog: true,
+    personaEngine: true,
+    exportBackup: true,
+};
+// ── Public API ────────────────────────────────────────────────
+/**
+ * Return the full limit table for the current tier.
+ * Reads from the local cache — instant, no I/O on most calls.
+ */
+function getFeatureLimits() {
+    const { isPro } = (0, licenseManager_1.getLicenseStatus)();
+    return isPro ? PRO_LIMITS : FREE_LIMITS;
+}
+/**
+ * Return true if the current tier allows a boolean feature.
+ * @example canUseFeature('nightMode') // false on Free
+ */
+function canUseFeature(feature) {
+    const limits = getFeatureLimits();
+    const val = limits[feature];
+    return typeof val === 'boolean' ? val : val > 0;
+}
+/**
+ * Return the numeric limit for a quota-based feature.
+ * @example getLimit('maxGoals') // 5 on Free, Infinity on Pro
+ */
+function getLimit(feature) {
+    return getFeatureLimits()[feature];
+}
+/**
+ * Return a human-readable tier label.
+ */
+function getTierLabel() {
+    return (0, licenseManager_1.getLicenseStatus)().isPro ? 'Pro' : 'Free';
+}

package/dist/core/fileIngestion.js

@@ -0,0 +1,113 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractPDF = extractPDF;
+exports.extractEPUB = extractEPUB;
+exports.extractText = extractText;
+exports.extractFile = extractFile;
+// core/fileIngestion.ts — Local PDF / EPUB / TXT / MD text extractor
+//
+// All processing is done on the user's machine. No data leaves the device.
+//
+// Dependencies (bundled with DevOS):
+//   pdf-parse  — pure-JS PDF text extraction
+//   epub2      — EPUB chapter extraction
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+// ── PDF extraction ─────────────────────────────────────────
+// Uses pdf-parse (pure JS, no native canvas dependency)
+async function extractPDF(filePath) {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const pdfParse = require('pdf-parse');
+    const buf = fs_1.default.readFileSync(filePath);
+    const fileSizeMB = parseFloat((buf.length / 1024 / 1024).toFixed(2));
+    let result;
+    try {
+        result = await pdfParse(buf, { max: 0 }); // max: 0 = all pages
+    }
+    catch (e) {
+        throw new Error(`PDF parse failed: ${e.message}`);
+    }
+    const text = cleanText(result.text);
+    const wordCount = countWords(text);
+    const pageCount = result.numpages ?? 0;
+    return { text, wordCount, pageCount, format: 'pdf', fileSizeMB };
+}
+// ── EPUB extraction ────────────────────────────────────────
+// Reads all spine chapters and concatenates their text content
+async function extractEPUB(filePath) {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const EPub = require('epub2').EPub;
+    const fileSizeMB = parseFloat((fs_1.default.statSync(filePath).size / 1024 / 1024).toFixed(2));
+    const epub = new EPub(filePath);
+    await new Promise((resolve, reject) => {
+        epub.on('end', resolve);
+        epub.on('error', reject);
+        epub.parse();
+    });
+    const chapterIds = epub.spine.contents.map((c) => c.id);
+    const textParts = [];
+    for (const id of chapterIds) {
+        try {
+            const chapter = await new Promise((resolve, reject) => {
+                epub.getChapter(id, (err, data) => {
+                    if (err)
+                        reject(err);
+                    else
+                        resolve(data || '');
+                });
+            });
+            // Strip HTML tags from chapter HTML
+            const stripped = chapter.replace(/<[^>]+>/g, ' ');
+            textParts.push(stripped);
+        }
+        catch {
+            // skip unreadable chapters
+        }
+    }
+    const text = cleanText(textParts.join('\n'));
+    const wordCount = countWords(text);
+    return { text, wordCount, pageCount: 0, format: 'epub', fileSizeMB };
+}
+// ── Plain-text / Markdown extraction ──────────────────────
+function extractText(filePath, format = 'txt') {
+    const raw = fs_1.default.readFileSync(filePath, 'utf-8');
+    const fileSizeMB = parseFloat((Buffer.byteLength(raw, 'utf-8') / 1024 / 1024).toFixed(2));
+    const text = cleanText(raw);
+    const wordCount = countWords(text);
+    return { text, wordCount, pageCount: 0, format, fileSizeMB };
+}
+// ── Router — pick extractor by extension ──────────────────
+async function extractFile(filePath) {
+    const ext = path_1.default.extname(filePath).toLowerCase();
+    switch (ext) {
+        case '.pdf':
+            return extractPDF(filePath);
+        case '.epub':
+            return extractEPUB(filePath);
+        case '.md':
+        case '.markdown':
+            return extractText(filePath, 'md');
+        case '.txt':
+        default:
+            return extractText(filePath, 'txt');
+    }
+}
+// ── Helpers ────────────────────────────────────────────────
+function cleanText(raw) {
+    return raw
+        .replace(/\r\n/g, '\n')
+        .replace(/\r/g, '\n')
+        .replace(/\n{3,}/g, '\n\n') // collapse >2 blank lines
+        .replace(/[ \t]+/g, ' ') // collapse horizontal whitespace
+        .trim();
+}
+function countWords(text) {
+    return text.split(/\s+/).filter(w => w.length > 0).length;
+}

package/dist/core/gateway.js

@@ -0,0 +1,97 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gateway = void 0;
+// core/gateway.ts — Unified channel router.
+// All inbound messages (dashboard, Telegram, API, future channels)
+// are routed through a single processor so they share the same
+// memory, context, and tool pipeline.
+const sessionRouter_1 = require("./sessionRouter");
+// ── Gateway class ──────────────────────────────────────────────
+class Gateway {
+    constructor() {
+        this.handlers = new Map();
+        this.messageProcessor = null;
+        this.activeChannels = new Set();
+    }
+    // ── Register the central message processor (Aiden's brain) ───
+    setProcessor(handler) {
+        this.messageProcessor = handler;
+    }
+    // ── Register a channel's outbound delivery method ─────────────
+    registerChannel(channel, deliveryHandler) {
+        this.handlers.set(channel, deliveryHandler);
+        this.activeChannels.add(channel);
+        console.log(`[Gateway] Channel registered: ${channel}`);
+    }
+    // ── Unregister a channel ──────────────────────────────────────
+    unregisterChannel(channel) {
+        this.handlers.delete(channel);
+        this.activeChannels.delete(channel);
+        console.log(`[Gateway] Channel unregistered: ${channel}`);
+    }
+    // ── Route an incoming message through Aiden ───────────────────
+    async routeMessage(message) {
+        if (!this.messageProcessor) {
+            throw new Error('No message processor registered');
+        }
+        // Resolve stable cross-channel session and attach sessionId
+        const session = sessionRouter_1.sessionRouter.getSession(message.userId, message.channel);
+        session.messageCount++;
+        message.sessionId = session.sessionId;
+        console.log(`[Gateway] ${message.channel}:${message.channelId} ` +
+            `[${session.sessionId}] → "${message.text.substring(0, 60)}"`);
+        const start = Date.now();
+        try {
+            let response = await this.messageProcessor(message);
+            const duration = Date.now() - start;
+            console.log(`[Gateway] Response ready (${duration}ms) → ${message.channel}`);
+            // Hint on Telegram first message: conversation continues on desktop
+            if (message.channel === 'telegram' && session.messageCount === 1) {
+                response += '\n\n_Tip: Continue this conversation on your desktop dashboard with full context._';
+            }
+            return response;
+        }
+        catch (error) {
+            console.error(`[Gateway] Processing failed:`, error);
+            return 'Something went wrong processing your message. Try again.';
+        }
+    }
+    // ── Deliver a message to a specific channel ───────────────────
+    async deliver(message) {
+        const handler = this.handlers.get(message.channel);
+        if (!handler) {
+            console.log(`[Gateway] No handler for channel: ${message.channel}`);
+            return false;
+        }
+        try {
+            return await handler(message);
+        }
+        catch (error) {
+            console.error(`[Gateway] Delivery failed to ${message.channel}:`, error);
+            return false;
+        }
+    }
+    // ── Broadcast to all active channels ─────────────────────────
+    async broadcast(text, exclude) {
+        for (const channel of this.activeChannels) {
+            if (channel === exclude)
+                continue;
+            await this.deliver({ channel, channelId: 'broadcast', text });
+        }
+    }
+    // ── Channel status list ────────────────────────────────────────
+    getStatus() {
+        const allChannels = [
+            'dashboard', 'telegram', 'discord', 'slack', 'whatsapp', 'signal', 'sms', 'imessage', 'email', 'api',
+        ];
+        return allChannels.map(ch => ({
+            channel: ch,
+            active: this.activeChannels.has(ch),
+        }));
+    }
+}
+exports.gateway = new Gateway();