aiden-runtime 4.0.2 → 4.1.0

package/dist/cli/v4/display.js

@@ -20,6 +20,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Display = exports.SPINNER_PHRASES = exports.TOOL_ICONS = void 0;
 exports.iconForTool = iconForTool;
+exports.detectConfiguredChannels = detectConfiguredChannels;
+exports.summarizeConfiguredChannels = summarizeConfiguredChannels;
+exports.summarizeChannelState = summarizeChannelState;
+exports.voiceIndicator = voiceIndicator;
 exports.previewToolArgs = previewToolArgs;
 exports.formatToolDuration = formatToolDuration;
 exports.formatCompactTokens = formatCompactTokens;
@@ -32,6 +36,12 @@ const marked_1 = require("marked");
 const TerminalRenderer = require('marked-terminal').default ?? require('marked-terminal');
 const skinEngine_1 = require("./skinEngine");
 const box_1 = require("./box");
+// Phase v4.1-reply-formatting: skin-aware markdown renderer that
+// replaces marked-terminal's defaults with structured headers, lists,
+// code blocks, blockquotes, and links.
+const replyRenderer_1 = require("./replyRenderer");
+// Optional "Sources" footer when AIDEN_CITATIONS=1 (default off).
+const citationFooter_1 = require("./citationFooter");
 /**
  * Phase 26.2.7 — category emoji icons for the tool-row prefix when
  * `AIDEN_UI_ICONS=1` is set in the environment. Default OFF (the
@@ -126,6 +136,74 @@ exports.SPINNER_PHRASES = [
     'Smelting',
     'Conjuring',
 ];
+/**
+ * Phase v4.1-1 — boot card "channels" pill helpers. The CLI process
+ * doesn't actually run channel adapters (those live in the API server)
+ * so we report what we *can* honestly know from the environment: how
+ * many of the nine channel adapters have their credentials present.
+ *
+ * `summarizeConfiguredChannels` returns a render-ready label like
+ * `"3 configured (incl. telegram)"` for the Environment column.
+ */
+const CHANNEL_ENV_VARS = [
+    { id: 'telegram', vars: ['TELEGRAM_BOT_TOKEN'] },
+    { id: 'discord', vars: ['DISCORD_BOT_TOKEN'] },
+    { id: 'slack', vars: ['SLACK_BOT_TOKEN', 'SLACK_APP_TOKEN'] },
+    { id: 'whatsapp', vars: ['WHATSAPP_BUSINESS_API_KEY'] },
+    { id: 'twilio', vars: ['TWILIO_AUTH_TOKEN'] },
+    { id: 'imessage', vars: ['BLUEBUBBLES_PASSWORD'] },
+    { id: 'email', vars: ['EMAIL_IMAP_PASSWORD', 'EMAIL_SMTP_PASSWORD'] },
+];
+function detectConfiguredChannels(env = process.env) {
+    const ids = [];
+    for (const c of CHANNEL_ENV_VARS) {
+        if (c.vars.some((v) => typeof env[v] === 'string' && env[v].trim() !== '')) {
+            ids.push(c.id);
+        }
+    }
+    return { total: ids.length, ids, telegram: ids.includes('telegram') };
+}
+function summarizeConfiguredChannels(detection = detectConfiguredChannels()) {
+    if (detection.total === 0)
+        return '0 configured';
+    const suffix = detection.telegram ? ' (incl. telegram)' : '';
+    return `${detection.total} configured${suffix}`;
+}
+function summarizeChannelState(probe, envFallback = detectConfiguredChannels()) {
+    // No live probe (e.g. test harness with no manager) → env-only count.
+    if (!probe) {
+        if (envFallback.total === 0) {
+            return '0 configured (run /channel telegram add to enable)';
+        }
+        return `${envFallback.total} configured${envFallback.telegram ? ' (incl. telegram)' : ''}`;
+    }
+    // Phase v4.1-1.2 — conflict takes priority over the generic active /
+    // offline split. If any adapter is in the conflict state, surface
+    // that explicitly so the user has an unambiguous remediation hint.
+    const conflicted = probe.adapters.filter((a) => a.state === 'conflict');
+    if (conflicted.length > 0) {
+        const names = conflicted.map((a) => a.id).join(', ');
+        return `${conflicted.length} degraded: ${names} (conflict — /channel telegram takeover)`;
+    }
+    const active = probe.adapters.filter((a) => a.healthy);
+    const inactive = probe.adapters.filter((a) => !a.healthy);
+    if (active.length === 0) {
+        if (envFallback.total === 0) {
+            return '0 configured (run /channel telegram add to enable)';
+        }
+        // Token in env but adapter not healthy — frame it as offline so
+        // the user knows /channel telegram status is the next step.
+        const offlineNames = inactive
+            .filter((a) => envFallback.ids.includes(a.id))
+            .map((a) => a.id)
+            .join(', ');
+        return offlineNames
+            ? `${envFallback.total} configured: ${offlineNames} (offline — /channel telegram status)`
+            : `${envFallback.total} configured`;
+    }
+    const parts = active.map((a) => (a.botHandle ? `${a.id} (@${a.botHandle})` : a.id));
+    return `${active.length} active: ${parts.join(', ')}`;
+}
 const AIDEN_BANNER = String.raw `
 █████╗  ██╗██████╗ ███████╗███╗   ██╗
 ██╔══██╗██║██╔══██╗██╔════╝████╗  ██║
@@ -144,6 +222,14 @@ class Display {
         // starts on its own line.
         this.streamHeaderShown = false;
         this.streamLastEndedNewline = false;
+        // Phase v4.1-reply-formatting: track the running buffered stream
+        // so streamComplete can re-render it as structured markdown
+        // (headers / lists / code blocks / blockquotes) once the full
+        // body is known. During streaming the raw text remains visible
+        // — the post-stream pass clears it via cursor-up + erase-line and
+        // reprints the formatted output.
+        this.streamBuffer = '';
+        this.streamLineCount = 0;
         this.skin = opts.skin ?? (0, skinEngine_1.getSkinEngine)();
         this.out = opts.stdout ?? process.stdout;
         this.err = opts.stderr ?? process.stderr;
@@ -320,10 +406,13 @@ class Display {
      * `cols() >= 80`, stacked vertically below that. Title in brand,
      * keys in muted (padded to 11 visible chars), values in `agent`.
      */
-    twoColumnBlock(left, right) {
+    twoColumnBlock(left, right, opts = {}) {
         const sk = this.skin;
         const cols = this.cols();
-        const stacked = cols < 80;
+        // Tier-3.1b: callers can raise the side-by-side threshold (boot
+        // card prefers stacked at 70-119 cols, side-by-side only at ≥120).
+        // Default 80 preserves prior behaviour for any other caller.
+        const stacked = cols < (opts.sideBySideThreshold ?? 80);
         const indent = '  ';
         const KEY_PAD = 11;
         const renderRows = (sec) => {
@@ -395,13 +484,10 @@ class Display {
         const val = (s) => sk.applyColors(s, 'agent');
         const heart = sk.applyColors('♥', 'brand');
         if (this.cols() < 80) {
-            // Plain 4-line fallback (no border).
-            return [
-                `  ${heart}  ${val('Built solo')}`,
-                `  ${lab('GitHub:')}  ${val('github.com/taracodlabs/aiden')}`,
-                `  ${lab('Web:')}     ${val('aiden.taracod.com')}`,
-                `  ${lab('Contact:')} ${val('contact@taracod.com')}`,
-            ].join('\n');
+            // Tier-3.1b: single-line credits at narrow widths so the boot
+            // card stays compact. The 4-line plain fallback shipped earlier
+            // wastes vertical space when terminals already squeeze content.
+            return `  ${heart} ${m('built solo · github.com/taracodlabs/aiden · aiden.taracod.com')}`;
         }
         // Parchment.
         const INTERIOR = 63;
@@ -477,6 +563,74 @@ class Display {
         const elapsed = sk.applyColors(formatElapsedShort(args.elapsedMs), 'muted');
         return `  ${provModel}${SEP}${ctxSeg}${SEP}${elapsed}`;
     }
+    /**
+     * Tier-3.1 (v4.1-tier3.1): pre-prompt status line.
+     *
+     * Single-line summary written ABOVE the input prompt on every
+     * fresh turn. Format (full, ≥76 cols):
+     *
+     *   <provider>:<model> · ctx <N>/<M>k · MCP <state> · cron <state>
+     *
+     * Width-tier degrade:
+     *   <52 cols  → only `<provider>:<model> · ctx N/Mk`
+     *   <76 cols  → drop voice indicator
+     *   ≥76 cols  → full
+     *
+     * MCP serve mode: this helper is a pure builder; callers MUST
+     * gate the actual write on `isMcpServeMode()` from
+     * `cli/v4/uiBuild.ts`. The function itself never writes.
+     */
+    renderStatusLine(args) {
+        const sk = this.skin;
+        const cols = args.cols ?? this.cols();
+        const SEP = sk.applyColors(' · ', 'muted');
+        const colourForState = (s) => {
+            if (s === 'active')
+                return 'success';
+            if (s === 'broken')
+                return 'error';
+            return 'muted';
+        };
+        const glyphForState = (s) => {
+            if (s === 'active')
+                return '✓'; // ✓
+            if (s === 'broken')
+                return '✗'; // ✗
+            return '-';
+        };
+        const provModel = sk.applyColors(args.provider, 'muted') +
+            sk.applyColors(':', 'muted') +
+            sk.applyColors(args.model, 'agent');
+        const ctxSeg = (() => {
+            if (args.ctxMax == null || args.ctxUsed == null)
+                return '';
+            const usedK = Math.round(args.ctxUsed / 1000);
+            const maxK = Math.max(1, Math.round(args.ctxMax / 1000));
+            return sk.applyColors(`ctx ${usedK}/${maxK}k`, 'muted');
+        })();
+        const mcpSeg = args.mcpState
+            ? sk.applyColors(`MCP ${glyphForState(args.mcpState)}`, colourForState(args.mcpState))
+            : '';
+        const cronSeg = args.cronState
+            ? sk.applyColors(`cron ${glyphForState(args.cronState)}`, colourForState(args.cronState))
+            : '';
+        const voiceSeg = args.voiceRecording
+            ? sk.applyColors('[REC]', 'error')
+            : '';
+        // Compose with width-tier degrade.
+        const segs = [provModel];
+        if (ctxSeg)
+            segs.push(ctxSeg);
+        if (cols >= 52) {
+            if (mcpSeg)
+                segs.push(mcpSeg);
+            if (cronSeg)
+                segs.push(cronSeg);
+        }
+        if (cols >= 76 && voiceSeg)
+            segs.push(voiceSeg);
+        return '  ' + segs.join(SEP);
+    }
     /**
      * Optional provider-switch indicator line — emitted only when this
      * turn ran on a different provider than the previous one.  Format
@@ -657,14 +811,24 @@ class Display {
         const arrow = sk.getActive().glyphs?.arrow ?? '>';
         return `${sk.applyColors(arrow, 'tool')} ${sk.applyColors(name, 'tool')} ${sk.applyColors(serialized, 'muted')}`;
     }
-    /** Render markdown to ANSI; falls back to raw text if marked-terminal failed to wire. */
+    /**
+     * Render markdown to ANSI via the v4.1-reply-formatting renderer
+     * (skin-aware headers / lists / code / quotes / links). Falls back
+     * to the marked-terminal default config if the structured renderer
+     * is unavailable, then raw text as a last resort.
+     */
     markdown(text) {
         try {
-            const out = marked_1.marked.parse(text);
-            return typeof out === 'string' ? out : String(out);
+            return (0, replyRenderer_1.getReplyRenderer)().render(text);
         }
         catch {
-            return text;
+            try {
+                const out = marked_1.marked.parse(text);
+                return typeof out === 'string' ? out : String(out);
+            }
+            catch {
+                return text;
+            }
         }
     }
     /** Format a user turn (e.g. echoed back from history). */
@@ -809,9 +973,18 @@ class Display {
             // open identically.
             this.out.write(this.agentHeader());
             this.streamHeaderShown = true;
+            this.streamBuffer = '';
+            this.streamLineCount = 0;
         }
         this.out.write(text);
         this.streamLastEndedNewline = text.endsWith('\n');
+        // Phase v4.1-reply-formatting: track buffer + line count for the
+        // post-stream re-render. We count newlines in the OUTGOING bytes
+        // so the eraser later knows how many rows to clear.
+        this.streamBuffer += text;
+        for (let i = 0; i < text.length; i += 1)
+            if (text[i] === '\n')
+                this.streamLineCount += 1;
     }
     /**
      * Mark the end of a streaming turn. Adds a trailing newline if the
@@ -824,8 +997,68 @@ class Display {
             return;
         if (!this.streamLastEndedNewline)
             this.out.write('\n');
+        // Phase v4.1-reply-formatting: re-render the buffered stream as
+        // structured markdown — but ONLY when stdout is a TTY and the
+        // buffer actually contains markdown structure worth rendering.
+        // Plain prose with no headers / lists / fences gets left alone
+        // (no flicker, identical output). Otherwise we erase the raw
+        // streamed body via cursor-up + erase-line and reprint via the
+        // skin-aware renderer.
+        const buffered = this.streamBuffer;
+        const lines = this.streamLineCount;
+        this.streamBuffer = '';
+        this.streamLineCount = 0;
         this.streamHeaderShown = false;
         this.streamLastEndedNewline = false;
+        if (!this.out.isTTY)
+            return;
+        if (process.env.AIDEN_NO_REFORMAT === '1')
+            return;
+        // Cheap heuristic: only re-render when there's structure that
+        // benefits from formatting. Avoids flicker on short prose replies.
+        const hasStructure = /^#{1,6}\s/m.test(buffered) ||
+            /^\s*[-*+]\s/m.test(buffered) ||
+            /^\s*\d+\.\s/m.test(buffered) ||
+            /^>\s/m.test(buffered) ||
+            /```/.test(buffered);
+        if (!hasStructure)
+            return;
+        try {
+            // Erase the raw streamed body in place. We wrote `lines + 1`
+            // rows (header + body) — the header (`┃ Aiden`) stays, so we
+            // walk back `lines` rows and clear each.
+            // `\x1b[<n>F` = cursor-up-and-to-column-0 N times.
+            // `\x1b[J`    = erase from cursor to end of screen.
+            if (lines > 0) {
+                this.out.write(`\x1b[${lines}F\x1b[J`);
+            }
+            const formatted = this.markdown(buffered).trimEnd();
+            const indented = formatted
+                .split('\n')
+                .map((ln) => (ln ? `  ${ln}` : ''))
+                .join('\n');
+            this.out.write(indented + '\n');
+        }
+        catch {
+            // If anything goes wrong with the re-render, leave the raw
+            // streamed text in place — graceful degradation beats flicker
+            // + corrupted output.
+        }
+    }
+    /**
+     * Phase v4.1-reply-formatting: render the optional "Sources"
+     * footer when AIDEN_CITATIONS=1 and the trace has fetch-class
+     * tool calls. Pure write; safe to call after a turn completes
+     * regardless of streaming/non-streaming. No-op when the env gate
+     * is off or no sources surface.
+     */
+    printCitationFooter(trace) {
+        const footer = (0, citationFooter_1.renderCitationFooter)(trace);
+        if (!footer)
+            return;
+        if (!this.out.isTTY)
+            return;
+        this.out.write(footer);
     }
     /**
      * Inline tool indicator. Printed between deltas when a tool call
@@ -842,6 +1075,57 @@ class Display {
     }
 }
 exports.Display = Display;
+/**
+ * Render a voice-mode status line. Pure builder — caller writes the
+ * result via Display.streamPartial / direct stdout. Includes a
+ * RMS-driven block bar when state is `recording`. The bar uses 8
+ * unicode block-fill levels (▏ to █) over a 0..1500 RMS range,
+ * which covers the practical loud-speech ceiling without saturating
+ * for any reasonable mic preamp.
+ *
+ * Tier-3.1 (v4.1-tier3.1): replaced 🎤 / 🔊 emoji with text-state
+ * badges `[REC]` (recording, error/red) and `[PLAY]` (speaking,
+ * success/green). Idle/listening/transcribing get the neutral
+ * `[VOX]` badge in muted colour. Same 4-char inner width keeps
+ * subsequent column alignment intact.
+ *
+ * Examples:
+ *   voiceIndicator('idle')                  → '[VOX] idle (Space to talk)'
+ *   voiceIndicator('listening')             → '[VOX] listening...'
+ *   voiceIndicator('recording', 800)        → '[REC] ▌▌▌▌▌▌  recording (Space to stop, Esc to cancel)'
+ *   voiceIndicator('transcribing')          → '[VOX] transcribing...'
+ *   voiceIndicator('speaking')              → '[PLAY] speaking...'
+ */
+function voiceIndicator(state, rms = 0) {
+    const skin = (0, skinEngine_1.getSkinEngine)();
+    const recBadge = skin.applyColors('[REC]', 'error');
+    const playBadge = skin.applyColors('[PLAY]', 'success');
+    const voxBadge = skin.applyColors('[VOX]', 'muted');
+    switch (state) {
+        case 'idle':
+            return `${voxBadge} idle (Space to talk)`;
+        case 'listening':
+            return `${voxBadge} listening...`;
+        case 'recording': {
+            const bar = renderRmsBar(rms);
+            return `${recBadge} ${bar}  recording (Space to stop, Esc to cancel)`;
+        }
+        case 'transcribing':
+            return `${voxBadge} transcribing...`;
+        case 'speaking':
+            return `${playBadge} speaking...`;
+        default:
+            return `${voxBadge} ${state}`;
+    }
+}
+const BAR_WIDTH = 12;
+const BAR_FULL_RMS = 1500;
+/** RMS-driven horizontal block bar. 0..BAR_FULL_RMS → 0..BAR_WIDTH chars. */
+function renderRmsBar(rms) {
+    const safe = Math.max(0, Math.min(rms, BAR_FULL_RMS));
+    const filled = Math.round((safe / BAR_FULL_RMS) * BAR_WIDTH);
+    return '▌'.repeat(filled) + ' '.repeat(BAR_WIDTH - filled);
+}
 // ── Phase 23.5 — tool row helpers ─────────────────────────────────────
 /** Width the tool name is padded to so brackets line up across rows. */
 const TOOL_ROW_NAME_PAD = 16;

package/dist/cli/v4/doctor.js

@@ -34,6 +34,7 @@ exports.checkNpxAvailable = checkNpxAvailable;
 exports.checkSkillsDir = checkSkillsDir;
 exports.checkBundledManifest = checkBundledManifest;
 exports.checkPlatformPaths = checkPlatformPaths;
+exports.checkAudioBackend = checkAudioBackend;
 exports.checkLicense = checkLicense;
 exports.checkUpdate = checkUpdate;
 exports.checkLogsWritable = checkLogsWritable;
@@ -48,6 +49,7 @@ const paths_1 = require("../../core/v4/paths");
 const license_1 = require("../../core/v4/license");
 const checkUpdate_1 = require("../../core/v4/update/checkUpdate");
 const box_1 = require("./box");
+const audioBackend_1 = require("../../core/voice/audioBackend");
 const DEFAULT_TIMEOUT_MS = 3000;
 /** Wrap a promise with a timeout. The timed-out path resolves to the fallback result. */
 async function withTimeout(p, ms, fallback) {
@@ -421,6 +423,44 @@ async function checkPlatformPaths(paths) {
         };
     }
 }
+/**
+ * Phase v4.1-cross-platform: probe per-OS audio backends so a user
+ * who installs Aiden fresh on Linux/macOS gets a clear "install sox"
+ * pointer instead of a stack trace the first time they run /voice.
+ *
+ * Reports as INFO not FAILURE — the agent loop works fine without
+ * voice support; we just want to surface the install hint.
+ */
+async function checkAudioBackend() {
+    const t0 = Date.now();
+    const playback = (0, audioBackend_1.detectBackend)('playback');
+    const record = (0, audioBackend_1.detectBackend)('record');
+    const known = {
+        playback: (0, audioBackend_1.listKnownBackends)('playback').map((b) => b.label),
+        record: (0, audioBackend_1.listKnownBackends)('record').map((b) => b.label),
+    };
+    if (playback && record) {
+        return {
+            name: 'audio backend',
+            passed: true,
+            message: `${process.platform}: playback=${playback.label} · record=${record.label}`,
+            durationMs: Date.now() - t0,
+        };
+    }
+    // Pass=true — informational. The suggestion carries the fix.
+    const missing = [];
+    if (!playback)
+        missing.push((0, audioBackend_1.missingBackendMessage)('playback'));
+    if (!record)
+        missing.push((0, audioBackend_1.missingBackendMessage)('record'));
+    return {
+        name: 'audio backend',
+        passed: true,
+        message: `${process.platform}: voice features will not work — backends missing (known: ${[...new Set([...known.playback, ...known.record])].join(', ') || 'none'})`,
+        suggestion: missing.join(' || '),
+        durationMs: Date.now() - t0,
+    };
+}
 /**
  * Phase 20 Task 7: license-server reachability + local cache state.
  * `/doctor` shouldn't block when offline — we treat both "no local cache
@@ -586,6 +626,7 @@ async function runDoctor(opts = {}) {
     results.push(await checkBundledManifest(paths));
     results.push(await checkPlatformPaths(paths));
     results.push(await checkLogsWritable(paths));
+    results.push(await checkAudioBackend());
     // Phase 20 Task 7: license + update health.
     results.push(await checkLicense({ paths, fetchImpl, timeoutMs }));
     results.push(await checkUpdate({ paths, installedVersion, timeoutMs }));

package/dist/cli/v4/envSources.js

@@ -33,9 +33,13 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.KNOWN_PROVIDER_KEYS = void 0;
 exports.loadAidenEnvFile = loadAidenEnvFile;
 exports.getEnvSource = getEnvSource;
 exports.__resetEnvSources = __resetEnvSources;
+exports.resolveAidenInstallDir = resolveAidenInstallDir;
+exports.loadMcpEnvSources = loadMcpEnvSources;
+exports.describeProviderKeys = describeProviderKeys;
 /**
  * Copyright (c) 2026 Shiva Deore (Taracod).
  * Licensed under AGPL-3.0. See LICENSE for details.
@@ -59,6 +63,7 @@ exports.__resetEnvSources = __resetEnvSources;
  *   - 'unset'     — not in process.env
  */
 const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
 const ENV_SOURCE_TAG = Symbol.for('aiden.envSource');
 function getMap() {
     let m = globalThis[ENV_SOURCE_TAG];
@@ -121,3 +126,103 @@ function getEnvSource(key) {
 function __resetEnvSources() {
     getMap().clear();
 }
+// ── Phase v4.1-mcp.2 — Multi-source env loader for `aiden mcp serve` ──
+//
+// When Claude Desktop / Cursor / Claude Code spawn `aiden mcp serve`
+// over stdio, they pass an EMPTY env block by default. Without an
+// explicit `env: {...}` per-server entry in the client config, the
+// spawned aiden has no GROQ_API_KEY, GEMINI_API_KEY, etc. Provider-
+// using tools (subagent_fanout, web_search, fetch_url, …) then fail
+// with "no providers configured".
+//
+// Fix: at MCP serve startup, eagerly load .env files from a small
+// list of well-known locations into process.env. Same fill-only
+// semantics as `loadAidenEnvFile` (preset > file). Caller passes
+// `paths.envFile` (covers `~/.aiden/.env` and Windows-equivalent).
+// We additionally probe the install directory so a project-local
+// `.env` in the Aiden checkout works out of the box.
+//
+// NEVER log the values — only the source path and the set of keys
+// (names) detected.
+/** Walk up from `from` looking for an Aiden install root — a directory
+ *  containing a `package.json` whose `name` is `aiden-runtime`. Returns
+ *  null when no candidate is found within `maxDepth` levels. */
+function resolveAidenInstallDir(from = __dirname, maxDepth = 8) {
+    let dir = path.resolve(from);
+    for (let i = 0; i < maxDepth; i += 1) {
+        const pkg = path.join(dir, 'package.json');
+        try {
+            const text = fs.readFileSync(pkg, 'utf8');
+            const parsed = JSON.parse(text);
+            if (parsed.name === 'aiden-runtime')
+                return dir;
+        }
+        catch { /* not present or unparseable, walk up */ }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+/** Load `.env` files for `aiden mcp serve`. Order:
+ *
+ *   1. `<aiden_install_dir>/.env`  — project-local, dev convenience
+ *   2. `aidenHomeEnv`               — per-user, `paths.envFile`
+ *
+ *   3. process.env — already loaded; takes precedence over both
+ *                    via fill-only semantics.
+ *
+ *  Caller logs the report via the mcp-stdio logger (stderr-safe).
+ *  Values are NEVER returned — only counts + key names. */
+function loadMcpEnvSources(opts) {
+    const attempts = [];
+    const installDir = opts.installDir ?? resolveAidenInstallDir();
+    const candidates = [];
+    if (installDir)
+        candidates.push(path.join(installDir, '.env'));
+    candidates.push(opts.aidenHomeEnv);
+    let appliedTotal = 0;
+    for (const file of candidates) {
+        const before = new Set(Object.keys(process.env));
+        let exists = false;
+        try {
+            fs.accessSync(file, fs.constants.R_OK);
+            exists = true;
+        }
+        catch { /* missing — record and skip */ }
+        if (exists)
+            loadAidenEnvFile(file);
+        const appliedKeys = [];
+        for (const k of Object.keys(process.env)) {
+            if (!before.has(k))
+                appliedKeys.push(k);
+        }
+        appliedTotal += appliedKeys.length;
+        attempts.push({ path: file, exists, appliedKeys });
+    }
+    return { attempts, appliedTotal };
+}
+/** The provider-key surface aiden cares about for `mcp status` output.
+ *  Listed explicitly so we never accidentally enumerate / log a
+ *  newly-added secret.  */
+exports.KNOWN_PROVIDER_KEYS = [
+    'GROQ_API_KEY',
+    'GEMINI_API_KEY',
+    'TOGETHER_API_KEY',
+    'OPENROUTER_API_KEY',
+    'ANTHROPIC_API_KEY',
+    'OPENAI_API_KEY',
+    'CEREBRAS_API_KEY',
+    'NVIDIA_API_KEY',
+    'COHERE_API_KEY',
+];
+/** Snapshot of provider-key presence + source. Values NEVER returned;
+ *  only the source tag (`preset`/`aiden-env`/`unset`). */
+function describeProviderKeys(keys = exports.KNOWN_PROVIDER_KEYS) {
+    return keys.map((key) => ({
+        key,
+        present: typeof process.env[key] === 'string' && process.env[key].length > 0,
+        source: getEnvSource(key),
+    }));
+}

package/dist/cli/v4/ghostMatch.js

@@ -0,0 +1,74 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/ghostMatch.ts — Tier-3.1.1 (v4.1-tier3.1.1)
+ *
+ * Compute the best ghost-text match for what the user has typed so far.
+ * The aidenPrompt component calls `findGhost(typed, ctx)` on every
+ * keystroke and renders the returned suggestion (in dim) past the
+ * cursor.
+ *
+ * Two modes:
+ *
+ *   1. Slash mode (typed starts with `/`): match against registered
+ *      slash command names + aliases. Longest start-with match wins
+ *      (so `/p` favours `/plugins` over `/personality`/`/providers`
+ *      only if no shorter unique match exists; ties broken by
+ *      alphabetical order so the result is deterministic).
+ *
+ *   2. Free-text mode: match against recent user prompts (most recent
+ *      first). Returns the first prompt that starts with `typed` and
+ *      is strictly longer.
+ *
+ * Returns the SUFFIX to append after the typed text, or `null` if no
+ * match exists. Empty/whitespace-only typed text → null. Typed text
+ * containing a paste-compression label (`[paste #N: …]`) → null
+ * (don't suggest over a compressed paste).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findGhost = findGhost;
+const PASTE_LABEL_RE = /\[paste #\d+:[^\]]*\]/;
+/**
+ * Return the suffix to append (everything past `typed`) or null.
+ *
+ * Examples:
+ *   findGhost('/cr',  { slashNames: ['cron','clear'], … }) → 'on'
+ *   findGhost('/x',   { slashNames: ['cron'], … })          → null
+ *   findGhost('how ', { history: ['how do I quit'], … })    → 'do I quit'
+ */
+function findGhost(typed, ctx) {
+    if (!typed || typed.trim().length === 0)
+        return null;
+    if (PASTE_LABEL_RE.test(typed))
+        return null;
+    if (typed.startsWith('/')) {
+        const stem = typed.slice(1);
+        if (stem.length === 0)
+            return null;
+        const all = [...ctx.slashNames, ...ctx.slashAliases];
+        // Longest start-with match wins. Ties broken alphabetically.
+        const candidates = all
+            .filter((n) => n.startsWith(stem) && n.length > stem.length)
+            .sort();
+        if (candidates.length === 0)
+            return null;
+        // Prefer the SHORTEST candidate that uniquely starts with stem
+        // (more likely the user-intended completion). Fall back to the
+        // alphabetically-first if all share the same length.
+        const shortest = candidates.reduce((best, c) => c.length < best.length ? c : best);
+        return shortest.slice(stem.length);
+    }
+    // Free-text — history fallback. Prefer the most-recent strict
+    // start-with match.
+    for (const past of ctx.history) {
+        if (past.startsWith(typed) && past.length > typed.length) {
+            return past.slice(typed.length);
+        }
+    }
+    return null;
+}