agentic-qe 3.15.11 → 3.15.13

package/dist/mcp/daemon-mode.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Agentic QE v3 - MCP server daemon mode (#1158)
+ *
+ * The generated `.agentic-qe/workers/start-daemon.cjs` runs the MCP server as
+ * a detached background process with no stdin (`stdio: 'ignore'`), only to
+ * host the worker daemon. The #513 guard treats stdin EOF as "the client is
+ * gone" and shuts the server down, so that daemon used to exit within
+ * seconds of starting.
+ *
+ * `AQE_MCP_DAEMON=1` selects daemon mode. It changes exactly one thing: stdin
+ * EOF/close no longer shuts the server down, and a ref'd heartbeat timer keeps
+ * the process alive (worker timers are unref'd, also #513). The server then
+ * stops only on SIGTERM/SIGINT (what `stop-daemon.cjs` sends), the JSON-RPC
+ * `shutdown` method, or a crash.
+ *
+ * Safety: daemon mode is honoured only when stdin is NOT a pipe or socket. An
+ * MCP client always talks to the server over a pipe/socket, so an
+ * `AQE_MCP_DAEMON` that leaks into a client's environment cannot turn its
+ * server into an orphan that outlives the client: the #513 guard stays on and
+ * a warning is logged. The variable is also removed from `process.env` once
+ * read, so processes the server spawns do not inherit it.
+ *
+ * Log size (#1207): the server's stdout/stderr ARE daemon.log (a descriptor
+ * opened with O_APPEND by start-daemon.cjs), so renaming the file would not
+ * stop the writes. Instead, on each heartbeat the server copies an oversized
+ * daemon.log to daemon.log.1 and truncates daemon.log in place; with O_APPEND
+ * the next write lands at the new end of the file. start-daemon.cjs rotates an
+ * oversized log at start-up the same way (a rename, as nothing writes it then).
+ */
+export declare const DAEMON_MODE_ENV = "AQE_MCP_DAEMON";
+/** Default interval of the daemon heartbeat line in daemon.log. */
+export declare const DEFAULT_DAEMON_HEARTBEAT_MS = 60000;
+/** Heartbeat interval in seconds (#1207), also how often daemon.log size is checked. */
+export declare const DAEMON_HEARTBEAT_ENV = "AQE_DAEMON_HEARTBEAT_SECONDS";
+/** Size cap of daemon.log before it is rotated to daemon.log.1 (#1207). */
+export declare const DAEMON_LOG_MAX_SIZE_ENV = "AQE_DAEMON_LOG_MAX_SIZE";
+export declare const DEFAULT_DAEMON_LOG_MAX_BYTES: number;
+/**
+ * Absolute path of daemon.log, set by start-daemon.cjs for the server it
+ * starts. Internal: the server rotates the log only when this file is the one
+ * its stdout/stderr write to.
+ */
+export declare const DAEMON_LOG_PATH_ENV = "AQE_MCP_DAEMON_LOG";
+export interface ParsedSetting {
+    value: number;
+    /** Set when the raw value was rejected and the default applies. */
+    warning?: string;
+}
+/**
+ * Parse `AQE_DAEMON_LOG_MAX_SIZE`: bytes, or a number with a K, M or G suffix
+ * (binary units, optional trailing B). `0`/`off` disables rotation (value 0).
+ * Unset, empty or invalid values fall back to the 5 MB default.
+ */
+export declare function parseDaemonLogMaxBytes(raw: string | undefined): ParsedSetting;
+/** Parse `AQE_DAEMON_HEARTBEAT_SECONDS` (whole seconds, 1 to 86400) into milliseconds. */
+export declare function parseDaemonHeartbeatMs(raw: string | undefined): ParsedSetting;
+/** What `fd 0` is connected to, as far as the guard cares. */
+export type StdinKind = 'tty' | 'pipe' | 'other';
+/** How the server's lifecycle reacts to stdin. */
+export type StdinGuardMode = 
+/** Normal stdio client: stdin EOF/close shuts the server down (#513). */
+'stdio'
+/** Interactive terminal: no guard, so Ctrl-D does not kill a debug session. */
+ | 'tty'
+/** `AQE_MCP_DAEMON` with a non-pipe stdin: stdin is ignored (#1158). */
+ | 'daemon';
+export interface StdinGuardDecision {
+    mode: StdinGuardMode;
+    /** Set when daemon mode was requested but refused. */
+    warning?: string;
+}
+/** Whether the environment asks for daemon mode. */
+export declare function isDaemonModeRequested(env: Readonly<Record<string, string | undefined>>): boolean;
+/**
+ * Classify the process's stdin. A FIFO or socket means a client is (or was)
+ * connected; `/dev/null` (`stdio: 'ignore'`) or a regular file is 'other'.
+ */
+export declare function detectStdinKind(stdin?: {
+    isTTY?: boolean;
+}, fd?: number): StdinKind;
+/** Decide how the server should treat stdin EOF. Pure: no side effects. */
+export declare function resolveStdinGuardMode(env: Readonly<Record<string, string | undefined>>, stdinKind: StdinKind): StdinGuardDecision;
+export interface DaemonHeartbeatStatus {
+    totalWorkers: number;
+    errorWorkers: number;
+    /** Worker runs since the daemon started, all workers together. */
+    totalExecutions: number;
+    failedExecutions: number;
+}
+/**
+ * Keep a daemon-mode server alive and log one heartbeat line per interval.
+ * The timer is deliberately ref'd: nothing else holds the event loop open in
+ * daemon mode. `beforeBeat` runs just before each line (log rotation, #1207);
+ * an error it throws is ignored. Returns a function that stops it.
+ */
+export declare function startDaemonHeartbeat(log: (message: string) => void, getStatus: () => DaemonHeartbeatStatus | undefined, intervalMs?: number, beforeBeat?: () => void): () => void;
+export type DaemonLogRotation = {
+    rotated: true;
+    bytes: number;
+    kept: boolean;
+    error?: string;
+} | {
+    rotated: false;
+    reason: 'disabled' | 'not-a-regular-file' | 'not-our-log' | 'under-cap' | 'error';
+    error?: string;
+};
+/**
+ * Keep daemon.log under `maxBytes` (#1207). When it is over the cap, copy it
+ * to `<logPath>.1` (replacing the previous one) and truncate it in place
+ * through the server's own descriptor, which start-daemon.cjs opened with
+ * O_APPEND, so later writes start again at offset 0 of the same file.
+ *
+ * Acts only when `logPath` is a regular file (not a symlink, #970) and is the
+ * very file one of `fds` (stdout/stderr) writes to, matched by device and
+ * inode, so it never truncates a file the server does not own. If the copy
+ * fails the log is still truncated, to keep disk use bounded. Lines written
+ * between the copy and the truncate are lost; the window is one copy long.
+ */
+export declare function rotateDaemonLog(logPath: string, maxBytes: number, fds?: readonly number[]): DaemonLogRotation;
+/**
+ * The heartbeat hook that keeps daemon.log under `maxBytes` (#1207), logging a
+ * line into the fresh log after each rotation and a warning the first time a
+ * check fails. Returns undefined when there is nothing to rotate.
+ */
+export declare function createDaemonLogRotator(logPath: string | undefined, maxBytes: number, log: (message: string) => void): (() => void) | undefined;
+//# sourceMappingURL=daemon-mode.d.ts.map

package/dist/mcp/daemon-mode.js

@@ -0,0 +1,257 @@
+/**
+ * Agentic QE v3 - MCP server daemon mode (#1158)
+ *
+ * The generated `.agentic-qe/workers/start-daemon.cjs` runs the MCP server as
+ * a detached background process with no stdin (`stdio: 'ignore'`), only to
+ * host the worker daemon. The #513 guard treats stdin EOF as "the client is
+ * gone" and shuts the server down, so that daemon used to exit within
+ * seconds of starting.
+ *
+ * `AQE_MCP_DAEMON=1` selects daemon mode. It changes exactly one thing: stdin
+ * EOF/close no longer shuts the server down, and a ref'd heartbeat timer keeps
+ * the process alive (worker timers are unref'd, also #513). The server then
+ * stops only on SIGTERM/SIGINT (what `stop-daemon.cjs` sends), the JSON-RPC
+ * `shutdown` method, or a crash.
+ *
+ * Safety: daemon mode is honoured only when stdin is NOT a pipe or socket. An
+ * MCP client always talks to the server over a pipe/socket, so an
+ * `AQE_MCP_DAEMON` that leaks into a client's environment cannot turn its
+ * server into an orphan that outlives the client: the #513 guard stays on and
+ * a warning is logged. The variable is also removed from `process.env` once
+ * read, so processes the server spawns do not inherit it.
+ *
+ * Log size (#1207): the server's stdout/stderr ARE daemon.log (a descriptor
+ * opened with O_APPEND by start-daemon.cjs), so renaming the file would not
+ * stop the writes. Instead, on each heartbeat the server copies an oversized
+ * daemon.log to daemon.log.1 and truncates daemon.log in place; with O_APPEND
+ * the next write lands at the new end of the file. start-daemon.cjs rotates an
+ * oversized log at start-up the same way (a rename, as nothing writes it then).
+ */
+import { closeSync, constants, fstatSync, ftruncateSync, lstatSync, openSync, readSync, renameSync, unlinkSync, writeSync, } from 'node:fs';
+export const DAEMON_MODE_ENV = 'AQE_MCP_DAEMON';
+/** Only these values enable daemon mode; anything else (or unset) is off. */
+const DAEMON_ON_VALUES = new Set(['1', 'true', 'yes', 'on']);
+/** Default interval of the daemon heartbeat line in daemon.log. */
+export const DEFAULT_DAEMON_HEARTBEAT_MS = 60_000;
+/** Heartbeat interval in seconds (#1207), also how often daemon.log size is checked. */
+export const DAEMON_HEARTBEAT_ENV = 'AQE_DAEMON_HEARTBEAT_SECONDS';
+const MAX_HEARTBEAT_SECONDS = 86_400;
+/** Size cap of daemon.log before it is rotated to daemon.log.1 (#1207). */
+export const DAEMON_LOG_MAX_SIZE_ENV = 'AQE_DAEMON_LOG_MAX_SIZE';
+export const DEFAULT_DAEMON_LOG_MAX_BYTES = 5 * 1024 * 1024;
+const MIN_DAEMON_LOG_MAX_BYTES = 1024;
+/**
+ * Absolute path of daemon.log, set by start-daemon.cjs for the server it
+ * starts. Internal: the server rotates the log only when this file is the one
+ * its stdout/stderr write to.
+ */
+export const DAEMON_LOG_PATH_ENV = 'AQE_MCP_DAEMON_LOG';
+const OFF_VALUES = new Set(['0', 'off', 'false', 'no', 'none', 'disable', 'disabled']);
+const SIZE_UNITS = { '': 1, k: 1024, m: 1024 ** 2, g: 1024 ** 3 };
+/**
+ * Parse `AQE_DAEMON_LOG_MAX_SIZE`: bytes, or a number with a K, M or G suffix
+ * (binary units, optional trailing B). `0`/`off` disables rotation (value 0).
+ * Unset, empty or invalid values fall back to the 5 MB default.
+ */
+export function parseDaemonLogMaxBytes(raw) {
+    const text = (raw ?? '').trim().toLowerCase();
+    if (text === '')
+        return { value: DEFAULT_DAEMON_LOG_MAX_BYTES };
+    if (OFF_VALUES.has(text))
+        return { value: 0 };
+    const match = /^(\d+)\s*([kmg]?)b?$/.exec(text);
+    const bytes = match ? Number(match[1]) * SIZE_UNITS[match[2]] : NaN;
+    if (Number.isSafeInteger(bytes) && bytes >= MIN_DAEMON_LOG_MAX_BYTES)
+        return { value: bytes };
+    return {
+        value: DEFAULT_DAEMON_LOG_MAX_BYTES,
+        warning: `[AQE] WARN ${DAEMON_LOG_MAX_SIZE_ENV}=${JSON.stringify(raw)} ignored: expected bytes ` +
+            `(at least ${MIN_DAEMON_LOG_MAX_BYTES}) or a size such as 512K or 5M; using 5M\n`,
+    };
+}
+/** Parse `AQE_DAEMON_HEARTBEAT_SECONDS` (whole seconds, 1 to 86400) into milliseconds. */
+export function parseDaemonHeartbeatMs(raw) {
+    const text = (raw ?? '').trim();
+    if (text === '')
+        return { value: DEFAULT_DAEMON_HEARTBEAT_MS };
+    const seconds = /^\d+$/.test(text) ? Number(text) : NaN;
+    if (seconds >= 1 && seconds <= MAX_HEARTBEAT_SECONDS)
+        return { value: seconds * 1000 };
+    return {
+        value: DEFAULT_DAEMON_HEARTBEAT_MS,
+        warning: `[AQE] WARN ${DAEMON_HEARTBEAT_ENV}=${JSON.stringify(raw)} ignored: expected whole ` +
+            `seconds from 1 to ${MAX_HEARTBEAT_SECONDS}; using 60\n`,
+    };
+}
+/** Whether the environment asks for daemon mode. */
+export function isDaemonModeRequested(env) {
+    const raw = env[DAEMON_MODE_ENV];
+    if (raw === undefined)
+        return false;
+    return DAEMON_ON_VALUES.has(raw.trim().toLowerCase());
+}
+/**
+ * Classify the process's stdin. A FIFO or socket means a client is (or was)
+ * connected; `/dev/null` (`stdio: 'ignore'`) or a regular file is 'other'.
+ */
+export function detectStdinKind(stdin = process.stdin, fd = 0) {
+    if (stdin.isTTY)
+        return 'tty';
+    try {
+        const stat = fstatSync(fd);
+        return stat.isFIFO() || stat.isSocket() ? 'pipe' : 'other';
+    }
+    catch {
+        // Unknown stdin: treat it as a client pipe so the #513 guard stays on.
+        return 'pipe';
+    }
+}
+/** Decide how the server should treat stdin EOF. Pure: no side effects. */
+export function resolveStdinGuardMode(env, stdinKind) {
+    const requested = isDaemonModeRequested(env);
+    if (stdinKind === 'tty')
+        return { mode: 'tty' };
+    if (!requested)
+        return { mode: 'stdio' };
+    if (stdinKind === 'pipe') {
+        return {
+            mode: 'stdio',
+            warning: `[AQE] WARN ${DAEMON_MODE_ENV} ignored: stdin is a pipe (an MCP client is attached), ` +
+                'so the server still shuts down when stdin closes\n',
+        };
+    }
+    return { mode: 'daemon' };
+}
+/**
+ * Keep a daemon-mode server alive and log one heartbeat line per interval.
+ * The timer is deliberately ref'd: nothing else holds the event loop open in
+ * daemon mode. `beforeBeat` runs just before each line (log rotation, #1207);
+ * an error it throws is ignored. Returns a function that stops it.
+ */
+export function startDaemonHeartbeat(log, getStatus, intervalMs = DEFAULT_DAEMON_HEARTBEAT_MS, beforeBeat) {
+    const startedAt = Date.now();
+    const timer = setInterval(() => {
+        try {
+            beforeBeat?.();
+        }
+        catch { /* never let rotation stop the heartbeat */ }
+        const uptimeS = Math.round((Date.now() - startedAt) / 1000);
+        let status;
+        try {
+            status = getStatus();
+        }
+        catch {
+            status = undefined;
+        }
+        const workers = status
+            ? `${status.totalWorkers} workers (${status.errorWorkers} in error), ` +
+                `${status.totalExecutions} runs (${status.failedExecutions} failed)`
+            : 'workers unavailable';
+        log(`[AQE] Daemon heartbeat: pid ${process.pid}, up ${uptimeS}s, ${workers}\n`);
+    }, intervalMs);
+    return () => clearInterval(timer);
+}
+/** Copy `src` to a fresh `dest`; neither path may be a symlink. */
+function copyNoFollow(src, dest, srcIno) {
+    const nofollow = constants.O_NOFOLLOW ?? 0;
+    const input = openSync(src, constants.O_RDONLY | nofollow);
+    let output;
+    try {
+        if (fstatSync(input).ino !== srcIno)
+            throw new Error('daemon.log changed while rotating');
+        try {
+            unlinkSync(dest);
+        }
+        catch { /* absent */ }
+        // O_EXCL: fails on anything already there, a symlink included.
+        output = openSync(dest, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | nofollow, 0o644);
+        const buffer = Buffer.allocUnsafe(64 * 1024);
+        let read;
+        while ((read = readSync(input, buffer, 0, buffer.length, null)) > 0) {
+            writeSync(output, buffer, 0, read);
+        }
+    }
+    finally {
+        if (output !== undefined)
+            closeSync(output);
+        closeSync(input);
+    }
+}
+/**
+ * Keep daemon.log under `maxBytes` (#1207). When it is over the cap, copy it
+ * to `<logPath>.1` (replacing the previous one) and truncate it in place
+ * through the server's own descriptor, which start-daemon.cjs opened with
+ * O_APPEND, so later writes start again at offset 0 of the same file.
+ *
+ * Acts only when `logPath` is a regular file (not a symlink, #970) and is the
+ * very file one of `fds` (stdout/stderr) writes to, matched by device and
+ * inode, so it never truncates a file the server does not own. If the copy
+ * fails the log is still truncated, to keep disk use bounded. Lines written
+ * between the copy and the truncate are lost; the window is one copy long.
+ */
+export function rotateDaemonLog(logPath, maxBytes, fds = [1, 2]) {
+    if (maxBytes <= 0)
+        return { rotated: false, reason: 'disabled' };
+    try {
+        const stat = lstatSync(logPath);
+        if (!stat.isFile())
+            return { rotated: false, reason: 'not-a-regular-file' };
+        const fd = fds.find((candidate) => {
+            try {
+                const own = fstatSync(candidate);
+                return own.dev === stat.dev && own.ino === stat.ino;
+            }
+            catch {
+                return false;
+            }
+        });
+        if (fd === undefined)
+            return { rotated: false, reason: 'not-our-log' };
+        if (stat.size <= maxBytes)
+            return { rotated: false, reason: 'under-cap' };
+        const tmp = `${logPath}.1.${process.pid}.tmp`;
+        let copyError;
+        try {
+            copyNoFollow(logPath, tmp, stat.ino);
+            renameSync(tmp, `${logPath}.1`); // replaces the old one, never follows it
+        }
+        catch (error) {
+            copyError = error instanceof Error ? error.message : String(error);
+            try {
+                unlinkSync(tmp);
+            }
+            catch { /* absent */ }
+        }
+        ftruncateSync(fd, 0);
+        return copyError === undefined
+            ? { rotated: true, bytes: stat.size, kept: true }
+            : { rotated: true, bytes: stat.size, kept: false, error: copyError };
+    }
+    catch (error) {
+        return { rotated: false, reason: 'error', error: error instanceof Error ? error.message : String(error) };
+    }
+}
+/**
+ * The heartbeat hook that keeps daemon.log under `maxBytes` (#1207), logging a
+ * line into the fresh log after each rotation and a warning the first time a
+ * check fails. Returns undefined when there is nothing to rotate.
+ */
+export function createDaemonLogRotator(logPath, maxBytes, log) {
+    if (!logPath || maxBytes <= 0)
+        return undefined;
+    let warned = false;
+    return () => {
+        const result = rotateDaemonLog(logPath, maxBytes);
+        if (result.rotated) {
+            log(result.kept
+                ? `[AQE] daemon.log rotated: ${result.bytes} bytes moved to daemon.log.1 (cap ${maxBytes})\n`
+                : `[AQE] WARN daemon.log truncated at ${result.bytes} bytes (cap ${maxBytes}); ` +
+                    `could not keep daemon.log.1: ${result.error}\n`);
+        }
+        else if (result.reason === 'error' && !warned) {
+            warned = true;
+            log(`[AQE] WARN daemon.log size check failed: ${result.error}\n`);
+        }
+    };
+}
+//# sourceMappingURL=daemon-mode.js.map

package/dist/mcp/entry.d.ts

@@ -12,6 +12,10 @@
  * Environment Variables:
  *   AQE_HTTP_PORT: Port for HTTP server (0 = disabled, default: 0)
  *   AQE_VERBOSE: Enable verbose logging
+ *   AQE_MCP_DAEMON: 1 = daemon mode (#1158): stdin EOF does not shut the
+ *     server down; only honoured when stdin is not a pipe. See daemon-mode.ts.
+ *   AQE_DAEMON_HEARTBEAT_SECONDS / AQE_DAEMON_LOG_MAX_SIZE: daemon mode only,
+ *     heartbeat interval and daemon.log size cap (#1207).
  */
 export {};
 //# sourceMappingURL=entry.d.ts.map

package/dist/mcp/entry.js

@@ -12,6 +12,10 @@
  * Environment Variables:
  *   AQE_HTTP_PORT: Port for HTTP server (0 = disabled, default: 0)
  *   AQE_VERBOSE: Enable verbose logging
+ *   AQE_MCP_DAEMON: 1 = daemon mode (#1158): stdin EOF does not shut the
+ *     server down; only honoured when stdin is not a pipe. See daemon-mode.ts.
+ *   AQE_DAEMON_HEARTBEAT_SECONDS / AQE_DAEMON_LOG_MAX_SIZE: daemon mode only,
+ *     heartbeat interval and daemon.log size cap (#1207).
  */
 import { quickStart } from './protocol-server.js';
 import { createHTTPServer } from './http-server.js';
@@ -25,7 +29,8 @@ import { initFeatureFlagsFromEnv } from '../integrations/ruvector/feature-flags.
 import { resetSharedRvfAdapter } from '../integrations/ruvector/shared-rvf-adapter.js';
 import { resetSharedRvfDualWriter } from '../integrations/ruvector/shared-rvf-dual-writer.js';
 import { claimProcessLifecycle, closeRegisteredStores } from '../kernel/process-lifecycle.js';
-import { startBackgroundWorkers } from './background-workers.js';
+import { getBackgroundWorkersState, startBackgroundWorkers } from './background-workers.js';
+import { DAEMON_HEARTBEAT_ENV, DAEMON_LOG_MAX_SIZE_ENV, DAEMON_LOG_PATH_ENV, DAEMON_MODE_ENV, createDaemonLogRotator, detectStdinKind, parseDaemonHeartbeatMs, parseDaemonLogMaxBytes, resolveStdinGuardMode, startDaemonHeartbeat, } from './daemon-mode.js';
 import { readFileSync } from 'node:fs';
 import { resolve, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -95,11 +100,15 @@ async function main() {
     // resolved, which is why `kill <pid>` appeared to be "ignored" and only
     // `kill -9` worked.
     let shuttingDown = false;
+    let stopDaemonHeartbeat = null;
+    let daemonStatus = null;
+    const daemonWarnings = [];
     const shutdown = async (reason) => {
         if (shuttingDown)
             return;
         shuttingDown = true;
         originalStderrWrite(`[AQE] Shutting down (${reason})\n`);
+        stopDaemonHeartbeat?.();
         const watchdog = setTimeout(() => {
             originalStderrWrite('[AQE] Shutdown watchdog fired — forcing exit\n');
             process.exit(0);
@@ -139,10 +148,29 @@ async function main() {
     // reaches EOF. An orphaned stdio MCP server has no parent to serve, so exit
     // instead of lingering at high CPU. Guarded to a piped stdin so an
     // interactive TTY debug session (Ctrl-D) is unaffected.
-    if (!process.stdin.isTTY) {
+    // #1158: start-daemon.cjs runs the server with no stdin and AQE_MCP_DAEMON=1;
+    // that daemon mode skips this guard (only when stdin is not a client pipe).
+    const stdinGuard = resolveStdinGuardMode(process.env, detectStdinKind(process.stdin));
+    const daemonLogPath = process.env[DAEMON_LOG_PATH_ENV];
+    delete process.env[DAEMON_MODE_ENV]; // never inherited by processes we spawn
+    delete process.env[DAEMON_LOG_PATH_ENV];
+    if (stdinGuard.mode === 'stdio') {
         process.stdin.on('end', () => { void shutdown('stdin-eof'); });
         process.stdin.on('close', () => { void shutdown('stdin-close'); });
     }
+    else if (stdinGuard.mode === 'daemon') {
+        // Worker timers are unref'd (#513), so a daemon with no stdin needs its
+        // own ref'd timer to stay up, from the start of boot; it also logs
+        // liveness to daemon.log.
+        // #1207: each heartbeat also keeps daemon.log under its size cap.
+        const heartbeat = parseDaemonHeartbeatMs(process.env[DAEMON_HEARTBEAT_ENV]);
+        const logCap = parseDaemonLogMaxBytes(process.env[DAEMON_LOG_MAX_SIZE_ENV]);
+        for (const parsed of [heartbeat, logCap])
+            if (parsed.warning)
+                daemonWarnings.push(parsed.warning);
+        const log = (message) => { originalStderrWrite(message); }; // declared further down
+        stopDaemonHeartbeat = startDaemonHeartbeat(log, () => daemonStatus?.(), heartbeat.value, createDaemonLogRotator(daemonLogPath, logCap.value, log));
+    }
     // Catch unhandled exceptions/rejections to prevent MCP connection drops
     process.on('uncaughtException', (error) => {
         process.stderr.write(`[AQE] FATAL uncaught exception: ${error.message}\n`);
@@ -334,6 +362,26 @@ async function main() {
         // IMP-10: Start background workers (heartbeat scheduler, etc.) and the
         // QualityDaemon. #1061: AQE_WORKERS_ENABLED=false skips both.
         await startBackgroundWorkers(originalStderrWrite);
+        if (stdinGuard.warning)
+            originalStderrWrite(stdinGuard.warning);
+        for (const warning of daemonWarnings)
+            originalStderrWrite(warning);
+        if (stdinGuard.mode === 'daemon') {
+            if (getBackgroundWorkersState().state !== 'disabled') {
+                const { getDaemon } = await import('../workers/daemon.js');
+                daemonStatus = () => {
+                    const health = getDaemon().getStatus().workerManager;
+                    const workers = Object.values(health.workers);
+                    return {
+                        totalWorkers: health.totalWorkers,
+                        errorWorkers: health.errorWorkers,
+                        totalExecutions: workers.reduce((sum, w) => sum + w.totalExecutions, 0),
+                        failedExecutions: workers.reduce((sum, w) => sum + w.failedExecutions, 0),
+                    };
+                };
+            }
+            originalStderrWrite(`[AQE] Daemon mode (${DAEMON_MODE_ENV}): stdin EOF ignored; stop with SIGTERM (stop-daemon.cjs)\n`);
+        }
         // Start HTTP server for AG-UI/A2A/A2UI if port is specified
         const httpPort = parseInt(process.env.AQE_HTTP_PORT || '0', 10);
         if (httpPort > 0) {

package/dist/mcp/handlers/domain-handler-configs.d.ts

@@ -148,6 +148,9 @@ export interface AccessibilityTestResult {
     score: number;
     violations: unknown[];
     warnings: unknown[];
+    /** #1145: false when no page was audited; `passed` is then not a verdict and `score` is -1. */
+    measured?: boolean;
+    note?: string;
     duration: number;
     savedFiles?: string[];
     /** #933: true when result files were written; see savedFiles for their paths. */
@@ -247,6 +250,11 @@ export interface CodeIndexResult {
         tests: number;
         toolsUsed: string[];
     };
+    /**
+     * #1224: non-fatal indexing warnings, e.g. that code search does not cover
+     * every indexed file. Absent when there are none.
+     */
+    warnings?: string[];
     /**
      * #1096: discovered paths that were not indexed (missing, not a regular
      * file, outside the project root, filtered out), with the reason. Absent

package/dist/mcp/handlers/domain-handler-configs.js

@@ -455,6 +455,11 @@ export const coverageAnalyzeConfig = {
             ...(data.runStatus === 'passed' || data.runStatus === 'failed' ? { runStatus: data.runStatus } : {}),
             // #995: the target has no measurement at all — distinct from a measured 0%.
             ...(data.unmeasured === true ? { unmeasured: true } : {}),
+            // #1154: target files the report does not cover, and a stale report.
+            ...(data.evidenceStatus === 'complete' || data.evidenceStatus === 'insufficient-evidence'
+                ? { evidenceStatus: data.evidenceStatus } : {}),
+            ...(Array.isArray(data.unmeasuredFiles) ? { unmeasuredFiles: data.unmeasuredFiles } : {}),
+            ...(data.staleReport ? { staleReport: data.staleReport } : {}),
             ...(data.warning ? { warning: data.warning } : {}),
         };
     },
@@ -682,11 +687,15 @@ export const accessibilityTestConfig = {
     }),
     mapToResult: (taskId, data, duration, savedFiles) => ({
         taskId,
-        status: 'completed',
+        status: data.measured === true ? 'completed' : 'not-measured',
         passed: data.passed || false,
-        score: data.score || 0,
+        // #1145: an unmeasured score is -1, never a 0/100 grade
+        score: data.measured === true && typeof data.score === 'number' ? data.score : -1,
         violations: data.violations || [],
         warnings: data.warnings || [],
+        // #1145: fail closed; only an explicit measurement counts as one
+        measured: data.measured === true,
+        ...(typeof data.note === 'string' ? { note: data.note } : {}),
         duration,
         savedFiles,
     }),
@@ -808,6 +817,9 @@ export const codeIndexConfig = {
         symbolsExtracted: data.symbolsExtracted || 0,
         relationsFound: data.relationsFound || 0,
         ...(data.projectMetrics ? { projectMetrics: data.projectMetrics } : {}),
+        ...(Array.isArray(data.warnings) && data.warnings.length > 0
+            ? { warnings: data.warnings }
+            : {}),
         ...(Array.isArray(data.skipped) && data.skipped.length > 0
             ? { skipped: data.skipped }
             : {}),

package/dist/mcp/handlers/handler-factory.js

@@ -224,6 +224,9 @@ async function recordDomainFeedback(domain, data, durationMs, params) {
                 coverageMethod: data.coverageMethod ?? 'instrumented-report',
                 branchDataCollected: data.branchCoverage !== null && data.branchCoverage !== undefined,
                 functionDataCollected: data.functionCoverage !== null && data.functionCoverage !== undefined,
+                // #1030: coverage from a run whose tests failed says so, as
+                // coverage:latest and the per-file records already do (#1027 N4).
+                ...(data.runStatus === 'passed' || data.runStatus === 'failed' ? { runStatus: data.runStatus } : {}),
             },
         };
         await loop.recordCoverageSession(session);

package/dist/mcp/handlers/model-route-handlers.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Agentic QE v3 - Model routing MCP handlers (ADR-051)
+ * Routing decisions, routing metrics and routing economics.
+ */
+import type { ToolResult } from '../types';
+import { type RoutingLogEntry, type RoutingStats } from '../services/task-router';
+import type { ModelTier } from '../../integrations/agentic-flow';
+export interface ModelRouteParams {
+    /** Task description to analyze */
+    task: string;
+    /** Optional code context for complexity analysis */
+    codeContext?: string;
+    /** Optional file paths */
+    filePaths?: string[];
+    /** Manual tier override */
+    manualTier?: ModelTier;
+    /** Mark as critical task */
+    isCritical?: boolean;
+    /** Agent type making the request */
+    agentType?: string;
+    /** Domain context */
+    domain?: string;
+}
+export interface ModelRouteResult {
+    tier: ModelTier;
+    tierName: string;
+    modelId: string;
+    executionStrategy: string;
+    useAgentBooster: boolean;
+    agentBoosterTransform?: string;
+    complexity: {
+        overall: number;
+        code: number;
+        reasoning: number;
+        scope: number;
+    };
+    confidence: number;
+    rationale: string;
+    warnings: string[];
+    budget: {
+        allowed: boolean;
+        wasDowngraded: boolean;
+        estimatedCostUsd: number;
+    };
+    decisionTimeMs: number;
+}
+/**
+ * Handle model routing query - returns routing decision without submitting task
+ */
+export declare function handleModelRoute(params: ModelRouteParams): Promise<ToolResult<ModelRouteResult>>;
+export interface RoutingMetricsParams {
+    /** Include routing log entries */
+    includeLog?: boolean;
+    /** Max log entries to return */
+    logLimit?: number;
+}
+export interface RoutingMetricsResult {
+    stats: RoutingStats;
+    log?: RoutingLogEntry[];
+    modelRouterMetrics: {
+        totalDecisions: number;
+        avgDecisionTimeMs: number;
+        agentBoosterStats: {
+            eligible: number;
+            used: number;
+            successRate: number;
+        };
+        budgetStats: {
+            totalSpentUsd: number;
+            budgetUtilization: number;
+            downgradeCount: number;
+        };
+    };
+}
+/**
+ * Handle routing metrics query
+ */
+export declare function handleRoutingMetrics(params: RoutingMetricsParams): Promise<ToolResult<RoutingMetricsResult>>;
+export interface RoutingEconomicsParams {
+    /** Task complexity score 0-1 for tier scoring (default: 0.5) */
+    taskComplexity?: number;
+}
+export interface RoutingEconomicsResult {
+    tierEfficiency: Array<{
+        tier: string;
+        qualityScore: number;
+        estimatedCostUsd: number;
+        qualityPerDollar: number | string;
+        economicScore: number;
+    }>;
+    currentHourlyCostUsd: number;
+    currentDailyCostUsd: number;
+    budgetRemaining: {
+        hourly: number | null;
+        daily: number | null;
+    };
+    recommendation: string;
+    savingsOpportunity: {
+        usd: number;
+        description: string;
+    } | null;
+}
+/**
+ * Handle economic routing report query
+ */
+export declare function handleRoutingEconomics(params: RoutingEconomicsParams): Promise<ToolResult<RoutingEconomicsResult>>;
+//# sourceMappingURL=model-route-handlers.d.ts.map