aiden-runtime 4.0.2 → 4.1.0

package/dist/core/channels/manager.js

@@ -5,15 +5,31 @@
 // ============================================================
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.channelManager = exports.ChannelManager = void 0;
-// ── ChannelManager ─────────────────────────────────────────
+const logger_1 = require("../v4/logger");
 class ChannelManager {
-    constructor() {
+    constructor(opts = {}) {
         this.adapters = new Map();
         this.lastActivity = new Map();
+        this.log = opts.logger ?? (0, logger_1.noopLogger)();
     }
-    /** Register an adapter — must be called before startAll() */
+    /**
+     * Phase v4.1-1.3a — late-binding logger setter. Lets the singleton
+     * pick up a real logger after construction (api/server.ts boot path
+     * imports the singleton; we can't change its constructor without
+     * breaking every existing import site).
+     */
+    attachLogger(logger) {
+        this.log = logger;
+    }
+    /** Register an adapter — must be called before startAll(). */
     register(adapter) {
         this.adapters.set(adapter.name, adapter);
+        // Phase v4.1-1.3a — hand the adapter a scoped child logger so its
+        // own diagnostics route through the same sink chain as the manager.
+        // Adapters that haven't been migrated yet skip silently (no method).
+        if (typeof adapter.attachLogger === 'function') {
+            adapter.attachLogger(this.log.child(adapter.name));
+        }
     }
     /**
      * Start all registered adapters.
@@ -29,11 +45,13 @@ class ChannelManager {
                 results.push({ name, status });
             }
             catch (error) {
-                console.error(`[ChannelManager] ${name} failed to start:`, error.message);
+                this.log.error(`${name} failed to start: ${error.message}`);
                 results.push({ name, status: 'failed', error: String(error.message) });
             }
         }
-        // Summary line
+        // Summary line — single info record so log files capture the
+        // boot snapshot. CLI mode: routes to file only (REPL stays clean).
+        // Serve mode: routes to NDJSON stdout for log aggregators.
         const summary = results
             .map(r => {
             if (r.status === 'started')
@@ -44,7 +62,7 @@ class ChannelManager {
         })
             .join(' | ');
         if (results.length > 0)
-            console.log(`[Channels] ${summary}`);
+            this.log.info(`startup: ${summary}`);
         return results;
     }
     /** Gracefully stop all adapters — called on SIGTERM / shutdown */
@@ -54,7 +72,7 @@ class ChannelManager {
                 await adapter.stop();
             }
             catch (e) {
-                console.error(`[ChannelManager] Error stopping ${adapter.name}:`, e.message);
+                this.log.error(`Error stopping ${adapter.name}: ${e.message}`);
             }
         }
     }

package/dist/core/channels/pdf-extract.js

@@ -0,0 +1,180 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HARD_CHAR_CAP = exports.MAX_PDF_BYTES = void 0;
+exports.extractPdfForChannel = extractPdfForChannel;
+// core/channels/pdf-extract.ts — Phase v4.1-4.
+//
+// Channel-side adapter for inbound PDFs. Wraps the existing
+// `core/fileIngestion.ts` `extractPDF` function with the policies
+// the Telegram adapter cares about:
+//
+//   1. 20 MB pre-download size cap matching Telegram's documented
+//      Bot API getFile attachment limit. Refusing here keeps the
+//      polling loop from spending bandwidth on a payload Telegram
+//      would refuse to deliver anyway.
+//   2. Token-budget truncation. The agent loop has to fit the PDF
+//      content INSIDE the user turn alongside system prompts, prior
+//      history, and a reserve for the response. We cap injected text
+//      at the lesser of:
+//        - 50,000 characters (hard ceiling — keeps pathological
+//          200-page PDFs from blowing the budget on small models)
+//        - (modelContextWindow - 8K reserved-for-response) * 4
+//          chars/token (rough OpenAI heuristic, errs on the safe side)
+//      and report `{ truncated: true, originalChars }` so the channel
+//      adapter can append a "PDF truncated to fit context, original
+//      was N chars" note inside the agent annotation.
+//   3. Result-shape contract that maps onto the bracketed user-turn
+//      annotation the adapter emits. Failures return `success:false`
+//      with a human-readable `error` so the agent gets a directive
+//      ("[transcription failed: …. Apologize and ask them to send a
+//      shorter file.]") instead of an empty message.
+//
+// Logger comes from the v4.1-1.3a contract; defaults to a noop sink.
+const node_fs_1 = require("node:fs");
+const fileIngestion_1 = require("../fileIngestion");
+const logger_1 = require("../v4/logger");
+// 20 MiB. Telegram's documented Bot API attachment download limit.
+// Anything bigger would have been refused by getFile upstream, so
+// we reject here without spending bandwidth on the round-trip.
+exports.MAX_PDF_BYTES = 20 * 1024 * 1024;
+/** Hard ceiling on injected PDF text — protects small-context models. */
+exports.HARD_CHAR_CAP = 50000;
+/** Reserved tokens for the agent's response when computing context budget. */
+const RESPONSE_RESERVED_TOKENS = 8000;
+/** Conservative chars-per-token estimate for budget math. */
+const CHARS_PER_TOKEN = 4;
+/**
+ * Extract a PDF and return text bounded by the channel-layer's
+ * truncation policy. Never throws — failures land on
+ * `success: false` with a human-readable `error`.
+ */
+async function extractPdfForChannel(opts) {
+    const log = opts.logger ?? (0, logger_1.noopLogger)();
+    const cap = opts.maxBytesOverride ?? exports.MAX_PDF_BYTES;
+    // ── 1. Size precheck ────────────────────────────────────────────
+    let sizeBytes;
+    try {
+        const st = await node_fs_1.promises.stat(opts.filePath);
+        sizeBytes = st.size;
+    }
+    catch (e) {
+        log.warn('pdf file not readable', { path: opts.filePath, error: e?.message });
+        return { success: false, truncated: false, error: `pdf file not readable: ${e?.message ?? 'unknown error'}` };
+    }
+    if (sizeBytes > cap) {
+        log.warn('pdf file too large', { sizeBytes, cap });
+        return {
+            success: false,
+            truncated: false,
+            error: `PDF too large: ${(sizeBytes / (1024 * 1024)).toFixed(1)} MB ` +
+                `(cap is ${(cap / (1024 * 1024)).toFixed(0)} MB).`,
+        };
+    }
+    // ── 2. Hand off to the local extractor ──────────────────────────
+    const extractor = opts.extractFn ?? fileIngestion_1.extractPDF;
+    let extracted;
+    try {
+        extracted = await extractor(opts.filePath);
+    }
+    catch (e) {
+        log.error('pdf extraction threw', { error: e?.message ?? String(e) });
+        return {
+            success: false,
+            truncated: false,
+            error: `pdf extraction failed: ${e?.message ?? 'unknown error'}`,
+        };
+    }
+    const fullText = (extracted.text ?? '').trim();
+    if (!fullText) {
+        log.warn('pdf extracted empty text', { pageCount: extracted.pageCount });
+        return {
+            success: false,
+            truncated: false,
+            pageCount: extracted.pageCount,
+            error: 'pdf extraction returned empty text (scanned image PDF?)',
+        };
+    }
+    // ── 3. Truncation budget ────────────────────────────────────────
+    const charBudget = computeCharBudget(opts.modelContextWindow);
+    const originalChars = fullText.length;
+    if (originalChars <= charBudget) {
+        log.info('pdf extracted', {
+            pageCount: extracted.pageCount,
+            chars: originalChars,
+            truncated: false,
+        });
+        return {
+            success: true,
+            text: fullText,
+            truncated: false,
+            originalChars,
+            pageCount: extracted.pageCount,
+            wordCount: extracted.wordCount,
+        };
+    }
+    // Truncate to the budget — slice on a sentence/paragraph boundary
+    // when one's available within the last 1 KB of the budget so we
+    // don't mid-word the agent's view of the text.
+    const truncatedText = truncateOnBoundary(fullText, charBudget);
+    log.info('pdf extracted (truncated)', {
+        pageCount: extracted.pageCount,
+        originalChars,
+        finalChars: truncatedText.length,
+        budget: charBudget,
+    });
+    return {
+        success: true,
+        text: truncatedText,
+        truncated: true,
+        originalChars,
+        pageCount: extracted.pageCount,
+        wordCount: countWords(truncatedText),
+    };
+}
+/**
+ * Compute the truncation budget. When `modelContextWindow` is given,
+ * subtract 8K reserved-for-response tokens, multiply by 4 chars/token,
+ * and cap at the hard 50K ceiling. When not given, fall back to the
+ * hard ceiling. Always returns at least 4 KB so a tiny-context model
+ * doesn't end up with nothing.
+ */
+function computeCharBudget(modelContextWindow) {
+    if (typeof modelContextWindow !== 'number' || !Number.isFinite(modelContextWindow) || modelContextWindow <= 0) {
+        return exports.HARD_CHAR_CAP;
+    }
+    const usableTokens = Math.max(0, modelContextWindow - RESPONSE_RESERVED_TOKENS);
+    const usableChars = usableTokens * CHARS_PER_TOKEN;
+    const budget = Math.min(exports.HARD_CHAR_CAP, usableChars);
+    return Math.max(budget, 4000);
+}
+/**
+ * Slice `text` at `cap` characters but try to land on the last newline
+ * in the trailing 1 KB of the cap, falling back to the last sentence
+ * terminator, finally a hard cut.
+ */
+function truncateOnBoundary(text, cap) {
+    if (text.length <= cap)
+        return text;
+    const window = text.slice(0, cap);
+    const tailStart = Math.max(0, cap - 1024);
+    const lastNewline = window.lastIndexOf('\n', cap);
+    if (lastNewline >= tailStart)
+        return window.slice(0, lastNewline);
+    // Match common sentence terminators; English-centric but Devanagari
+    // and Latin punctuation both work since `.` is in the regex.
+    const terminator = window.slice(tailStart).search(/[.!?।]\s/);
+    if (terminator >= 0) {
+        const cutAt = tailStart + terminator + 1;
+        return window.slice(0, cutAt);
+    }
+    return window;
+}
+function countWords(text) {
+    if (!text)
+        return 0;
+    return text.trim().split(/\s+/).filter(Boolean).length;
+}

package/dist/core/channels/photo-vision.js

@@ -0,0 +1,157 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_PHOTO_BYTES = void 0;
+exports.analyzePhotoForChannel = analyzePhotoForChannel;
+// core/channels/photo-vision.ts — Phase v4.1-4.
+//
+// Channel-side adapter for inbound photos. Wraps the existing
+// `core/visionAnalyze.ts` chain with Telegram-specific concerns:
+//
+//   1. 25 MB pre-download size cap. Mirrors the voice path's policy
+//      (Telegram Bot API getFile limit is the binding constraint).
+//      Refusing here saves the round-trip when we already know the
+//      payload is too big for the providers.
+//   2. Mode decision — `native` vs `text` — based on whether the
+//      currently active model carries a `supportsVision: true` flag in
+//      `providers/v4/modelCatalog.ts`. When vision is supported, the
+//      channel adapter attaches the file path on the user turn so the
+//      provider sees pixels directly. Otherwise we pre-analyze with
+//      the auxiliary `analyzeImage` chain (Anthropic / OpenAI / Ollama
+//      llava) and prepend a description annotation — same "smuggle
+//      into agent turn" pattern as voice transcripts.
+//   3. Result-shape contract that matches the channel adapter's
+//      expectations so the Telegram adapter's `handlePhotoMessage`
+//      can branch on `mode` and assemble the right outbound payload.
+//
+// Logger comes from the v4.1-1.3a contract; defaults to a noop sink
+// so anything that calls into this module without a wired logger
+// stays REPL-clean.
+const node_fs_1 = require("node:fs");
+const modelCatalog_1 = require("../../providers/v4/modelCatalog");
+const visionAnalyze_1 = require("../visionAnalyze");
+const logger_1 = require("../v4/logger");
+// 25 MiB. Matches the voice cap and the OpenAI / Anthropic vision
+// request-size envelopes; Telegram's getFile cap is 20 MB so a 25 MB
+// payload would already have been rejected upstream — but keeping
+// these caps consistent simplifies the operator mental model.
+exports.MAX_PHOTO_BYTES = 25 * 1024 * 1024;
+/**
+ * Default text-mode prompt. Single source so smokes and the adapter
+ * agree on what gets sent to the auxiliary vision chain. Phrased
+ * for the agent's perspective — the description ends up bracketed
+ * inside an "[The user sent an image. Description: ...]" annotation.
+ */
+const DEFAULT_DESCRIBE_PROMPT = 'Describe everything visible in this image in detail. Include any ' +
+    'text, code, layout, objects, people, colors, and any other notable ' +
+    'visual information.';
+/**
+ * Decide how an inbound photo should be presented to the model and
+ * (in text mode) generate the description the channel adapter will
+ * smuggle into the agent's user turn.
+ *
+ * Never throws — failures land on `success: false` with a
+ * human-readable `error`. Callers downstream decide whether to:
+ *   - hand a `[The user sent an image but description failed: ...]`
+ *     directive to the agent, or
+ *   - render a friendly user-facing reject reply.
+ */
+async function analyzePhotoForChannel(opts) {
+    const log = opts.logger ?? (0, logger_1.noopLogger)();
+    const cap = opts.maxBytesOverride ?? exports.MAX_PHOTO_BYTES;
+    // ── 1. Size precheck ────────────────────────────────────────────
+    let sizeBytes;
+    try {
+        const st = await node_fs_1.promises.stat(opts.filePath);
+        sizeBytes = st.size;
+    }
+    catch (e) {
+        log.warn('photo file not readable', { path: opts.filePath, error: e?.message });
+        return { success: false, mode: 'text', error: `photo file not readable: ${e?.message ?? 'unknown error'}` };
+    }
+    if (sizeBytes > cap) {
+        log.warn('photo file too large', { sizeBytes, cap });
+        return {
+            success: false,
+            mode: 'text',
+            error: `Photo too large: ${(sizeBytes / (1024 * 1024)).toFixed(1)} MB ` +
+                `(cap is ${(cap / (1024 * 1024)).toFixed(0)} MB).`,
+        };
+    }
+    // ── 2. Mode decision ────────────────────────────────────────────
+    const mode = decideMode(opts.providerId, opts.modelId, log);
+    if (mode === 'native') {
+        log.info('photo routed native', {
+            providerId: opts.providerId,
+            modelId: opts.modelId,
+            sizeBytes,
+        });
+        return { success: true, mode: 'native', nativePath: opts.filePath };
+    }
+    // ── 3. Text mode: pre-analyze via the auxiliary vision chain ────
+    const analyze = opts.analyzeFn ?? visionAnalyze_1.analyzeImage;
+    try {
+        const visionResult = await analyze(opts.filePath, opts.prompt ?? DEFAULT_DESCRIBE_PROMPT, log);
+        const description = (visionResult.description ?? '').trim();
+        if (!description) {
+            log.warn('vision chain returned empty description', { provider: visionResult.provider });
+            return {
+                success: false,
+                mode: 'text',
+                error: 'vision chain returned an empty description',
+                provider: visionResult.provider,
+                modelUsed: visionResult.modelUsed,
+                durationMs: visionResult.durationMs,
+            };
+        }
+        return {
+            success: true,
+            mode: 'text',
+            description,
+            provider: visionResult.provider,
+            modelUsed: visionResult.modelUsed,
+            durationMs: visionResult.durationMs,
+        };
+    }
+    catch (e) {
+        log.error('vision chain threw', { error: e?.message ?? String(e) });
+        return {
+            success: false,
+            mode: 'text',
+            error: `vision chain failed: ${e?.message ?? 'unknown error'}`,
+        };
+    }
+}
+/**
+ * Resolve native-vs-text routing for the active model. Returns
+ * `'text'` whenever:
+ *   - either id is missing (caller didn't tell us)
+ *   - the model isn't in `MODEL_CATALOG` (registry drift)
+ *   - the model's `supportsVision` is false
+ *   - the lookup throws for any reason
+ *
+ * `'text'` is the safe fallback — it always works because the
+ * auxiliary `analyzeImage` chain runs against its own provider keys
+ * independent of whatever the user has selected for the agent loop.
+ */
+function decideMode(providerId, modelId, log) {
+    if (!providerId || !modelId) {
+        log.debug('photo mode: missing provider/model id, defaulting to text');
+        return 'text';
+    }
+    try {
+        const entry = (0, modelCatalog_1.findModel)(providerId, modelId);
+        if (!entry) {
+            log.debug('photo mode: model not in catalog, defaulting to text', { providerId, modelId });
+            return 'text';
+        }
+        return entry.supportsVision ? 'native' : 'text';
+    }
+    catch (e) {
+        log.debug('photo mode: lookup threw, defaulting to text', { error: e?.message });
+        return 'text';
+    }
+}

package/dist/core/channels/signal.js

@@ -25,9 +25,12 @@ exports.SignalAdapter = void 0;
 //   SIGNAL_ALLOWED_NUMBERS  — optional comma-separated allowlist
 const axios_1 = __importDefault(require("axios"));
 const gateway_1 = require("../gateway");
+const logger_1 = require("../v4/logger");
 class SignalAdapter {
     constructor() {
         this.name = 'signal';
+        // Phase v4.1-1.3a — diagnostics route through scope logger.
+        this.log = (0, logger_1.noopLogger)();
         this.healthy = false;
         this.pollTimer = null;
         this.lastReceived = 0;
@@ -36,21 +39,22 @@ class SignalAdapter {
         const raw = process.env.SIGNAL_ALLOWED_NUMBERS ?? '';
         this.allowedNumbers = raw ? new Set(raw.split(',').map(s => s.trim()).filter(Boolean)) : new Set();
     }
+    attachLogger(logger) { this.log = logger; }
     // ── Lifecycle ──────────────────────────────────────────────
     async start() {
         if (!this.myNumber) {
-            console.log('[Signal] Disabled — set SIGNAL_PHONE_NUMBER to enable');
+            this.log.info('Disabled — set SIGNAL_PHONE_NUMBER to enable');
             return;
         }
         // Verify signal-cli is reachable
         const reachable = await this.checkHealth();
         if (!reachable) {
-            console.log(`[Signal] Disabled — signal-cli-rest-api not reachable at ${this.baseUrl}`);
+            this.log.info('Disabled — signal-cli-rest-api not reachable at ${this.baseUrl}');
             return;
         }
         this.healthy = true;
         this.lastReceived = Date.now();
-        console.log(`[Signal] Connected — polling ${this.baseUrl}`);
+        this.log.info('Connected — polling ${this.baseUrl}');
         // Register outbound delivery
         gateway_1.gateway.registerChannel('signal', async (msg) => {
             await this.send(msg.channelId, msg.text);
@@ -66,7 +70,7 @@ class SignalAdapter {
             this.pollTimer = null;
         }
         gateway_1.gateway.unregisterChannel('signal');
-        console.log('[Signal] Disconnected');
+        this.log.info('Disconnected');
     }
     async send(target, message) {
         if (!this.healthy)
@@ -75,7 +79,7 @@ class SignalAdapter {
             await axios_1.default.post(`${this.baseUrl}/v2/send`, { message, number: this.myNumber, recipients: [target] }, { timeout: 10000 });
         }
         catch (e) {
-            console.error('[Signal] send error:', e.message);
+            this.log.error(`send error:${e.message}`);
         }
     }
     isHealthy() { return this.healthy; }
@@ -112,7 +116,7 @@ class SignalAdapter {
         catch (e) {
             // Don't spam logs on transient poll errors
             if (this.healthy) {
-                console.error('[Signal] poll error:', e.message);
+                this.log.error(`poll error:${e.message}`);
             }
         }
     }
@@ -132,7 +136,7 @@ class SignalAdapter {
             });
         }
         catch (e) {
-            console.error('[Signal] routeMessage error:', e.message);
+            this.log.error(`routeMessage error:${e.message}`);
             return '❌ Something went wrong. Try again.';
         }
     }

package/dist/core/channels/slack.js

@@ -27,11 +27,13 @@ exports.SlackAdapter = void 0;
 //   - Graceful degradation: missing creds → disabled, no crash
 const bolt_1 = require("@slack/bolt");
 const gateway_1 = require("../gateway");
+const logger_1 = require("../v4/logger");
 class SlackAdapter {
     constructor() {
         this.name = 'slack';
         this.app = null;
         this.healthy = false;
+        this.log = (0, logger_1.noopLogger)(); // Phase v4.1-1.3a — wired by ChannelManager.register
         this.botToken = process.env.SLACK_BOT_TOKEN ?? '';
         this.signingSecret = process.env.SLACK_SIGNING_SECRET ?? '';
         this.appToken = process.env.SLACK_APP_TOKEN ?? '';
@@ -40,10 +42,11 @@ class SlackAdapter {
             ? new Set(rawChannels.split(',').map(s => s.trim()).filter(Boolean))
             : new Set();
     }
+    attachLogger(logger) { this.log = logger; }
     // ── Lifecycle ──────────────────────────────────────────────
     async start() {
         if (!this.botToken || !this.signingSecret) {
-            console.log('[Slack] Disabled — set SLACK_BOT_TOKEN and SLACK_SIGNING_SECRET to enable');
+            this.log.info('Disabled — set SLACK_BOT_TOKEN and SLACK_SIGNING_SECRET to enable');
             return;
         }
         const useSocketMode = !!this.appToken;
@@ -63,7 +66,7 @@ class SlackAdapter {
             if (this.allowedChannels.size > 0 && !this.allowedChannels.has(msg.channel))
                 return;
             const response = await this.processMessage(msg.channel, msg.user ?? 'unknown', msg.text ?? '');
-            await say({ text: response, thread_ts: msg.ts }).catch((e) => console.error('[Slack] say error:', e.message));
+            await say({ text: response, thread_ts: msg.ts }).catch((e) => this.log.error(`say error: ${e.message}`));
         });
         // ── App mentions (@Aiden) ────────────────────────────────
         this.app.event('app_mention', async ({ event, say }) => {
@@ -72,7 +75,7 @@ class SlackAdapter {
             // Strip the @mention prefix from the message
             const text = (event.text ?? '').replace(/<@[^>]+>/g, '').trim();
             const response = await this.processMessage(event.channel, event.user, text);
-            await say({ text: response, thread_ts: event.ts }).catch((e) => console.error('[Slack] mention reply error:', e.message));
+            await say({ text: response, thread_ts: event.ts }).catch((e) => this.log.error(`mention reply error: ${e.message}`));
         });
         // ── Slash command /aiden ─────────────────────────────────
         this.app.command('/aiden', async ({ command, ack, say }) => {
@@ -82,7 +85,7 @@ class SlackAdapter {
                 return;
             }
             const response = await this.processMessage(command.channel_id, command.user_id, command.text);
-            await say(response).catch((e) => console.error('[Slack] slash reply error:', e.message));
+            await say(response).catch((e) => this.log.error(`slash reply error: ${e.message}`));
         });
         // Register outbound delivery so gateway.deliver() and broadcast() work
         gateway_1.gateway.registerChannel('slack', async (msg) => {
@@ -91,7 +94,7 @@ class SlackAdapter {
                 return true;
             }
             catch (e) {
-                console.error('[Slack] Delivery error:', e.message);
+                this.log.error(`Delivery error: ${e.message}`);
                 return false;
             }
         });
@@ -99,10 +102,10 @@ class SlackAdapter {
         try {
             await this.app.start(port);
             this.healthy = true;
-            console.log(`[Slack] Connected (${useSocketMode ? 'socket mode' : `HTTP mode port ${port}`})`);
+            this.log.info(`Connected (${useSocketMode ? 'socket mode' : `HTTP mode port ${port}`})`);
         }
         catch (e) {
-            console.error('[Slack] Start failed:', e.message);
+            this.log.error(`Start failed: ${e.message}`);
             this.healthy = false;
         }
     }
@@ -113,10 +116,10 @@ class SlackAdapter {
             await this.app.stop().catch(() => { });
             this.app = null;
         }
-        console.log('[Slack] Disconnected');
+        this.log.info('Disconnected');
     }
     async send(channelId, message) {
-        await this.app?.client.chat.postMessage({ channel: channelId, text: message }).catch((e) => console.error('[Slack] send error:', e.message));
+        await this.app?.client.chat.postMessage({ channel: channelId, text: message }).catch((e) => this.log.error(`send error: ${e.message}`));
     }
     isHealthy() { return this.healthy; }
     // ── Helpers ────────────────────────────────────────────────
@@ -131,7 +134,7 @@ class SlackAdapter {
             });
         }
         catch (e) {
-            console.error('[Slack] routeMessage error:', e.message);
+            this.log.error(`routeMessage error: ${e.message}`);
             return '❌ Something went wrong. Try again.';
         }
     }