aiden-runtime 4.0.2 → 4.1.1

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

@@ -18,6 +18,39 @@
  * will normally be sub-second.
  *
  */
+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 };
 };
@@ -34,6 +67,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 +82,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 +456,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 +659,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 }));
@@ -719,6 +793,33 @@ async function runDoctorCli(opts) {
         }
     }
     process.stdout.write(`\n${report.passed ? 'all checks passed' : 'some checks failed'} in ${report.totalMs} ms\n`);
-    process.exitCode = report.passed ? 0 : 1;
+    // Phase v4.1.1-oauth-fix Phase 5: discoverability hint for the deep
+    // mode. Only emitted in standard mode — if the user already passed
+    // `--providers`, the section right below this is the answer to the hint.
+    if (!opts?.liveness) {
+        process.stdout.write('  hint: Run `aiden doctor --providers` for live provider checks\n');
+    }
+    // Phase v4.1.1-oauth-fix Phase 4: opt-in provider liveness.
+    // Runs after the standard report so a failed config check is visible
+    // before the network probes start. Section header + summary line are
+    // rendered by doctorLiveness.renderProviderLivenessSection so the
+    // formatting stays alongside its consumer.
+    let livenessFailed = false;
+    if (opts?.liveness) {
+        process.stdout.write('\n  Running provider liveness checks...\n');
+        const { runProviderLiveness, renderProviderLivenessSection } = await Promise.resolve().then(() => __importStar(require('./doctorLiveness')));
+        const paths = opts.paths ?? (0, paths_1.resolveAidenPaths)();
+        const { results, summary } = await runProviderLiveness({
+            paths,
+            env: opts.env,
+            fetchImpl: opts.fetchImpl,
+            timeoutMs: opts.livenessTimeoutMs,
+        });
+        process.stdout.write(renderProviderLivenessSection(results, summary));
+        livenessFailed = summary.red > 0;
+    }
+    // Liveness reds count toward the overall exit code so CI / scripts
+    // can `aiden doctor --providers && deploy`.
+    process.exitCode = (report.passed && !livenessFailed) ? 0 : 1;
     return report;
 }