agentic-qe 3.15.11 → 3.15.12

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.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 } : {}),
         };
     },

package/dist/mcp/handlers/orchestrate-routes.d.ts

@@ -15,12 +15,17 @@ export interface OrchestrateRequest {
     filePaths?: string[];
 }
 export type OrchestrateRoute = 
-/** Submit `type` to `domain` with `payload`. */
+/**
+ * Submit `type` to `domain` with `payload`. `executionOwner: 'caller'` runs
+ * the task through the MCP task executor, as the domain's own tool does,
+ * instead of the domain plugin.
+ */
 {
     kind: 'route';
     type: string;
     domain: DomainName;
     payload: Record<string, unknown>;
+    executionOwner?: 'caller';
 }
 /** The request lacks what the handler needs; `error` says what to supply. */
  | {

package/dist/mcp/handlers/orchestrate-routes.js

@@ -8,8 +8,11 @@
  * supplied, or is refused with the input it needs. A payload is never filled
  * with values the request did not contain.
  */
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
 import { findProjectRoot } from '../../kernel/project-root.js';
 import { confineIndexPaths } from '../../domains/code-intelligence/index-path-guard.js';
+import { requirePayloadPath } from '../../shared/io/payload-path-guard.js';
 const needs = (type, what) => ({
     kind: 'needs-input',
     error: `task_orchestrate inferred '${type}' from the description, but ${what}`,
@@ -26,6 +29,52 @@ async function projectFiles(type, filePaths) {
     }
     return { files: accepted };
 }
+/** Source and report extensions that mark a bare word in a description as a file. */
+const PATH_EXTENSION = /\.(?:[cm]?[jt]sx?|py|go|rs|java|kt|cs|rb|php|swift|info|lcov|json|xml)$/i;
+/** Words after which a description names what to measure ("coverage for src"). */
+const TARGET_PREPOSITION = /^(?:for|of|in|under|on)$/i;
+/**
+ * The paths a description names: words with a path separator or a source /
+ * report extension, else a word after "for/of/in/under/on" that exists
+ * (`analyze coverage for src`). Anything else is prose.
+ */
+function pathsInDescription(task) {
+    const words = task.split(/\s+/).map(w => w.replace(/^[`'"(]+|[`'",;:!?)]+$|\.$/g, '')).filter(Boolean);
+    const pathLike = words.filter(w => !/^https?:/i.test(w) && (/[\\/]/.test(w) || PATH_EXTENSION.test(w)));
+    if (pathLike.length > 0)
+        return [...new Set(pathLike)];
+    // Resolved as the coverage handler resolves its target: from the cwd.
+    const named = words.filter((w, i) => i > 0 && TARGET_PREPOSITION.test(words[i - 1]) &&
+        /^[\w.-]+$/.test(w) && existsSync(resolve(w)));
+    return [...new Set(named)];
+}
+/**
+ * #1200: the one target an orchestrated coverage task measures — the single
+ * filePath, else the one path the description names, else '.' (the default
+ * of coverage_analyze_sublinear).
+ * The task then runs the handler coverage_analyze_sublinear runs, so it
+ * resolves the target, reads the report and judges its evidence the same way.
+ */
+async function coverageRoute(request) {
+    const type = 'analyze-coverage';
+    const given = request.filePaths ?? [];
+    const candidates = given.length > 0 ? given : pathsInDescription(request.task);
+    if (candidates.length > 1) {
+        return needs(type, `coverage is analyzed for one target, and ${given.length > 0 ? 'filePaths' : 'the description'} ` +
+            `names ${candidates.length} (${candidates.join(', ')}). Pass one file or directory, or use ` +
+            'coverage_analyze_sublinear with a target.');
+    }
+    const target = candidates[0] ?? '.';
+    if (target !== '.') {
+        const confined = await requirePayloadPath(type, 'target', target, { allowDirectory: true, allowMissing: true });
+        if (!confined.success)
+            return needs(type, `the ${confined.error.message.replace(/^Invalid [\w-]+ payload: /, '')}`);
+    }
+    return {
+        kind: 'route', type, domain: 'coverage-analysis', executionOwner: 'caller',
+        payload: { target, detectGaps: true },
+    };
+}
 /** Decide how task_orchestrate runs an inferred task type. */
 export async function routeInferredTask(type, request) {
     const filePaths = request.filePaths ?? [];
@@ -59,6 +108,10 @@ export async function routeInferredTask(type, request) {
                 return confined;
             return { kind: 'route', type: 'analyze-quality', domain: 'quality-assessment', payload: { sourceFiles: confined.files } };
         }
+        case 'analyze-coverage':
+            // #1200: the domain plugin's handler needs coverageData, which a
+            // description never carries; the coverage tool's handler finds it.
+            return coverageRoute(request);
         case 'test-accessibility':
             // run-accessibility-audit falls back to URL-pattern heuristics when no
             // browser is available, which reports violations nobody measured.

package/dist/mcp/handlers/task-handlers.d.ts

@@ -8,7 +8,9 @@
 import { ToolResult, TaskSubmitParams, TaskSubmitResult, TaskListParams, TaskStatusParams, TaskStatusResult, TaskCancelParams } from '../types';
 import { TaskType } from '../../coordination/queen-coordinator';
 import { type RoutingLogEntry, type RoutingStats } from '../services/task-router';
+import type { ExperienceGuidanceStatus } from '../../integrations/agentic-flow/reasoning-bank/index.js';
 import type { ModelTier } from '../../integrations/agentic-flow';
+import { type Priority } from '../../shared/types/index.js';
 export declare function handleTaskSubmit(params: TaskSubmitParams): Promise<ToolResult<TaskSubmitResult>>;
 export declare function handleTaskList(params: TaskListParams): Promise<ToolResult<TaskStatusResult[]>>;
 export declare function handleTaskStatus(params: TaskStatusParams): Promise<ToolResult<TaskStatusResult>>;
@@ -20,7 +22,8 @@ export declare function handleTaskCancel(params: TaskCancelParams): Promise<Tool
 export interface TaskOrchestrateParams {
     task: string;
     strategy?: 'parallel' | 'sequential' | 'adaptive';
-    priority?: 'low' | 'medium' | 'high' | 'critical';
+    /** Named levels, or a canonical p0-p3 priority (p0 stays p0). */
+    priority?: 'low' | 'medium' | 'high' | 'critical' | Priority;
     maxAgents?: number;
     /** Manual tier override (0-4) */
     manualTier?: ModelTier;
@@ -38,13 +41,19 @@ export interface TaskOrchestrateParams {
 /**
  * #1022: how learned patterns informed task_orchestrate.
  * - 'vector': embedding similarity plus text matching
- * - 'lexical-only': no embedding runtime; text matching only, no similarity
+ * - 'lexical-only': no working embedder (absent, or failed at runtime, #1187);
+ *   text matching only, no similarity
  *   scores, and experience guidance unavailable
  * - 'unavailable': the ReasoningBank could not start; no learned guidance
+ *
+ * #1204: `experienceGuidance` says the same for similar-experience guidance:
+ * 'unavailable' (with the reason) when its embedder failed or is absent.
+ * Omitted when experience replay is disabled or the ReasoningBank is down.
  */
 export interface OrchestrateLearningStatus {
     patternSearch: 'vector' | 'lexical-only' | 'unavailable';
     reason?: string;
+    experienceGuidance?: ExperienceGuidanceStatus;
 }
 export interface TaskOrchestrateResult {
     taskId: string;