@alfe.ai/gateway 0.3.2 → 0.5.0

package/dist/bin/gateway.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { a as installService, c as uninstallService, i as checkExistingDaemon, n as queryDaemonHealth, r as startDaemon, s as stopExistingDaemon, t as formatHealthReport, y as SOCKET_PATH } from "../health.js";
+import { a as installService, c as uninstallService, i as checkExistingDaemon, n as queryDaemonHealth, r as startDaemon, s as stopExistingDaemon, t as formatHealthReport, w as SOCKET_PATH } from "../health.js";
 import { t as LOG_FILE } from "../logger.js";
 import { spawn } from "node:child_process";
 //#region bin/gateway.ts

package/dist/health.js

@@ -5266,7 +5266,7 @@ function isIPCResponse(msg) {
 const PROTOCOL_VERSION = 1;
 //#endregion
 //#region src/runtime-gate.ts
-const log$3 = logger$1.child({ component: "RuntimeGate" });
+const log$4 = logger$1.child({ component: "RuntimeGate" });
 var RuntimeGate = class {
 	depth = 0;
 	wasRunning = false;
@@ -5284,7 +5284,7 @@ var RuntimeGate = class {
 		const rp = this.getRuntime();
 		this.wasRunning = rp?.isRunning ?? false;
 		if (rp && this.wasRunning) {
-			log$3.info("Suspending runtime for mutating reconcile (avoid concurrent SQLite writers)");
+			log$4.info("Suspending runtime for mutating reconcile (avoid concurrent SQLite writers)");
 			await rp.stop();
 		}
 	}
@@ -5299,7 +5299,7 @@ var RuntimeGate = class {
 		if (this.depth < 0) this.depth = 0;
 		const rp = this.getRuntime();
 		if (rp && this.wasRunning) {
-			log$3.info("Resuming runtime after mutating reconcile");
+			log$4.info("Resuming runtime after mutating reconcile");
 			rp.resume();
 		}
 		this.wasRunning = false;
@@ -5314,12 +5314,12 @@ var RuntimeGate = class {
 	*/
 	requestRestart() {
 		if (this.depth > 0) {
-			log$3.info("Runtime restart requested while suspended — deferring to pending resume");
+			log$4.info("Runtime restart requested while suspended — deferring to pending resume");
 			return;
 		}
 		const rp = this.getRuntime();
 		if (rp) rp.restart().catch((err) => {
-			log$3.error({ err: err instanceof Error ? err.message : String(err) }, "Failed to restart runtime");
+			log$4.error({ err: err instanceof Error ? err.message : String(err) }, "Failed to restart runtime");
 		});
 	}
 };
@@ -5366,14 +5366,40 @@ var NoopRuntimeGate = class {
 * both places.
 */
 const AGENT_DAEMON_SENTRY_DSN = "https://a47f010d8d39fb4350f913492189f283@o4511008239452160.ingest.us.sentry.io/4511679448547328";
+const CLI_SENTRY_DSN = "https://82dde4631336561f2fcc89d7531623de@o4511008239452160.ingest.us.sentry.io/4511679411191808";
+/**
+* Dedicated project for errors emitted BY the agent runtime child process
+* (OpenClaw/Hermes) — crashes, spawn failures, and error-looking output. Kept
+* separate from `agent-daemon` so runtime noise never drowns daemon issues.
+* Mirrors `SENTRY_DSNS.agentRuntime` in `config/config.ts`.
+*/
+const AGENT_RUNTIME_SENTRY_DSN = "https://feb7fb2e3b8e723aec518e74715bfa6d@o4511008239452160.ingest.us.sentry.io/4511683667558400";
+/**
+* MCP tool/server failures on agent VMs — reported by the daemon-hosted MCP
+* bundler (tool errors, child crashes, stderr output). This is the SAME
+* project as the cloud MCP Fly service (`SENTRY_DSNS.mcp`); agent-side events
+* are distinguished by `source: agent-daemon` + `agentId` tags.
+*/
+const AGENT_MCP_SENTRY_DSN = "https://638309eac96146a945f46b578f10c806@o4511008239452160.ingest.us.sentry.io/4511146364174336";
 /** Surface → Sentry project: `cli` and `agent-daemon` respectively. */
 const SURFACE_DSNS = {
-	cli: "https://82dde4631336561f2fcc89d7531623de@o4511008239452160.ingest.us.sentry.io/4511679411191808",
+	cli: CLI_SENTRY_DSN,
 	daemon: AGENT_DAEMON_SENTRY_DSN
 };
 /** Held after a successful init so the capture helpers can run synchronously. */
 let sentry = null;
 /**
+* Additional bound clients (daemon surface only). The default client keeps the
+* daemon's own DSN; runtime child-process events and MCP failures are routed
+* to their own projects via explicitly-bound Scopes — the documented
+* multi-client pattern. `null` until `initAgentSentry({ surface: "daemon" })`
+* succeeds.
+*/
+let runtimeClient = null;
+let runtimeScope = null;
+let mcpClient = null;
+let mcpScope = null;
+/**
 * Map the configured API URL to a coarse environment tag. Best-effort — returns
 * `"unknown"` when no config is present yet (e.g. `alfe login` pre-setup).
 */
@@ -5404,12 +5430,13 @@ function errorReportingDisabled() {
 	} catch {}
 	return false;
 }
-const KV_SECRET_RE = /\b(authorization|api[_-]?key|apikey|token|secret|password|passwd|bearer)\b(\s*[:=]\s*|\s+)("?)([^\s"']+)\3/gi;
+const KV_SECRET_RE = /(?<![A-Za-z0-9])([A-Za-z0-9_-]*(?:authorization|api[_-]?key|apikey|token|secret|password|passwd|bearer|credential)s?)(\s*[:=]\s*|\s+)("?)([^\s"']+)\3/gi;
+const URL_QUERY_SECRET_RE = /([?&](?:[A-Za-z0-9_-]*(?:token|secret|key|signature|credential|password)|sig|code|x-amz-[a-z-]+)=)[^&\s"']+/gi;
 const MIN_BARE_SECRET_LEN = 16;
 const ALFE_TOKEN_RE = /alfe_(?:dev|test|demo|live)_[A-Za-z0-9._-]+/g;
 const BEARER_RE = /\bbearer\s+[A-Za-z0-9._\-+/=]+/gi;
 function scrubString(value) {
-	return value.replace(BEARER_RE, "Bearer [REDACTED]").replace(KV_SECRET_RE, (match, label, sep, _q, secret) => {
+	return value.replace(BEARER_RE, "Bearer [REDACTED]").replace(URL_QUERY_SECRET_RE, "$1[REDACTED]").replace(KV_SECRET_RE, (match, label, sep, _q, secret) => {
 		if (!/[:=]/.test(sep) && secret.length < MIN_BARE_SECRET_LEN) return match;
 		return `${label}${sep}[REDACTED]`;
 	}).replace(ALFE_TOKEN_RE, "alfe_[REDACTED]");
@@ -5453,6 +5480,47 @@ async function initAgentSentry(options) {
 		const dsn = SURFACE_DSNS[options.surface].trim();
 		if (!dsn) return;
 		const mod = await import("@sentry/node");
+		if (options.surface === "daemon") {
+			const buildBoundScope = (dsn, extraTags) => {
+				try {
+					if (!dsn.trim()) return null;
+					const client = new mod.NodeClient({
+						dsn: dsn.trim(),
+						environment: deriveEnvironment(),
+						...options.release ? { release: options.release } : {},
+						sampleRate: 1,
+						tracesSampleRate: 0,
+						sendDefaultPii: false,
+						transport: mod.makeNodeTransport,
+						stackParser: mod.defaultStackParser,
+						integrations: [],
+						beforeSend: (event) => scrubEvent(event)
+					});
+					client.init();
+					const scope = new mod.Scope();
+					scope.setClient(client);
+					const runtime = deriveRuntime();
+					if (runtime) scope.setTag("runtime", runtime);
+					for (const [k, v] of Object.entries(extraTags)) scope.setTag(k, v);
+					return {
+						client,
+						scope
+					};
+				} catch {
+					return null;
+				}
+			};
+			if (!runtimeScope) {
+				const bound = buildBoundScope(AGENT_RUNTIME_SENTRY_DSN, {});
+				runtimeClient = bound?.client ?? null;
+				runtimeScope = bound?.scope ?? null;
+			}
+			if (!mcpScope) {
+				const bound = buildBoundScope(AGENT_MCP_SENTRY_DSN, { source: "agent-daemon" });
+				mcpClient = bound?.client ?? null;
+				mcpScope = bound?.scope ?? null;
+			}
+		}
 		if (mod.getClient()) {
 			sentry = mod;
 			return;
@@ -5464,6 +5532,7 @@ async function initAgentSentry(options) {
 			sampleRate: 1,
 			tracesSampleRate: 0,
 			sendDefaultPii: false,
+			...options.surface === "daemon" ? { integrations: (defaults) => defaults.filter((i) => i.name !== "OnUncaughtException" && i.name !== "OnUnhandledRejection") } : {},
 			beforeSend: (event) => scrubEvent(event),
 			beforeBreadcrumb: (breadcrumb) => scrubBreadcrumb(breadcrumb)
 		});
@@ -5482,8 +5551,15 @@ async function initAgentSentry(options) {
 function setAgentContext(context) {
 	if (!sentry) return;
 	try {
-		if (context.agentId) sentry.setTag("agentId", context.agentId);
-		if (context.runtime) sentry.setTag("runtime", context.runtime);
+		for (const scope of [
+			sentry,
+			runtimeScope,
+			mcpScope
+		]) {
+			if (!scope) continue;
+			if (context.agentId) scope.setTag("agentId", context.agentId);
+			if (context.runtime) scope.setTag("runtime", context.runtime);
+		}
 	} catch {}
 }
 /**
@@ -5528,8 +5604,105 @@ function captureCliFailure(context, cause) {
 		});
 	} catch {}
 }
+/**
+* Capture a runtime child-process crash (non-graceful exit) or spawn failure
+* into the dedicated `agent-runtime` project. Recent output travels as
+* breadcrumbs — NEVER `extra`, which `scrubEvent` (the runtime client's
+* `beforeSend`) deletes. Throttling is the caller's job (`CaptureThrottle` in
+* `runtime-output-monitor.ts`). No-op when the runtime client is not
+* initialised. Never throws.
+*/
+function captureRuntimeCrash(opts) {
+	if (!runtimeScope) return;
+	try {
+		const scope = runtimeScope.clone();
+		for (const { stream, line } of opts.recentOutput) scope.addBreadcrumb({
+			category: `runtime.${stream}`,
+			level: stream === "stderr" ? "warning" : "info",
+			message: line
+		});
+		const crashKey = opts.spawnError ? `spawn:${opts.spawnError.code ?? "error"}` : String(opts.code ?? opts.signal ?? "unknown");
+		scope.setFingerprint([
+			"runtime-crash",
+			opts.runtime,
+			crashKey
+		]);
+		scope.setTags({
+			runtime: opts.runtime,
+			exitCode: String(opts.code),
+			signal: String(opts.signal),
+			crashesSuppressed: String(opts.crashesSuppressed ?? 0)
+		});
+		if (opts.spawnError) scope.captureException(opts.spawnError);
+		else scope.captureMessage(`Runtime ${opts.runtime} crashed (code=${String(opts.code)}, signal=${String(opts.signal)})`, "error");
+	} catch {}
+}
+/**
+* Capture an error-looking block of runtime output (stack trace, Python
+* traceback, or ERROR-level log line) detected while the child is running.
+* The block lines travel as breadcrumbs; the head line is the message.
+* Throttling/dedupe is the caller's job. No-op when Sentry is not initialised.
+* Never throws.
+*/
+function captureRuntimeErrorOutput(opts) {
+	if (!runtimeScope) return;
+	try {
+		const scope = runtimeScope.clone();
+		for (const line of opts.lines) scope.addBreadcrumb({
+			category: `runtime.${opts.stream}`,
+			level: "error",
+			message: line
+		});
+		scope.setFingerprint([
+			"runtime-output",
+			opts.runtime,
+			opts.kind,
+			opts.fingerprintKey
+		]);
+		scope.setTags({
+			runtime: opts.runtime,
+			stream: opts.stream,
+			kind: opts.kind,
+			suppressedCount: String(opts.suppressedCount ?? 0)
+		});
+		scope.captureMessage(opts.lines[0].slice(0, 300), "error");
+	} catch {}
+}
+/**
+* Capture an MCP failure (tool error, server crash, or error-looking stderr
+* output) into the `mcp` project via the daemon's bound MCP client. Throttling
+* is the caller's job (`mcp-error-capture.ts`). No-op when the MCP client is
+* not initialised. Never throws.
+*/
+function captureMcpFailure(opts) {
+	if (!mcpScope) return;
+	try {
+		const scope = mcpScope.clone();
+		for (const line of opts.lines ?? []) scope.addBreadcrumb({
+			category: `mcp.${opts.server}`,
+			level: "error",
+			message: line
+		});
+		scope.setFingerprint([
+			"agent-mcp",
+			opts.server,
+			opts.kind,
+			...opts.tool ? [opts.tool] : []
+		]);
+		scope.setTags({
+			server: opts.server,
+			kind: opts.kind,
+			...opts.tool ? { tool: opts.tool } : {},
+			suppressedCount: String(opts.suppressedCount ?? 0)
+		});
+		scope.captureMessage(`MCP ${opts.server}${opts.tool ? `.${opts.tool}` : ""} ${opts.kind}: ${opts.message.slice(0, 300)}`, "error");
+	} catch {}
+}
 /** Flush queued events (small timeout) so short-lived commands deliver them. */
 async function flushSentry(timeoutMs = 2e3) {
+	for (const client of [runtimeClient, mcpClient]) try {
+		if (client) await client.flush(timeoutMs);
+	} catch {}
 	if (!sentry) return;
 	try {
 		await sentry.flush(timeoutMs);
@@ -5548,7 +5721,7 @@ function captureFatal(cause) {
 }
 //#endregion
 //#region src/reconciliation.ts
-const log$2 = logger$1.child({ component: "Reconciliation" });
+const log$3 = logger$1.child({ component: "Reconciliation" });
 /**
 * How many times reconcile will re-attempt activation of an intact integration
 * stuck in `error` (with no reinstall requested) before giving up and waiting
@@ -5618,7 +5791,7 @@ var ReconciliationEngine = class {
 		try {
 			localIntegrations = await this.manager.getInstalledIntegrations();
 		} catch (err) {
-			log$2.error({ err }, "Failed to get local integrations");
+			log$3.error({ err }, "Failed to get local integrations");
 			localIntegrations = [];
 		}
 		const localMap = new Map(localIntegrations.map((i) => [i.id, i]));
@@ -5637,10 +5810,10 @@ var ReconciliationEngine = class {
 		try {
 			if (!local) {
 				await this.ensureSuspended();
-				log$2.info(`Installing ${id}@${desired.version}`);
+				log$3.info(`Installing ${id}@${desired.version}`);
 				await this.manager.install(id, desired.version, desired.config, desired.customSource);
 				report.installed.push(id);
-				log$2.info(`Activating ${id}`);
+				log$3.info(`Activating ${id}`);
 				if ((await this.manager.activate(id)).configApplied) report.configApplied = true;
 				report.activated.push(id);
 				report.results.push({
@@ -5652,7 +5825,7 @@ var ReconciliationEngine = class {
 			}
 			if (local.version !== desired.version && desired.version !== "" && local.version !== "unknown") {
 				await this.ensureSuspended();
-				log$2.info(`Upgrading ${id}: ${local.version} → ${desired.version}`);
+				log$3.info(`Upgrading ${id}: ${local.version} → ${desired.version}`);
 				if ((await this.manager.reinstall(id, desired.version, desired.config, desired.customSource)).configApplied) report.configApplied = true;
 				report.installed.push(id);
 				report.activated.push(id);
@@ -5666,7 +5839,7 @@ var ReconciliationEngine = class {
 			if (local.status === "error") {
 				if (desired.reinstallRequestedAt && local.installedAt && desired.reinstallRequestedAt > local.installedAt) {
 					await this.ensureSuspended();
-					log$2.info(`Reinstalling ${id} from error state (requested: ${desired.reinstallRequestedAt}, installed: ${local.installedAt})`);
+					log$3.info(`Reinstalling ${id} from error state (requested: ${desired.reinstallRequestedAt}, installed: ${local.installedAt})`);
 					this.manager.resetReinstallAttempts(id);
 					this.activateAttempts.delete(id);
 					if ((await this.manager.reinstall(id, desired.version, desired.config, desired.customSource)).configApplied) report.configApplied = true;
@@ -5682,7 +5855,7 @@ var ReconciliationEngine = class {
 				if (!await this.manager.isInstallIntact(id)) {
 					const attempts = this.manager.getReinstallAttempts(id);
 					if (attempts >= 3) {
-						log$2.error(`Auto-reinstall blocked for ${id} — ${String(attempts)} consecutive failures. Manual reinstall required.`);
+						log$3.error(`Auto-reinstall blocked for ${id} — ${String(attempts)} consecutive failures. Manual reinstall required.`);
 						captureIntegrationFailure(id, "reinstall", `Max auto-reinstall attempts (${String(attempts)}) reached — manual reinstall required`);
 						report.errors.push({
 							integrationId: id,
@@ -5697,7 +5870,7 @@ var ReconciliationEngine = class {
 						return;
 					}
 					await this.ensureSuspended();
-					log$2.info(`Auto-reinstalling ${id} — install directory is corrupted or missing (attempt ${String(attempts + 1)}/3)`);
+					log$3.info(`Auto-reinstalling ${id} — install directory is corrupted or missing (attempt ${String(attempts + 1)}/3)`);
 					this.manager.incrementReinstallAttempts(id);
 					try {
 						if ((await this.manager.reinstall(id, desired.version, desired.config, desired.customSource)).configApplied) report.configApplied = true;
@@ -5712,7 +5885,7 @@ var ReconciliationEngine = class {
 						});
 					} catch (reinstallErr) {
 						const reinstallMsg = reinstallErr instanceof Error ? reinstallErr.message : String(reinstallErr);
-						log$2.error({ err: reinstallErr }, `Auto-reinstall failed for ${id}`);
+						log$3.error({ err: reinstallErr }, `Auto-reinstall failed for ${id}`);
 						captureIntegrationFailure(id, "reinstall", reinstallErr);
 						report.errors.push({
 							integrationId: id,
@@ -5731,7 +5904,7 @@ var ReconciliationEngine = class {
 				if (activateAttempts < MAX_ERROR_ACTIVATE_ATTEMPTS) {
 					this.activateAttempts.set(id, activateAttempts + 1);
 					await this.ensureSuspended();
-					log$2.info(`Re-activating ${id} from error state (attempt ${String(activateAttempts + 1)}/${String(MAX_ERROR_ACTIVATE_ATTEMPTS)})`);
+					log$3.info(`Re-activating ${id} from error state (attempt ${String(activateAttempts + 1)}/${String(MAX_ERROR_ACTIVATE_ATTEMPTS)})`);
 					try {
 						if ((await this.manager.activate(id)).configApplied) report.configApplied = true;
 						this.activateAttempts.delete(id);
@@ -5744,7 +5917,7 @@ var ReconciliationEngine = class {
 						return;
 					} catch (reactivateErr) {
 						const reactivateMsg = reactivateErr instanceof Error ? reactivateErr.message : String(reactivateErr);
-						log$2.warn(`Re-activation of ${id} from error state failed (attempt ${String(activateAttempts + 1)}/${String(MAX_ERROR_ACTIVATE_ATTEMPTS)}): ${reactivateMsg}`);
+						log$3.warn(`Re-activation of ${id} from error state failed (attempt ${String(activateAttempts + 1)}/${String(MAX_ERROR_ACTIVATE_ATTEMPTS)}): ${reactivateMsg}`);
 						captureIntegrationFailure(id, "reactivate", reactivateErr);
 						report.errors.push({
 							integrationId: id,
@@ -5759,7 +5932,7 @@ var ReconciliationEngine = class {
 						return;
 					}
 				}
-				log$2.warn(`Integration ${id} is in error state — re-activation exhausted, waiting for reinstall request`);
+				log$3.warn(`Integration ${id} is in error state — re-activation exhausted, waiting for reinstall request`);
 				captureIntegrationFailure(id, "reactivate", `Integration ${id} stuck in error state — re-activation attempts exhausted`);
 				report.errors.push({
 					integrationId: id,
@@ -5775,7 +5948,7 @@ var ReconciliationEngine = class {
 			}
 			if (local.status !== "active") {
 				await this.ensureSuspended();
-				log$2.info(`Activating ${id}`);
+				log$3.info(`Activating ${id}`);
 				if ((await this.manager.activate(id)).configApplied) report.configApplied = true;
 				report.activated.push(id);
 				report.results.push({
@@ -5787,7 +5960,7 @@ var ReconciliationEngine = class {
 			}
 			if (desired.reinstallRequestedAt && local.installedAt && desired.reinstallRequestedAt > local.installedAt) {
 				await this.ensureSuspended();
-				log$2.info(`Reinstall requested for ${id} (requested: ${desired.reinstallRequestedAt}, installed: ${local.installedAt})`);
+				log$3.info(`Reinstall requested for ${id} (requested: ${desired.reinstallRequestedAt}, installed: ${local.installedAt})`);
 				this.manager.resetReinstallAttempts(id);
 				this.activateAttempts.delete(id);
 				if ((await this.manager.reinstall(id, desired.version, desired.config, desired.customSource)).configApplied) report.configApplied = true;
@@ -5808,7 +5981,7 @@ var ReconciliationEngine = class {
 			});
 		} catch (err) {
 			const message = err instanceof Error ? err.message : String(err);
-			log$2.error({ err }, `Error reconciling ${id}`);
+			log$3.error({ err }, `Error reconciling ${id}`);
 			captureIntegrationFailure(id, "reconcile_active", err);
 			report.errors.push({
 				integrationId: id,
@@ -5833,7 +6006,7 @@ var ReconciliationEngine = class {
 		}
 		try {
 			await this.ensureSuspended();
-			log$2.info(`Removing ${id}`);
+			log$3.info(`Removing ${id}`);
 			if (local.status === "active") {
 				await this.manager.deactivate(id);
 				report.deactivated.push(id);
@@ -5847,7 +6020,7 @@ var ReconciliationEngine = class {
 			});
 		} catch (err) {
 			const message = err instanceof Error ? err.message : String(err);
-			log$2.error({ err }, `Error removing ${id}`);
+			log$3.error({ err }, `Error removing ${id}`);
 			captureIntegrationFailure(id, "reconcile_removed", err);
 			report.errors.push({
 				integrationId: id,
@@ -21980,6 +22153,177 @@ function createLogger(component, additionalData) {
 		component
 	});
 }
+const ANSI_RE = /\x1b\[[0-9;]*[A-Za-z]/g;
+function stripAnsi(line) {
+	return line.replace(ANSI_RE, "");
+}
+/** Rolling window of the child's most recent output lines (both streams). */
+var OutputRingBuffer = class {
+	lines = [];
+	push(line) {
+		this.lines.push({
+			stream: line.stream,
+			line: line.line.length > 500 ? line.line.slice(0, 500) : line.line
+		});
+		if (this.lines.length > 50) this.lines.shift();
+	}
+	/** Oldest → newest copy. */
+	snapshot() {
+		return this.lines.map((l) => ({ ...l }));
+	}
+};
+const PY_TRACEBACK_START = "Traceback (most recent call last):";
+const NODE_ERROR_HEAD = /^\s*(?:Uncaught\s+|Unhandled\w*\s+)?[A-Z][A-Za-z0-9_]*(?:Error|Exception)\b\s*[:(]/;
+const LOG_ERROR_LEVEL = /^.{0,40}(?:\[(?:ERROR|FATAL|CRITICAL)\]|\b(?:ERROR|FATAL|CRITICAL)\b\s*[:|])/;
+const JSON_ERROR_LEVEL = /"level"\s*:\s*(?:"(?:error|fatal)"|(?:50|60)\b)/;
+const NODE_FRAME = /^\s+at\s/;
+const NODE_CAUSE = /^\s*caused by:?/i;
+const NODE_CHAINED = /^\s*[A-Z][A-Za-z0-9_]*(?:Error|Exception)\b\s*:/;
+const PY_FILE = /^\s*File "/;
+const PY_INDENTED = /^\s{2,}\S/;
+const PY_TERMINAL = /^[A-Za-z_][\w.]*(?:Error|Exception|Interrupt)?:/;
+/** Digits/hex-stripped, lowercased head line — stable across timestamps/ids. */
+function toFingerprintKey(head) {
+	return head.toLowerCase().replace(/\b0x[0-9a-f]+\b/g, "<hex>").replace(/\d+/g, "<n>").trim().slice(0, 120);
+}
+function compact(blocks) {
+	return blocks.filter((b) => b !== null);
+}
+/**
+* Stateful multi-line error detector. Feed lines (per stream) as they arrive;
+* returns the blocks completed by that line (usually zero or one — two when a
+* line closes a pending block AND is itself a single-line error-log block).
+* Call `flush()` on quiet periods / process exit to complete a trailing block.
+*/
+var ErrorLineDetector = class {
+	pending = null;
+	get isCollecting() {
+		return this.pending !== null;
+	}
+	feed(stream, rawLine) {
+		const line = stripAnsi(rawLine);
+		if (this.pending) {
+			if (stream === this.pending.stream && this.isContinuation(line)) {
+				this.pending.lines.push(line);
+				if (NODE_FRAME.test(line)) this.pending.sawFrame = true;
+				if (this.pending.kind === "python-traceback" && PY_TERMINAL.test(line) && !PY_FILE.test(line) || this.pending.lines.length >= 40) return compact([this.finish()]);
+				return [];
+			}
+			return compact([this.finish(), this.startOrDetect(stream, line)]);
+		}
+		return compact([this.startOrDetect(stream, line)]);
+	}
+	/** Force-complete a pending block (debounce timeout / process exit). */
+	flush() {
+		return this.finish();
+	}
+	startOrDetect(stream, line) {
+		if (line.trim() === "") return null;
+		if (line.startsWith(PY_TRACEBACK_START)) {
+			this.pending = {
+				kind: "python-traceback",
+				stream,
+				lines: [line],
+				sawFrame: true
+			};
+			return null;
+		}
+		if (LOG_ERROR_LEVEL.test(line) || JSON_ERROR_LEVEL.test(line)) return {
+			kind: "error-log",
+			stream,
+			lines: [line.slice(0, 500)],
+			fingerprintKey: toFingerprintKey(line)
+		};
+		if (NODE_ERROR_HEAD.test(line)) {
+			this.pending = {
+				kind: "node-stack",
+				stream,
+				lines: [line],
+				sawFrame: false
+			};
+			return null;
+		}
+		return null;
+	}
+	isContinuation(line) {
+		if (!this.pending) return false;
+		if (this.pending.kind === "python-traceback") return PY_FILE.test(line) || PY_INDENTED.test(line) || PY_TERMINAL.test(line);
+		return NODE_FRAME.test(line) || NODE_CAUSE.test(line) || NODE_CHAINED.test(line);
+	}
+	finish() {
+		const pending = this.pending;
+		this.pending = null;
+		if (!pending) return null;
+		if (pending.kind === "node-stack" && !pending.sawFrame) return null;
+		return {
+			kind: pending.kind,
+			stream: pending.stream,
+			lines: pending.lines.map((l) => l.slice(0, 500)),
+			fingerprintKey: toFingerprintKey(pending.lines[0])
+		};
+	}
+};
+/**
+* Bounds Sentry quota per RuntimeProcess. Worst case per agent:
+* ≤ `ERROR_CAPTURES_MAX` output events + ≤ 1 crash event per 10-minute window.
+*/
+var CaptureThrottle = class {
+	windowStart = 0;
+	windowCount = 0;
+	errorsSuppressed = 0;
+	lastSentByKey = /* @__PURE__ */ new Map();
+	lastCrashCaptureAt = 0;
+	hasCapturedCrash = false;
+	crashesSuppressed = 0;
+	constructor(stableUptimeMs) {
+		this.stableUptimeMs = stableUptimeMs;
+	}
+	allowErrorCapture(fingerprintKey, now = Date.now()) {
+		if (now - this.windowStart >= 6e5) {
+			this.windowStart = now;
+			this.windowCount = 0;
+		}
+		const lastSent = this.lastSentByKey.get(fingerprintKey);
+		if (lastSent !== void 0 && now - lastSent < 6e5 || this.windowCount >= 5) {
+			this.errorsSuppressed++;
+			return {
+				allow: false,
+				suppressedCount: this.errorsSuppressed
+			};
+		}
+		this.windowCount++;
+		this.lastSentByKey.set(fingerprintKey, now);
+		if (this.lastSentByKey.size > 50) {
+			const oldest = this.lastSentByKey.keys().next().value;
+			if (oldest !== void 0) this.lastSentByKey.delete(oldest);
+		}
+		const suppressed = this.errorsSuppressed;
+		this.errorsSuppressed = 0;
+		return {
+			allow: true,
+			suppressedCount: suppressed
+		};
+	}
+	allowCrashCapture(uptimeMs, now = Date.now()) {
+		const stable = uptimeMs >= this.stableUptimeMs;
+		const throttled = this.hasCapturedCrash && now - this.lastCrashCaptureAt < 6e5;
+		if (!stable && throttled) {
+			this.crashesSuppressed++;
+			return {
+				allow: false,
+				suppressedCount: this.crashesSuppressed
+			};
+		}
+		this.hasCapturedCrash = true;
+		this.lastCrashCaptureAt = now;
+		const suppressed = this.crashesSuppressed;
+		this.crashesSuppressed = 0;
+		return {
+			allow: true,
+			suppressedCount: suppressed
+		};
+	}
+};
 //#endregion
 //#region src/runtime-process.ts
 /**
@@ -21988,15 +22332,23 @@ function createLogger(component, additionalData) {
 * Spawns the runtime binary, pipes stdout/stderr to the daemon logger,
 * and restarts on crash with exponential backoff.
 */
-const log$1 = createLogger("RuntimeProcess");
+const log$2 = createLogger("RuntimeProcess");
+/** Quiet-period flush for a pending multi-line error block (e.g. a traceback
+* followed by silence — no closing line ever arrives to complete it). */
+const DETECTOR_FLUSH_DEBOUNCE_MS = 1500;
 const BACKOFF_INITIAL_MS = 1e3;
 const BACKOFF_MAX_MS = 3e4;
+const STABLE_UPTIME_MS = 6e4;
 var RuntimeProcess = class {
 	child = null;
 	stopped = false;
 	backoffMs = BACKOFF_INITIAL_MS;
 	lastStartTime = 0;
 	restartTimer = null;
+	ringBuffer = new OutputRingBuffer();
+	detector = new ErrorLineDetector();
+	throttle = new CaptureThrottle(STABLE_UPTIME_MS);
+	detectorFlushTimer = null;
 	constructor(options) {
 		this.options = options;
 	}
@@ -22027,7 +22379,7 @@ var RuntimeProcess = class {
 		if (this.stopped) return;
 		const { command, args } = this.resolveCommand();
 		this.lastStartTime = Date.now();
-		log$1.info({
+		log$2.info({
 			runtime: this.options.runtime,
 			command,
 			args,
@@ -22047,22 +22399,28 @@ var RuntimeProcess = class {
 		});
 		this.child.stdout?.on("data", (data) => {
 			const lines = data.toString().trim().split("\n");
-			for (const line of lines) log$1.info({
-				runtime: this.options.runtime,
-				stream: "stdout"
-			}, line);
+			for (const line of lines) {
+				log$2.info({
+					runtime: this.options.runtime,
+					stream: "stdout"
+				}, line);
+				this.observeLine("stdout", line);
+			}
 		});
 		this.child.stderr?.on("data", (data) => {
 			const lines = data.toString().trim().split("\n");
-			for (const line of lines) log$1.warn({
-				runtime: this.options.runtime,
-				stream: "stderr"
-			}, line);
+			for (const line of lines) {
+				log$2.warn({
+					runtime: this.options.runtime,
+					stream: "stderr"
+				}, line);
+				this.observeLine("stderr", line);
+			}
 		});
 		this.child.on("exit", (code, signal) => {
 			this.child = null;
 			if (this.stopped) {
-				log$1.info({
+				log$2.info({
 					runtime: this.options.runtime,
 					code,
 					signal
@@ -22070,7 +22428,7 @@ var RuntimeProcess = class {
 				return;
 			}
 			if (code === 0 && signal == null) {
-				log$1.info({
+				log$2.info({
 					runtime: this.options.runtime,
 					code
 				}, "Runtime exited gracefully — restarting");
@@ -22080,13 +22438,32 @@ var RuntimeProcess = class {
 				}, 500);
 				return;
 			}
-			log$1.warn({
+			log$2.warn({
 				runtime: this.options.runtime,
 				code,
 				signal,
 				backoffMs: this.backoffMs
 			}, "Runtime crashed — scheduling restart with backoff");
-			if (Date.now() - this.lastStartTime >= 6e4) this.backoffMs = BACKOFF_INITIAL_MS;
+			const uptime = Date.now() - this.lastStartTime;
+			if (this.detectorFlushTimer) {
+				clearTimeout(this.detectorFlushTimer);
+				this.detectorFlushTimer = null;
+			}
+			this.emitErrorBlock(this.detector.flush());
+			const crash = this.throttle.allowCrashCapture(uptime);
+			if (crash.allow) captureRuntimeCrash({
+				runtime: this.options.runtime,
+				code,
+				signal,
+				uptimeMs: uptime,
+				recentOutput: this.ringBuffer.snapshot(),
+				crashesSuppressed: crash.suppressedCount
+			});
+			else log$2.debug({
+				runtime: this.options.runtime,
+				suppressed: crash.suppressedCount
+			}, "Crash capture suppressed by throttle");
+			if (uptime >= 6e4) this.backoffMs = BACKOFF_INITIAL_MS;
 			this.restartTimer = setTimeout(() => {
 				this.restartTimer = null;
 				this.start();
@@ -22094,10 +22471,70 @@ var RuntimeProcess = class {
 			this.backoffMs = Math.min(this.backoffMs * 2, BACKOFF_MAX_MS);
 		});
 		this.child.on("error", (err) => {
-			log$1.error({
+			log$2.error({
 				runtime: this.options.runtime,
 				err: err.message
 			}, "Runtime process error");
+			if (this.stopped) return;
+			const crash = this.throttle.allowCrashCapture(Date.now() - this.lastStartTime);
+			if (crash.allow) captureRuntimeCrash({
+				runtime: this.options.runtime,
+				code: null,
+				signal: null,
+				uptimeMs: Date.now() - this.lastStartTime,
+				recentOutput: this.ringBuffer.snapshot(),
+				crashesSuppressed: crash.suppressedCount,
+				spawnError: err
+			});
+		});
+	}
+	/**
+	* Track a child output line for error capture: ring-buffer it (crash
+	* context) and run it through the error-block detector. A pending
+	* multi-line block is flushed after a quiet period so a trailing traceback
+	* isn't held forever.
+	*/
+	observeLine(stream, line) {
+		try {
+			this.ringBuffer.push({
+				stream,
+				line
+			});
+			for (const block of this.detector.feed(stream, line)) this.emitErrorBlock(block);
+			if (this.detectorFlushTimer) {
+				clearTimeout(this.detectorFlushTimer);
+				this.detectorFlushTimer = null;
+			}
+			if (this.detector.isCollecting) this.detectorFlushTimer = setTimeout(() => {
+				this.detectorFlushTimer = null;
+				this.emitErrorBlock(this.detector.flush());
+			}, DETECTOR_FLUSH_DEBOUNCE_MS);
+		} catch (err) {
+			log$2.debug({
+				runtime: this.options.runtime,
+				err: err instanceof Error ? err.message : String(err)
+			}, "Runtime output observation failed");
+		}
+	}
+	/** Report a completed error block to Sentry, throttle permitting. */
+	emitErrorBlock(block) {
+		if (!block) return;
+		const { allow, suppressedCount } = this.throttle.allowErrorCapture(block.fingerprintKey);
+		if (!allow) {
+			log$2.debug({
+				runtime: this.options.runtime,
+				kind: block.kind,
+				suppressed: suppressedCount
+			}, "Runtime error-output capture suppressed by throttle");
+			return;
+		}
+		captureRuntimeErrorOutput({
+			runtime: this.options.runtime,
+			stream: block.stream,
+			kind: block.kind,
+			lines: block.lines,
+			fingerprintKey: block.fingerprintKey,
+			suppressedCount
 		});
 	}
 	/**
@@ -22109,11 +22546,16 @@ var RuntimeProcess = class {
 			clearTimeout(this.restartTimer);
 			this.restartTimer = null;
 		}
+		if (this.detectorFlushTimer) {
+			clearTimeout(this.detectorFlushTimer);
+			this.detectorFlushTimer = null;
+		}
+		this.emitErrorBlock(this.detector.flush());
 		const child = this.child;
 		if (!child) return;
 		return new Promise((resolve) => {
 			const killTimer = setTimeout(() => {
-				log$1.warn({ runtime: this.options.runtime }, "Runtime did not exit in time — sending SIGKILL");
+				log$2.warn({ runtime: this.options.runtime }, "Runtime did not exit in time — sending SIGKILL");
 				child.kill("SIGKILL");
 			}, 5e3);
 			child.on("exit", () => {
@@ -22138,7 +22580,7 @@ var RuntimeProcess = class {
 	* Restart the runtime process (stop then start with fresh backoff).
 	*/
 	async restart() {
-		log$1.info({ runtime: this.options.runtime }, "Restarting runtime...");
+		log$2.info({ runtime: this.options.runtime }, "Restarting runtime...");
 		await this.stop();
 		this.stopped = false;
 		this.backoffMs = BACKOFF_INITIAL_MS;
@@ -22160,7 +22602,7 @@ var RuntimeProcess = class {
 * this registry from active integration manifests. Handler files are loaded
 * via ESM dynamic import on first use and cached until the registry is cleared.
 */
-const log = createLogger("CommandRegistry");
+const log$1 = createLogger("CommandRegistry");
 var CommandRegistry = class {
 	commands = /* @__PURE__ */ new Map();
 	version = 0;
@@ -22171,7 +22613,7 @@ var CommandRegistry = class {
 	register(integrationId, name, handlerPath, method = "handle", timeoutMs = 3e4) {
 		const existing = this.commands.get(name);
 		if (existing) {
-			log.warn({
+			log$1.warn({
 				command: name,
 				existing: existing.integrationId,
 				attempted: integrationId
@@ -22179,7 +22621,7 @@ var CommandRegistry = class {
 			return;
 		}
 		if (!existsSync(handlerPath)) {
-			log.warn({
+			log$1.warn({
 				command: name,
 				handlerPath,
 				integrationId
@@ -22194,7 +22636,7 @@ var CommandRegistry = class {
 			timeoutMs,
 			handler: null
 		});
-		log.info({
+		log$1.info({
 			command: name,
 			integrationId,
 			handlerPath,
@@ -22208,7 +22650,7 @@ var CommandRegistry = class {
 	unregisterAll(integrationId) {
 		for (const [name, entry] of this.commands) if (entry.integrationId === integrationId) {
 			this.commands.delete(name);
-			log.info({
+			log$1.info({
 				command: name,
 				integrationId
 			}, "Unregistered command");
@@ -22246,7 +22688,7 @@ var CommandRegistry = class {
 			entry.handler = fn;
 		} catch (err) {
 			const message = err instanceof Error ? err.message : String(err);
-			log.error({
+			log$1.error({
 				err: message,
 				command: name,
 				handlerPath: entry.handlerPath
@@ -22267,7 +22709,7 @@ var CommandRegistry = class {
 			})]);
 		} catch (err) {
 			const message = err instanceof Error ? err.message : String(err);
-			log.error({
+			log$1.error({
 				err: message,
 				command: name
 			}, "Command execution failed");
@@ -22296,7 +22738,7 @@ var CommandRegistry = class {
 	clear() {
 		this.commands.clear();
 		this.version++;
-		log.info({ version: this.version }, "Command registry cleared");
+		log$1.info({ version: this.version }, "Command registry cleared");
 	}
 };
 //#endregion
@@ -22585,6 +23027,93 @@ function writeSentinel(path) {
 	} catch {}
 }
 //#endregion
+//#region src/mcp-error-capture.ts
+const log = createLogger("McpErrorCapture");
+/** Quiet-period flush for a pending multi-line stderr block. */
+const MCP_STDERR_FLUSH_DEBOUNCE_MS = 1500;
+function createMcpErrorHooks() {
+	const resultErrorThrottle = new CaptureThrottle(6e4);
+	const errorThrottle = new CaptureThrottle(6e4);
+	const crashThrottle = new CaptureThrottle(6e4);
+	const throttleFor = (kind) => kind === "tool-result-error" ? resultErrorThrottle : kind === "server-crash" ? crashThrottle : errorThrottle;
+	const detectors = /* @__PURE__ */ new Map();
+	const flushTimers = /* @__PURE__ */ new Map();
+	const capture = (opts) => {
+		const { allow, suppressedCount } = throttleFor(opts.kind).allowErrorCapture(opts.fingerprintKey);
+		if (!allow) {
+			log.debug({
+				server: opts.server,
+				kind: opts.kind,
+				suppressed: suppressedCount
+			}, "MCP failure capture suppressed by throttle");
+			return;
+		}
+		captureMcpFailure({
+			...opts,
+			suppressedCount
+		});
+	};
+	const emitBlock = (server, block) => {
+		if (!block) return;
+		capture({
+			server,
+			kind: "stderr-output",
+			message: block.lines[0],
+			lines: block.lines,
+			fingerprintKey: `stderr:${server}:${block.fingerprintKey}`
+		});
+	};
+	return {
+		onToolError: (info) => {
+			capture({
+				server: info.server,
+				tool: info.tool,
+				kind: info.kind === "thrown" ? "tool-thrown" : "tool-result-error",
+				message: info.message,
+				fingerprintKey: `tool:${info.server}:${info.tool}:${toFingerprintKey(info.message)}`
+			});
+		},
+		onServerCrash: (server) => {
+			const timer = flushTimers.get(server);
+			if (timer) {
+				clearTimeout(timer);
+				flushTimers.delete(server);
+			}
+			emitBlock(server, detectors.get(server)?.flush() ?? null);
+			capture({
+				server,
+				kind: "server-crash",
+				message: "MCP server connection closed unexpectedly",
+				fingerprintKey: `crash:${server}`
+			});
+		},
+		onServerStderr: (server, line) => {
+			let detector = detectors.get(server);
+			if (!detector) {
+				detector = new ErrorLineDetector();
+				detectors.set(server, detector);
+			}
+			for (const block of detector.feed("stderr", line)) emitBlock(server, block);
+			const existing = flushTimers.get(server);
+			if (existing) {
+				clearTimeout(existing);
+				flushTimers.delete(server);
+			}
+			if (detector.isCollecting) {
+				const target = detector;
+				flushTimers.set(server, setTimeout(() => {
+					flushTimers.delete(server);
+					emitBlock(server, target.flush());
+				}, MCP_STDERR_FLUSH_DEBOUNCE_MS));
+			}
+		},
+		dispose: () => {
+			for (const timer of flushTimers.values()) clearTimeout(timer);
+			flushTimers.clear();
+		}
+	};
+}
+//#endregion
 //#region src/daemon.ts
 /**
 * Alfe Gateway Daemon — main entry point.
@@ -22820,6 +23349,21 @@ async function startDaemon() {
 		surface: "daemon",
 		release: await getCliVersion()
 	});
+	let fatalExiting = false;
+	process.on("uncaughtException", (err) => {
+		if (fatalExiting) process.exit(1);
+		fatalExiting = true;
+		logger$1.error({
+			err: err.message,
+			stack: err.stack
+		}, "Uncaught exception — daemon exiting");
+		captureFatal(err);
+		flushAndExit(1);
+	});
+	process.on("unhandledRejection", (reason) => {
+		logger$1.error({ reason: reason instanceof Error ? reason.message : String(reason) }, "Unhandled promise rejection");
+		captureFatal(reason instanceof Error ? reason : /* @__PURE__ */ new Error(`Unhandled rejection: ${String(reason)}`));
+	});
 	if (!managed) {
 		await mkdir(join(homedir(), ".alfe"), { recursive: true });
 		const existingPid = await checkExistingDaemon();
@@ -22954,9 +23498,11 @@ async function startDaemon() {
 	});
 	const mcpManager = new Manager({ logger: logger$1 });
 	mcpManagerRef = mcpManager;
+	const mcpErrorHooks = createMcpErrorHooks();
 	mcpBundler = new McpBundler({
 		logger: logger$1,
-		idleTtlMs: 0
+		idleTtlMs: 0,
+		...mcpErrorHooks
 	}, { connect: defaultConnect });
 	if (config.runtime === "hermes") logger$1.info("Hermes runtime — daemon MCP bundler left idle (store mirrored to config.yaml by HermesMcpSync)");
 	else {
@@ -23083,6 +23629,7 @@ async function startDaemon() {
 			mcpBundler = null;
 			logger$1.debug("MCP bundler stopped");
 		}
+		mcpErrorHooks.dispose();
 		logger$1.debug("Stopping MCP bundler manager...");
 		await mcpManager.dispose();
 		mcpManagerRef = null;
@@ -23807,4 +24354,4 @@ function formatDuration(ms) {
 	return `${String(Math.round(seconds / 3600))}h`;
 }
 //#endregion
-export { PINNED_OPENCLAW_VERSION as C, resolveAgentIdentity as S, ALFE_DIR as _, installService as a, fetchAgentConfig as b, uninstallService as c, captureFatal as d, captureIntegrationFailure as f, PROTOCOL_VERSION as g, setAgentContext as h, checkExistingDaemon as i, AGENT_DAEMON_SENTRY_DSN as l, initAgentSentry as m, queryDaemonHealth as n, startService as o, flushSentry as p, startDaemon as r, stopExistingDaemon as s, formatHealthReport as t, captureCliFailure as u, PID_PATH as v, loadDaemonConfig as x, SOCKET_PATH as y };
+export { PID_PATH as C, resolveAgentIdentity as D, loadDaemonConfig as E, PINNED_OPENCLAW_VERSION as O, ALFE_DIR as S, fetchAgentConfig as T, captureRuntimeErrorOutput as _, installService as a, setAgentContext as b, uninstallService as c, AGENT_RUNTIME_SENTRY_DSN as d, captureCliFailure as f, captureRuntimeCrash as g, captureMcpFailure as h, checkExistingDaemon as i, AGENT_DAEMON_SENTRY_DSN as l, captureIntegrationFailure as m, queryDaemonHealth as n, startService as o, captureFatal as p, startDaemon as r, stopExistingDaemon as s, formatHealthReport as t, AGENT_MCP_SENTRY_DSN as u, flushSentry as v, SOCKET_PATH as w, PROTOCOL_VERSION as x, initAgentSentry as y };

package/dist/src/index.d.ts

@@ -74,6 +74,20 @@ declare const PINNED_OPENCLAW_VERSION = "2026.6.8";
  * both places.
  */
 declare const AGENT_DAEMON_SENTRY_DSN = "https://a47f010d8d39fb4350f913492189f283@o4511008239452160.ingest.us.sentry.io/4511679448547328";
+/**
+ * Dedicated project for errors emitted BY the agent runtime child process
+ * (OpenClaw/Hermes) — crashes, spawn failures, and error-looking output. Kept
+ * separate from `agent-daemon` so runtime noise never drowns daemon issues.
+ * Mirrors `SENTRY_DSNS.agentRuntime` in `config/config.ts`.
+ */
+declare const AGENT_RUNTIME_SENTRY_DSN = "https://feb7fb2e3b8e723aec518e74715bfa6d@o4511008239452160.ingest.us.sentry.io/4511683667558400";
+/**
+ * MCP tool/server failures on agent VMs — reported by the daemon-hosted MCP
+ * bundler (tool errors, child crashes, stderr output). This is the SAME
+ * project as the cloud MCP Fly service (`SENTRY_DSNS.mcp`); agent-side events
+ * are distinguished by `source: agent-daemon` + `agentId` tags.
+ */
+declare const AGENT_MCP_SENTRY_DSN = "https://638309eac96146a945f46b578f10c806@o4511008239452160.ingest.us.sentry.io/4511146364174336";
 /** Which surface initialised Sentry — tagged on every event. */
 type SentrySurface = "cli" | "daemon";
 interface InitAgentSentryOptions {
@@ -112,6 +126,59 @@ declare function captureIntegrationFailure(integration: string, phase: string, c
  * Sentry is not initialised. Never throws.
  */
 declare function captureCliFailure(context: string, cause?: unknown): void;
+/** A line of runtime child-process output attached to a crash event. */
+interface RuntimeOutputLine {
+  stream: "stdout" | "stderr";
+  line: string;
+}
+/**
+ * Capture a runtime child-process crash (non-graceful exit) or spawn failure
+ * into the dedicated `agent-runtime` project. Recent output travels as
+ * breadcrumbs — NEVER `extra`, which `scrubEvent` (the runtime client's
+ * `beforeSend`) deletes. Throttling is the caller's job (`CaptureThrottle` in
+ * `runtime-output-monitor.ts`). No-op when the runtime client is not
+ * initialised. Never throws.
+ */
+declare function captureRuntimeCrash(opts: {
+  runtime: string;
+  code: number | null;
+  signal: string | null;
+  uptimeMs: number;
+  recentOutput: readonly RuntimeOutputLine[];
+  crashesSuppressed?: number;
+  /** Set for the child `error` event path (e.g. ENOENT — binary missing). */
+  spawnError?: Error;
+}): void;
+/**
+ * Capture an error-looking block of runtime output (stack trace, Python
+ * traceback, or ERROR-level log line) detected while the child is running.
+ * The block lines travel as breadcrumbs; the head line is the message.
+ * Throttling/dedupe is the caller's job. No-op when Sentry is not initialised.
+ * Never throws.
+ */
+declare function captureRuntimeErrorOutput(opts: {
+  runtime: string;
+  stream: "stdout" | "stderr";
+  kind: "node-stack" | "python-traceback" | "error-log";
+  lines: readonly string[];
+  fingerprintKey: string;
+  suppressedCount?: number;
+}): void;
+/**
+ * Capture an MCP failure (tool error, server crash, or error-looking stderr
+ * output) into the `mcp` project via the daemon's bound MCP client. Throttling
+ * is the caller's job (`mcp-error-capture.ts`). No-op when the MCP client is
+ * not initialised. Never throws.
+ */
+declare function captureMcpFailure(opts: {
+  server: string;
+  tool?: string;
+  kind: "tool-thrown" | "tool-result-error" | "server-crash" | "stderr-output";
+  message: string;
+  /** Optional context lines (stderr block) — attached as breadcrumbs. */
+  lines?: readonly string[];
+  suppressedCount?: number;
+}): void;
 /** Flush queued events (small timeout) so short-lived commands deliver them. */
 declare function flushSentry(timeoutMs?: number): Promise<void>;
 /**
@@ -293,4 +360,4 @@ declare function checkExistingDaemon(): Promise<number | null>;
  */
 declare function stopExistingDaemon(): Promise<boolean>;
 //#endregion
-export { AGENT_DAEMON_SENTRY_DSN, ALFE_DIR, type AgentIdentity, type AgentWorkspaceConfig, type DaemonConfig, type DaemonHealth, type IPCEvent, type IPCRequest, type IPCResponse, type InitAgentSentryOptions, PID_PATH, PINNED_OPENCLAW_VERSION, PROTOCOL_VERSION, SOCKET_PATH, type SentrySurface, captureCliFailure, captureFatal, captureIntegrationFailure, checkExistingDaemon, fetchAgentConfig, flushSentry, formatHealthReport, initAgentSentry, installService, loadDaemonConfig, logger, queryDaemonHealth, resolveAgentIdentity, setAgentContext, startDaemon, startService, stopExistingDaemon, uninstallService };
+export { AGENT_DAEMON_SENTRY_DSN, AGENT_MCP_SENTRY_DSN, AGENT_RUNTIME_SENTRY_DSN, ALFE_DIR, type AgentIdentity, type AgentWorkspaceConfig, type DaemonConfig, type DaemonHealth, type IPCEvent, type IPCRequest, type IPCResponse, type InitAgentSentryOptions, PID_PATH, PINNED_OPENCLAW_VERSION, PROTOCOL_VERSION, type RuntimeOutputLine, SOCKET_PATH, type SentrySurface, captureCliFailure, captureFatal, captureIntegrationFailure, captureMcpFailure, captureRuntimeCrash, captureRuntimeErrorOutput, checkExistingDaemon, fetchAgentConfig, flushSentry, formatHealthReport, initAgentSentry, installService, loadDaemonConfig, logger, queryDaemonHealth, resolveAgentIdentity, setAgentContext, startDaemon, startService, stopExistingDaemon, uninstallService };

package/dist/src/index.js

@@ -1,3 +1,3 @@
-import { C as PINNED_OPENCLAW_VERSION, S as resolveAgentIdentity, _ as ALFE_DIR, a as installService, b as fetchAgentConfig, c as uninstallService, d as captureFatal, f as captureIntegrationFailure, g as PROTOCOL_VERSION, h as setAgentContext, i as checkExistingDaemon, l as AGENT_DAEMON_SENTRY_DSN, m as initAgentSentry, n as queryDaemonHealth, o as startService, p as flushSentry, r as startDaemon, s as stopExistingDaemon, t as formatHealthReport, u as captureCliFailure, v as PID_PATH, x as loadDaemonConfig, y as SOCKET_PATH } from "../health.js";
+import { C as PID_PATH, D as resolveAgentIdentity, E as loadDaemonConfig, O as PINNED_OPENCLAW_VERSION, S as ALFE_DIR, T as fetchAgentConfig, _ as captureRuntimeErrorOutput, a as installService, b as setAgentContext, c as uninstallService, d as AGENT_RUNTIME_SENTRY_DSN, f as captureCliFailure, g as captureRuntimeCrash, h as captureMcpFailure, i as checkExistingDaemon, l as AGENT_DAEMON_SENTRY_DSN, m as captureIntegrationFailure, n as queryDaemonHealth, o as startService, p as captureFatal, r as startDaemon, s as stopExistingDaemon, t as formatHealthReport, u as AGENT_MCP_SENTRY_DSN, v as flushSentry, w as SOCKET_PATH, x as PROTOCOL_VERSION, y as initAgentSentry } from "../health.js";
 import { n as logger } from "../logger.js";
-export { AGENT_DAEMON_SENTRY_DSN, ALFE_DIR, PID_PATH, PINNED_OPENCLAW_VERSION, PROTOCOL_VERSION, SOCKET_PATH, captureCliFailure, captureFatal, captureIntegrationFailure, checkExistingDaemon, fetchAgentConfig, flushSentry, formatHealthReport, initAgentSentry, installService, loadDaemonConfig, logger, queryDaemonHealth, resolveAgentIdentity, setAgentContext, startDaemon, startService, stopExistingDaemon, uninstallService };
+export { AGENT_DAEMON_SENTRY_DSN, AGENT_MCP_SENTRY_DSN, AGENT_RUNTIME_SENTRY_DSN, ALFE_DIR, PID_PATH, PINNED_OPENCLAW_VERSION, PROTOCOL_VERSION, SOCKET_PATH, captureCliFailure, captureFatal, captureIntegrationFailure, captureMcpFailure, captureRuntimeCrash, captureRuntimeErrorOutput, checkExistingDaemon, fetchAgentConfig, flushSentry, formatHealthReport, initAgentSentry, installService, loadDaemonConfig, logger, queryDaemonHealth, resolveAgentIdentity, setAgentContext, startDaemon, startService, stopExistingDaemon, uninstallService };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alfe.ai/gateway",
-  "version": "0.3.2",
+  "version": "0.5.0",
   "description": "Alfe local gateway daemon — persistent control plane for agent integrations",
   "type": "module",
   "bin": {
@@ -23,12 +23,12 @@
     "pino-roll": "^1.2.0",
     "smol-toml": ">=1.6.1",
     "ws": "^8.18.0",
-    "@alfe.ai/agent-api-client": "^0.6.0",
+    "@alfe.ai/agent-api-client": "^0.8.0",
     "@alfe.ai/ai-proxy-local": "^0.0.13",
     "@alfe.ai/config": "^0.3.0",
     "@alfe.ai/integration-manifest": "^0.3.1",
-    "@alfe.ai/integrations": "^0.2.8",
-    "@alfe.ai/mcp-bundler": "^0.2.2"
+    "@alfe.ai/integrations": "^0.2.10",
+    "@alfe.ai/mcp-bundler": "^0.3.0"
   },
   "license": "UNLICENSED",
   "homepage": "https://alfe.ai",