aiden-runtime 4.0.2 → 4.1.0

package/dist/cli/v4/uiBuild.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIDEN_PRESHIP_BUILD = exports.AIDEN_CROSS_PLATFORM_BUILD = exports.AIDEN_REPLY_FORMAT_BUILD = exports.AIDEN_SKILL_MINING_BUILD = exports.AIDEN_UI_BUILD = void 0;
+exports.citationsEnabled = citationsEnabled;
+exports.isMcpServeMode = isMcpServeMode;
+exports.isNoUiMode = isNoUiMode;
+exports.uiIconsEnabled = uiIconsEnabled;
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod). Licensed under AGPL-3.0.
+ *
+ * cli/v4/uiBuild.ts — Aiden v4.1 Tier-3 UI build fingerprint.
+ *
+ * A single source-of-truth string the smokes can `require()` from
+ * the built artifact. Bumped by hand at the start of each tier-3
+ * sub-phase so smoke harnesses can pin against the expected build.
+ */
+exports.AIDEN_UI_BUILD = 'v4.1-tier3-essentials';
+/**
+ * Phase v4.1-skill-mining: build fingerprint for the auto-extract
+ * subsystem. Bumped per skill-mining sub-phase so smokes can pin
+ * against the expected build.
+ */
+exports.AIDEN_SKILL_MINING_BUILD = 'v4.1-skill-mining';
+/**
+ * Phase v4.1-reply-formatting: build fingerprint for the structured
+ * markdown rendering / citation footer / streaming stable-prefix
+ * subsystem. Render-layer only — no agent prompts or behavior change.
+ */
+exports.AIDEN_REPLY_FORMAT_BUILD = 'v4.1-reply-formatting';
+/**
+ * Phase v4.1-cross-platform: build fingerprint for the Linux / macOS
+ * compatibility pass — path helpers, audio backend detection, skill
+ * loader case-insensitive lookup, doctor checks per OS, CI matrix.
+ */
+exports.AIDEN_CROSS_PLATFORM_BUILD = 'v4.1-cross-platform';
+/**
+ * Phase v4.1-preship-cleanup: build fingerprint for the day-one
+ * polish batch — vitest baseline goes from 37 fails to 0, telegram
+ * 409 path gains a local-machine polling lock to prevent same-box
+ * rivals from racing.
+ */
+exports.AIDEN_PRESHIP_BUILD = 'v4.1-preship-cleanup';
+/** Predicate: is the citation footer enabled? Default off. */
+function citationsEnabled() {
+    return process.env.AIDEN_CITATIONS === '1';
+}
+/**
+ * Predicate: are we running in MCP serve mode? When true, the
+ * stdout channel belongs to JSON-RPC and any UI write would corrupt
+ * the wire. Tier-3 UI helpers consult this before printing.
+ *
+ * The MCP server CLI (cli/v4/commands/mcp.ts) sets
+ * `process.env.AIDEN_MCP_SERVE = '1'` early in its boot path; that
+ * env-var check is intentionally cheap and safe to read often.
+ */
+function isMcpServeMode() {
+    return process.env.AIDEN_MCP_SERVE === '1';
+}
+/**
+ * Predicate: is the legacy/no-UI flag in effect? Disables tier-3
+ * polish (autosuggest ghost text, inline status line, etc.) and
+ * falls back to pre-tier3.1 rendering. Set by `aiden --no-ui`.
+ */
+function isNoUiMode() {
+    return process.env.AIDEN_NO_UI === '1';
+}
+/**
+ * Predicate: should slash-command icons render? Default OFF; opt-in
+ * via `AIDEN_UI_ICONS=1`. Lets users with emoji-friendly terminals
+ * recover the previous icon column.
+ */
+function uiIconsEnabled() {
+    return process.env.AIDEN_UI_ICONS === '1';
+}

package/dist/cli/v4/voiceCli.js

@@ -0,0 +1,113 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/voiceCli.ts — Phase v4.1-voice-cli
+ *
+ * `aiden voice <action>` top-level CLI subcommand. Three actions:
+ *
+ *   doctor          — print diagnostics: build, TTY, mic backend,
+ *                     TTS providers, current config. No mic open.
+ *   tts <text>      — synthesise + play one short clip. Real
+ *                     provider call.
+ *   transcribe <f>  — STT one audio file. Reuses the v4.1-3
+ *                     `whisper-transcribe` channel pipeline.
+ *
+ * Distinct from the `/voice` slash command (which mutates session
+ * state from inside the REPL). This subcommand exists so users can
+ * verify mic + speaker setup BEFORE entering the REPL — useful for
+ * first-run mic-permission grants on Windows where the OS prompts
+ * the first time the device is opened.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIDEN_VOICE_CLI_BUILD = void 0;
+exports.runVoiceSubcommand = runVoiceSubcommand;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const node_fs_1 = require("node:fs");
+const diagnostics_1 = require("../../core/v4/voice/diagnostics");
+Object.defineProperty(exports, "AIDEN_VOICE_CLI_BUILD", { enumerable: true, get: function () { return diagnostics_1.AIDEN_VOICE_CLI_BUILD; } });
+const tts_1 = require("../../core/voice/tts");
+const whisper_transcribe_1 = require("../../core/channels/whisper-transcribe");
+async function runVoiceSubcommand(action, args, opts = {}) {
+    const writeOut = opts.writeOut ?? ((t) => process.stdout.write(t));
+    const writeErr = opts.writeErr ?? ((t) => process.stderr.write(t));
+    switch (action) {
+        case 'doctor': {
+            const diag = await (0, diagnostics_1.collectVoiceDiagnostics)();
+            writeOut(`Aiden voice — ${diagnostics_1.AIDEN_VOICE_CLI_BUILD}\n`);
+            writeOut(`  tty:            ${diag.isTty ? 'yes' : 'no'}\n`);
+            writeOut(`  enabled:        ${diag.enabled ? 'yes' : 'no (refused — non-TTY stdin)'}\n`);
+            writeOut(`  mic backend:    ${diag.audio.backend}\n`);
+            writeOut(`  mic active:     ${diag.audio.active ? 'yes' : 'no'}\n`);
+            writeOut(`  sox on PATH:    ${diag.audio.soxOnPath ? 'yes' : 'no'}\n`);
+            writeOut(`  mode:           ${diag.config.mode}\n`);
+            writeOut(`  tts voice:      ${diag.config.ttsVoice}\n`);
+            writeOut(`  beeps:          ${diag.config.beepsEnabled ? 'on' : 'off'}\n`);
+            writeOut(`  tts providers:\n`);
+            for (const p of diag.ttsProviders) {
+                const tag = p.available ? '✓' : '✗';
+                writeOut(`    ${tag} ${p.name.padEnd(12)} ${p.note ?? ''}\n`);
+            }
+            // Mic-backend hint when nothing is installed.
+            if (diag.audio.backend === 'unavailable') {
+                writeOut(`\n  Hint: install \`decibri\` (npm i decibri) for prebuilt mic capture,\n`);
+                writeOut(`        OR install sox (https://sox.sourceforge.io/) + node-record-lpcm16.\n`);
+            }
+            return 0;
+        }
+        case 'tts': {
+            const text = args.join(' ').trim();
+            if (!text) {
+                writeErr(`Usage: aiden voice tts "<text>"\n`);
+                return 1;
+            }
+            const cleaned = (0, tts_1.cleanForTTS)(text);
+            if (!cleaned) {
+                writeErr(`Empty after cleanForTTS — nothing to speak.\n`);
+                return 1;
+            }
+            writeOut(`Synthesising via TTS chain (${cleaned.length} chars)...\n`);
+            const r = await (0, tts_1.synthesize)({ text: cleaned });
+            if (r.error) {
+                writeErr(`TTS failed: ${r.error}\n`);
+                return 1;
+            }
+            writeOut(`TTS ok — provider: ${r.provider}, ${r.durationMs}ms\n`);
+            return 0;
+        }
+        case 'transcribe': {
+            const filePath = args[0];
+            if (!filePath) {
+                writeErr(`Usage: aiden voice transcribe <audio-file>\n`);
+                return 1;
+            }
+            try {
+                await node_fs_1.promises.access(filePath);
+            }
+            catch {
+                writeErr(`File not found: ${filePath}\n`);
+                return 1;
+            }
+            writeOut(`Transcribing ${filePath}...\n`);
+            const r = await (0, whisper_transcribe_1.transcribeForChannel)({ filePath });
+            if (!r.success) {
+                writeErr(`Transcribe failed: ${r.error ?? 'unknown'}\n`);
+                return 1;
+            }
+            const conf = typeof r.avgLogprob === 'number'
+                ? ` (avgLogprob=${r.avgLogprob.toFixed(2)})`
+                : '';
+            writeOut(`Transcript${conf}:\n${r.text ?? ''}\n`);
+            return 0;
+        }
+        default: {
+            writeErr(`Unknown 'aiden voice' action: ${action}\n`);
+            writeErr(`Actions: doctor | tts <text> | transcribe <file>\n`);
+            return 1;
+        }
+    }
+}

package/dist/cli/v4/voicePromptApi.js

@@ -0,0 +1,196 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/voicePromptApi.ts — Phase v4.1-voice-cli
+ *
+ * Wraps a default `ChatPromptApi` implementation with a raw-mode
+ * spacebar toggle for push-to-talk recording. When the user is at
+ * the prompt and presses Space:
+ *
+ *   1. Switch to raw mode + start `cliVoice.startRecording()`
+ *   2. Update the spinner: "🎤 recording (Space to stop, Esc to cancel)"
+ *   3. On second Space: stop and transcribe → return transcript
+ *   4. On Esc: cancel and return empty (caller falls back to text)
+ *   5. On any other character before the first Space: hand control
+ *      back to the wrapped `inquirer` prompt so the user types
+ *      normally
+ *
+ * Hard-refuses activation when `process.stdin.isTTY` is false. This
+ * is the MCP-stdio invariant — `aiden mcp serve` uses stdin as the
+ * JSON-RPC transport, and toggling raw mode there would corrupt
+ * every protocol frame. The refusal is silent in MCP context (the
+ * default `readLine` runs unchanged); explicit in REPL context (a
+ * stderr warning + fall-through).
+ *
+ * `selectSlashCommand` is delegated unchanged — slash commands
+ * still go through the inquirer dropdown.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVoicePromptApi = createVoicePromptApi;
+exports.voiceModeAllowed = voiceModeAllowed;
+const factory_1 = require("../../core/v4/logger/factory");
+const KEY_SPACE = 0x20;
+const KEY_ESC = 0x1b;
+/** Build a prompt API that intercepts Space for push-to-talk and
+ *  falls through to `inner` for normal text input. */
+function createVoicePromptApi(opts) {
+    const logger = (opts.logger ?? (0, factory_1.noopLogger)()).child('voice-prompt');
+    const stdin = opts.stdin ?? process.stdin;
+    const stdout = opts.stdout ?? process.stdout;
+    return {
+        async readLine(prompt) {
+            // Hard refuse when stdin isn't a TTY. Voice mode requires raw
+            // mode; raw mode requires a TTY. MCP stdio mode hits this path
+            // when Claude Desktop spawns aiden — silently fall through.
+            if (!stdin.isTTY) {
+                return opts.inner.readLine(prompt);
+            }
+            const transcript = await waitForSpaceOrTypedInput({
+                prompt,
+                stdin,
+                stdout,
+                voice: opts.voice,
+                onStatus: opts.onStatus,
+                logger,
+            });
+            if (transcript === null) {
+                // User typed text — hand off to the regular prompt API. The
+                // first character is already in the typeahead via the buffer
+                // — `inner.readLine` reads from there.
+                return opts.inner.readLine(prompt);
+            }
+            if (transcript === '') {
+                // Cancelled — fall back to text prompt.
+                return opts.inner.readLine(prompt);
+            }
+            return transcript;
+        },
+        async selectSlashCommand(source) {
+            // Slash commands don't get voice intercept — they're a
+            // discrete dropdown.
+            return opts.inner.selectSlashCommand(source);
+        },
+    };
+}
+/** Wait for either Space (start recording) or any other char (fall
+ *  through to text prompt). Returns:
+ *   - the transcribed string when recording completes
+ *   - '' when user cancels (Esc)
+ *   - null when user types non-space (fall through to inner) */
+async function waitForSpaceOrTypedInput(args) {
+    // Show a brief hint so users know voice mode is hot.
+    args.stdout.write(`${args.prompt}\x1b[2m(Space to talk)\x1b[0m `);
+    const stdin = args.stdin;
+    // Snapshot current raw mode state to restore on exit.
+    const wasRaw = !!stdin.isRaw;
+    if (!wasRaw)
+        stdin.setRawMode(true);
+    stdin.resume();
+    let result = undefined;
+    let recording = false;
+    let transcript = null;
+    let resolveOuter = null;
+    const cleanup = () => {
+        stdin.removeListener('data', onData);
+        stdin.removeListener('error', onError);
+        if (!wasRaw) {
+            try {
+                stdin.setRawMode(false);
+            }
+            catch { /* ignore */ }
+        }
+        stdin.pause();
+    };
+    const onData = (chunk) => {
+        if (chunk.length === 0)
+            return;
+        const code = chunk[0];
+        if (!recording) {
+            if (code === KEY_SPACE) {
+                // Start recording.
+                recording = true;
+                args.voice.startRecording().catch((err) => {
+                    args.logger.warn('startRecording threw', { error: err.message });
+                });
+            }
+            else if (code === KEY_ESC) {
+                result = '';
+                cleanup();
+                resolveOuter?.('');
+            }
+            else if (code === 0x03) {
+                // Ctrl+C — propagate to inner via empty cancel.
+                result = '';
+                cleanup();
+                resolveOuter?.('');
+            }
+            else {
+                // Any other key — fall through to inner prompt. Push the
+                // byte back so inner reads it (best-effort; on Windows
+                // the unread() trick isn't reliable, so we just signal
+                // null and inner re-prompts).
+                result = null;
+                cleanup();
+                resolveOuter?.(null);
+            }
+        }
+        else {
+            // Already recording. Space stops; Esc cancels.
+            if (code === KEY_SPACE) {
+                args.voice.stopRecording().catch((err) => {
+                    args.logger.warn('stopRecording threw', { error: err.message });
+                });
+            }
+            else if (code === KEY_ESC || code === 0x03) {
+                args.voice.cancel();
+                result = '';
+                cleanup();
+                resolveOuter?.('');
+            }
+        }
+    };
+    const onError = (err) => {
+        args.logger.warn('stdin error during voice prompt', { error: err.message });
+        cleanup();
+        resolveOuter?.(null);
+    };
+    // Voice handle's onTranscript wins the race when recording succeeds.
+    // We register a one-shot subscription via the existing callback by
+    // taking advantage of the fact that handle.startRecording resolves
+    // when transcribe completes — at that point transcript will be set
+    // through the host's status callback. To keep this module narrowly
+    // scoped, we POLL voice.getStatus() between awaits via a watcher.
+    const watcher = setInterval(() => {
+        const s = args.voice.getStatus();
+        args.onStatus?.(s);
+        // Recording finished naturally OR errored.
+        if (recording && s === 'idle') {
+            // Drain stdin and resolve. The transcript was forwarded via
+            // the host's onTranscript callback (set up in the cliVoice
+            // constructor); the host stitches it into the conversation.
+            // For the prompt-API contract we resolve with empty so the
+            // outer loop spins to the next iteration.
+            cleanup();
+            clearInterval(watcher);
+            resolveOuter?.(transcript ?? '');
+        }
+    }, 50);
+    stdin.on('data', onData);
+    stdin.on('error', onError);
+    return new Promise((resolve) => {
+        resolveOuter = (v) => {
+            clearInterval(watcher);
+            resolve(v);
+        };
+    });
+}
+/** Test-only helper: enforce the TTY guard. Returns true when voice
+ *  mode is allowed to activate in this process. */
+function voiceModeAllowed(stdin = process.stdin) {
+    return !!stdin.isTTY;
+}

package/dist/core/channels/discord.js

@@ -20,21 +20,27 @@ exports.DiscordAdapter = void 0;
 //   - Graceful degradation: missing token → disabled, no crash
 const discord_js_1 = require("discord.js");
 const gateway_1 = require("../gateway");
+const logger_1 = require("../v4/logger");
 class DiscordAdapter {
     constructor() {
         this.name = 'discord';
         this.client = null;
         this.healthy = false;
+        // Phase v4.1-1.3a — diagnostics route through the channel scope
+        // logger; ChannelManager.register injects it. Default noop keeps
+        // pre-attach calls silent.
+        this.log = (0, logger_1.noopLogger)();
         this.token = process.env.DISCORD_BOT_TOKEN ?? '';
         const rawGuilds = process.env.DISCORD_ALLOWED_GUILDS ?? '';
         const rawChannels = process.env.DISCORD_ALLOWED_CHANNELS ?? '';
         this.allowedGuilds = rawGuilds ? new Set(rawGuilds.split(',').map(s => s.trim()).filter(Boolean)) : new Set();
         this.allowedChannels = rawChannels ? new Set(rawChannels.split(',').map(s => s.trim()).filter(Boolean)) : new Set();
     }
+    attachLogger(logger) { this.log = logger; }
     // ── Lifecycle ──────────────────────────────────────────────
     async start() {
         if (!this.token) {
-            console.log('[Discord] Disabled — set DISCORD_BOT_TOKEN to enable');
+            this.log.info('Disabled — set DISCORD_BOT_TOKEN to enable');
             return;
         }
         this.client = new discord_js_1.Client({
@@ -46,14 +52,14 @@ class DiscordAdapter {
             ],
         });
         this.client.once(discord_js_1.Events.ClientReady, async (c) => {
-            console.log(`[Discord] Connected as ${c.user.tag}`);
+            this.log.info(`Connected as ${c.user.tag}`);
             this.healthy = true;
             // Register outbound delivery so gateway.deliver() and broadcast() work
             gateway_1.gateway.registerChannel('discord', async (msg) => {
                 return this.deliverToChannel(msg.channelId, msg.text);
             });
             // Register slash commands globally (takes ~1h to propagate on first run)
-            await this.registerSlashCommands(c.user.id).catch((e) => console.warn('[Discord] Slash command registration failed:', e.message));
+            await this.registerSlashCommands(c.user.id).catch((e) => this.log.warn(`Slash command registration failed: ${e.message}`));
         });
         this.client.on(discord_js_1.Events.MessageCreate, async (message) => {
             if (!this.shouldHandle(message.author.id, message.guildId, message.channelId, message.author.bot))
@@ -63,7 +69,7 @@ class DiscordAdapter {
             }
             catch { }
             const response = await this.processMessage(message.channelId, message.author.id, message.content);
-            await message.reply(response.substring(0, 2000)).catch((e) => console.error('[Discord] Reply error:', e.message));
+            await message.reply(response.substring(0, 2000)).catch((e) => this.log.error(`Reply error: ${e.message}`));
         });
         this.client.on(discord_js_1.Events.InteractionCreate, async (interaction) => {
             if (!interaction.isChatInputCommand())
@@ -84,7 +90,7 @@ class DiscordAdapter {
                 const prompt = interaction.options.getString('prompt', true);
                 await interaction.deferReply();
                 const response = await this.processMessage(channelId, userId, prompt);
-                await interaction.editReply(response.substring(0, 2000)).catch((e) => console.error('[Discord] editReply error:', e.message));
+                await interaction.editReply(response.substring(0, 2000)).catch((e) => this.log.error(`editReply error: ${e.message}`));
             }
             else if (interaction.commandName === 'aiden-help') {
                 await interaction.reply({
@@ -97,7 +103,7 @@ class DiscordAdapter {
             await this.client.login(this.token);
         }
         catch (e) {
-            console.error('[Discord] Login failed:', e.message);
+            this.log.error(`Login failed: ${e.message}`);
             this.healthy = false;
         }
     }
@@ -108,7 +114,7 @@ class DiscordAdapter {
             await this.client.destroy();
             this.client = null;
         }
-        console.log('[Discord] Disconnected');
+        this.log.info('Disconnected');
     }
     async send(channelId, message) {
         await this.deliverToChannel(channelId, message);
@@ -135,7 +141,7 @@ class DiscordAdapter {
             });
         }
         catch (e) {
-            console.error('[Discord] routeMessage error:', e.message);
+            this.log.error(`routeMessage error: ${e.message}`);
             return '❌ Something went wrong. Try again.';
         }
     }
@@ -149,7 +155,7 @@ class DiscordAdapter {
             return false;
         }
         catch (e) {
-            console.error('[Discord] Delivery error:', e.message);
+            this.log.error(`Delivery error: ${e.message}`);
             return false;
         }
     }
@@ -167,7 +173,7 @@ class DiscordAdapter {
                 .toJSON(),
         ];
         await rest.put(discord_js_1.Routes.applicationCommands(appId), { body: commands });
-        console.log('[Discord] Slash commands registered globally');
+        this.log.info('Slash commands registered globally');
     }
 }
 exports.DiscordAdapter = DiscordAdapter;

package/dist/core/channels/email.js

@@ -33,9 +33,12 @@ exports.EmailAdapter = void 0;
 //   EMAIL_POLL_INTERVAL     — polling interval in seconds (default 60)
 const nodemailer_1 = __importDefault(require("nodemailer"));
 const gateway_1 = require("../gateway");
+const logger_1 = require("../v4/logger");
 class EmailAdapter {
     constructor() {
         this.name = 'email';
+        // Phase v4.1-1.3a — diagnostics route through scope logger.
+        this.log = (0, logger_1.noopLogger)();
         this.healthy = false;
         this.pollTimer = null;
         this.processedIds = new Set();
@@ -52,14 +55,15 @@ class EmailAdapter {
         this.allowedSenders = raw ? new Set(raw.split(',').map(s => s.trim().toLowerCase()).filter(Boolean)) : new Set();
         this.pollIntervalMs = parseInt(process.env.EMAIL_POLL_INTERVAL ?? '60', 10) * 1000;
     }
+    attachLogger(logger) { this.log = logger; }
     // ── Lifecycle ──────────────────────────────────────────────
     async start() {
         if (!this.imapHost || !this.imapUser || !this.imapPassword) {
-            console.log('[Email] Disabled — set EMAIL_IMAP_HOST, EMAIL_IMAP_USER, EMAIL_IMAP_PASSWORD to enable');
+            this.log.info('Disabled — set EMAIL_IMAP_HOST, EMAIL_IMAP_USER, EMAIL_IMAP_PASSWORD to enable');
             return;
         }
         if (!this.smtpHost || !this.smtpUser || !this.smtpPassword) {
-            console.log('[Email] Disabled — set EMAIL_SMTP_HOST, EMAIL_SMTP_USER, EMAIL_SMTP_PASSWORD to enable');
+            this.log.info('Disabled — set EMAIL_SMTP_HOST, EMAIL_SMTP_USER, EMAIL_SMTP_PASSWORD to enable');
             return;
         }
         // Set up SMTP transporter
@@ -75,11 +79,11 @@ class EmailAdapter {
         // Verify SMTP connection
         const smtpOk = await this.transporter.verify().then(() => true).catch(() => false);
         if (!smtpOk) {
-            console.log('[Email] Disabled — SMTP connection failed. Check EMAIL_SMTP_* settings.');
+            this.log.info('Disabled — SMTP connection failed. Check EMAIL_SMTP_* settings.');
             return;
         }
         this.healthy = true;
-        console.log(`[Email] Ready — polling ${this.imapUser} every ${this.pollIntervalMs / 1000}s`);
+        this.log.info('Ready — polling ${this.imapUser} every ${this.pollIntervalMs / 1000}s');
         // Register outbound delivery
         gateway_1.gateway.registerChannel('email', async (msg) => {
             await this.send(msg.channelId, msg.text);
@@ -97,7 +101,7 @@ class EmailAdapter {
         }
         this.transporter = null;
         gateway_1.gateway.unregisterChannel('email');
-        console.log('[Email] Disconnected');
+        this.log.info('Disconnected');
     }
     async send(target, message) {
         if (!this.transporter)
@@ -112,7 +116,7 @@ class EmailAdapter {
             });
         }
         catch (e) {
-            console.error('[Email] send error:', e.message);
+            this.log.error(`send error:${e.message}`);
         }
     }
     isHealthy() { return this.healthy; }
@@ -191,7 +195,7 @@ class EmailAdapter {
         }
         catch (e) {
             if (this.healthy) {
-                console.error('[Email] poll error:', e.message);
+                this.log.error(`poll error:${e.message}`);
             }
         }
         finally {
@@ -217,7 +221,7 @@ class EmailAdapter {
             });
         }
         catch (e) {
-            console.error('[Email] reply error:', e.message);
+            this.log.error(`reply error:${e.message}`);
         }
     }
     extractText(raw) {
@@ -245,7 +249,7 @@ class EmailAdapter {
             });
         }
         catch (e) {
-            console.error('[Email] routeMessage error:', e.message);
+            this.log.error(`routeMessage error:${e.message}`);
             return 'Something went wrong processing your email. Please try again.';
         }
     }

package/dist/core/channels/imessage.js

@@ -26,9 +26,12 @@ exports.IMessageAdapter = void 0;
 const axios_1 = __importDefault(require("axios"));
 const ws_1 = require("ws");
 const gateway_1 = require("../gateway");
+const logger_1 = require("../v4/logger");
 class IMessageAdapter {
     constructor() {
         this.name = 'imessage';
+        // Phase v4.1-1.3a — diagnostics route through scope logger.
+        this.log = (0, logger_1.noopLogger)();
         this.healthy = false;
         this.ws = null;
         this.reconnectTimer = null;
@@ -37,20 +40,21 @@ class IMessageAdapter {
         const raw = process.env.BLUEBUBBLES_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.baseUrl || !this.password) {
-            console.log('[iMessage] Disabled — set BLUEBUBBLES_URL and BLUEBUBBLES_PASSWORD to enable');
+            this.log.info('Disabled — set BLUEBUBBLES_URL and BLUEBUBBLES_PASSWORD to enable');
             return;
         }
         // Verify BlueBubbles is reachable
         const reachable = await this.checkHealth();
         if (!reachable) {
-            console.log(`[iMessage] Disabled — BlueBubbles server not reachable at ${this.baseUrl}`);
+            this.log.info('Disabled — BlueBubbles server not reachable at ${this.baseUrl}');
             return;
         }
         this.healthy = true;
-        console.log(`[iMessage] Connected to BlueBubbles at ${this.baseUrl}`);
+        this.log.info('Connected to BlueBubbles at ${this.baseUrl}');
         // Register outbound delivery
         gateway_1.gateway.registerChannel('imessage', async (msg) => {
             await this.send(msg.channelId, msg.text);
@@ -70,7 +74,7 @@ class IMessageAdapter {
             this.ws = null;
         }
         gateway_1.gateway.unregisterChannel('imessage');
-        console.log('[iMessage] Disconnected');
+        this.log.info('Disconnected');
     }
     async send(target, message) {
         if (!this.healthy)
@@ -82,7 +86,7 @@ class IMessageAdapter {
             });
         }
         catch (e) {
-            console.error('[iMessage] send error:', e.message);
+            this.log.error(`send error:${e.message}`);
         }
     }
     isHealthy() { return this.healthy; }
@@ -105,7 +109,7 @@ class IMessageAdapter {
         const wsUrl = this.baseUrl.replace(/^http/, 'ws');
         this.ws = new ws_1.WebSocket(`${wsUrl}?password=${encodeURIComponent(this.password)}`);
         this.ws.on('open', () => {
-            console.log('[iMessage] WebSocket connected');
+            this.log.info('WebSocket connected');
         });
         this.ws.on('message', async (raw) => {
             try {
@@ -127,11 +131,11 @@ class IMessageAdapter {
                 await this.send(chatId || sender, response);
             }
             catch (e) {
-                console.error('[iMessage] message parse error:', e.message);
+                this.log.error(`message parse error:${e.message}`);
             }
         });
         this.ws.on('error', (e) => {
-            console.error('[iMessage] WebSocket error:', e.message);
+            this.log.error(`WebSocket error:${e.message}`);
         });
         this.ws.on('close', () => {
             if (this.healthy) {
@@ -156,7 +160,7 @@ class IMessageAdapter {
             });
         }
         catch (e) {
-            console.error('[iMessage] routeMessage error:', e.message);
+            this.log.error(`routeMessage error:${e.message}`);
             return '❌ Something went wrong. Try again.';
         }
     }