@vibesdotdev/mcp 0.0.0-stage → 1.0.0-rc.1

package/dist/cli/surface-mcp/dev.mcp.serve.impl.consumer.js

@@ -0,0 +1,657 @@
+import { loadPurposePresetOverrides } from '@vibesdotdev/tools/config/load';
+import { runtimePurposePresets, purposePresetPolicyKey } from '@vibesdotdev/tools/schemas/presets/registry';
+/**
+ * MCP Serve CLI Command Implementation - Consumer
+ *
+ * Runs the MCP server in stdio or HTTP mode for consumer hardware.
+ * Owned by runtime-surface-mcp so @vibesdotdev/mcp stays transport/framework-only.
+ */
+import * as z from 'zod/v4';
+import { ContextDescriptorSchema } from '@vibesdotdev/kernel/schemas/context';
+import { CapabilityError, CaughtFailureSchema, valueFreeFailure, createRuntimeImplementation, getRuntimeScopedValues, getRuntimeStdio, getRuntimeStdioStreams, getRuntimeStdinEvents } from '@vibesdotdev/kernel';
+import { isWorkspaceNotAdmitted } from '@vibesdotdev/pm/admission';
+import { createStartupRefusalServer, createStartupRefusalTransport } from "../../adapters/mcp/startup-refusal.js";
+import { hostProcessProbe } from "../../adapters/mcp/host-registry.js";
+import { relayAttestationVerifier, STDIO_LAUNCH_SOURCE } from "../../adapters/mcp/connection-identity.js";
+import { getPathRoots } from '@vibesdotdev/paths';
+import { createCLIActionLifetime, isCLIExitSignal, requestCLIExit } from '@vibesdotdev/cli/providers';
+import { acquireStdoutCapture, getLogger } from '@vibesdotdev/logging';
+import { stdioRelayTransportPlugins } from "./stdio-relay-transport.js";
+import { createMcpAdapter } from '@vibesdotdev/mcp/adapters/mcp';
+import { WireInvokeCallerSchema } from '@vibesdotdev/kernel/schemas/invoke-caller';
+import { validateMcpGeneration } from "../../adapters/mcp/generation-contract.js";
+import { prepareMcpServeHost } from "../../surface-mcp/index.js";
+import { reportLocalToolsForMcpServe, localToolIdsForMcpAdapter } from "../../surface-mcp/local-tools-bootstrap.js";
+import { getMcpBuildProvenance } from "../../surface-mcp/build-provenance.js";
+import { writeHostProvenanceBanner } from "../../surface-mcp/host-provenance-banner.js";
+import { startExecutableFreshnessWatch } from "../../surface-mcp/executable-freshness-watch.js";
+import { subscribeServeCrashReports } from "../../surface-mcp/crash-reporting.js";
+import { startLifecycleRepeat } from "../../lifecycle-repeat.js";
+import { loadMcpConfig } from "../../config/load.js";
+import { resolveServeHostIdentity, staleBodyBanner } from "../../adapters/mcp/stale-body.consumer.js";
+import { refusesLocalDevOnPublicBinary } from "./local-dev-flag.js";
+import { managedHostDependencies, startStdioMcp } from "./shared-host-startup.js";
+import { runTeardown } from "./teardown.js";
+import { announceSessionBound, announceSessionUnbound, archiveBoundStdioSession, bindFreshStdioSession, startConsumerBackgroundServices, getBoundStdioSessionId, rebindWorkspaceEnvironmentForActiveSession, rebindWorkspaceEnvironmentForSession, triggerProgressiveIndexingInBackground } from "../../surface-mcp/serve-lifecycle.js";
+import { loadSurfaceSessions, tryGetSessionManager } from "../../surface-mcp/session-bridge.js";
+const ServeOptionsSchema = z.object({
+    auth: z.boolean().optional(), mode: z.enum(['stdio', 'http']).optional(), port: z.string().optional(),
+    client: z.string().optional(), preset: z.string().optional(), tools: z.string().optional(),
+    agent: z.string().optional(), agentId: z.string().optional(), harness: z.string().optional(),
+    preloadKnowledgeBases: z.string().optional(), isolated: z.boolean().optional(), finite: z.boolean().optional()
+});
+function parsePreloadKnowledgeBases(value) {
+    if (!value)
+        return [];
+    return value
+        .split(',')
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0);
+}
+function hasSessionTools(descriptors) {
+    return descriptors.some((descriptor) => descriptor.id === 'session' || descriptor.id.startsWith('session-'));
+}
+/**
+ * The serve host's declared MCP logger (`mcp-stdio`/`mcp-http`), else the
+ * `mcp` namespace logger when the host declares none. A declared logger that
+ * fails to resolve is a startup failure, not an absence.
+ */
+async function resolveMcpLogger(runtime, mode) {
+    const loggerId = mode === 'stdio' ? 'mcp-stdio' : 'mcp-http';
+    if (runtime.hasKind('logging/logger') && runtime.query('logging/logger').withId(loggerId).exists()) {
+        return await runtime.query('logging/logger').withId(loggerId).resolve();
+    }
+    return getLogger('mcp', runtime);
+}
+/** A teardown step that failed: logged, never allowed to block the rest of teardown. */
+/** A known PM refusal stays protocol-visible without creating a private serving body. */
+export async function serveWorkspaceRefusal(runtime, failure, closeCapture) {
+    if (!isWorkspaceNotAdmitted(failure) || failure.code !== 'PERMISSION_DENIED')
+        throw failure;
+    const streams = await getRuntimeStdioStreams(runtime);
+    const server = createStartupRefusalServer(failure);
+    const lifetime = await createCLIActionLifetime(runtime, async () => {
+        const results = await Promise.allSettled([server.close(), closeCapture?.()]);
+        const failures = [];
+        for (const result of results)
+            if (result.status === 'rejected')
+                failures.push(CaughtFailureSchema.parse(result.reason));
+        if (failures.length === 1)
+            throw failures[0];
+        if (failures.length > 1)
+            throw new AggregateError(failures, 'MCP refusal cleanup failed.');
+    });
+    const transportClosed = new Promise((resolve, reject) => {
+        server.onerror = error => {
+            reject(error);
+            void lifetime.request('transport-error');
+        };
+        server.onclose = () => { resolve(); void lifetime.request('transport-close'); };
+    });
+    const transportOutcome = transportClosed.then(() => undefined, error => CaughtFailureSchema.parse(error));
+    const onDispose = () => { void lifetime.request('runtime-dispose'); };
+    runtime.lifecycle.signal.addEventListener('abort', onDispose, { once: true });
+    try {
+        const transport = createStartupRefusalTransport(streams.streams());
+        await server.connect(transport);
+        lifetime.bindProcessSignals();
+        if (runtime.lifecycle.signal.aborted)
+            onDispose();
+        await lifetime.wait();
+        const transportFailure = await transportOutcome;
+        if (transportFailure !== undefined)
+            throw transportFailure;
+    }
+    catch (thrown) {
+        void lifetime.request('startup-failure');
+        const [cleanup] = await Promise.allSettled([lifetime.wait()]);
+        if (cleanup?.status === 'rejected' && cleanup.reason !== thrown) {
+            const cleanupFailure = CaughtFailureSchema.parse(cleanup.reason);
+            throw new AggregateError([thrown, cleanupFailure], 'MCP refusal and cleanup failed.', { cause: thrown });
+        }
+        throw thrown;
+    }
+    finally {
+        runtime.lifecycle.signal.removeEventListener('abort', onDispose);
+    }
+}
+async function executeMcpCommand(_args, options, context) {
+    const opts = ServeOptionsSchema.parse(options);
+    // The serve host: `dev mcp serve` declares `effects.serve`, so the CLI booted
+    // this runtime through the one entry before the action ran (rc02-rc03 §2.3)
+    // — surface and purpose `mcp`, request principals, `sharedHost`,
+    // `qualifiers.serve`, and the `--finite ? finite : persistent` lifecycle. It
+    // is already composed; serving bodies activate, while stdio relays defer
+    // autonomous work to their shared body. Nothing here re-declares it.
+    // The CLI hands it to the action as `context.runtime`.
+    const host = context.runtime;
+    const configuredPresets = await loadPurposePresetOverrides(host);
+    const stdio = await getRuntimeStdio(host);
+    const scopedValues = await getRuntimeScopedValues(host);
+    // VIBES_LOCAL_DEV failsafe (MCP-refusal half). On the COMPILED public binary
+    // (the declared build surface is public), a truthy VIBES_LOCAL_DEV is a hard stop:
+    // we refuse to start the MCP server so a prod binary can't quietly serve under
+    // local-dev wiring. Override is the explicit failsafe VIBES_LOCAL_DEV=0. The
+    // source dev runner (VIBES_CLI_MODE !== "public") is unaffected.
+    if (await refusesLocalDevOnPublicBinary(host)) {
+        stdio.write('stderr', '\x1b[31m[mcp] Refusing to start the MCP server: VIBES_LOCAL_DEV is set on the production binary. This is a safety stop. Re-run with VIBES_LOCAL_DEV=0 to override.\x1b[0m\n');
+        requestCLIExit(1);
+    }
+    const mode = opts.mode ?? 'stdio';
+    // Human-visible stderr logs: the host's MCP_ENABLE_STDERR opt-in, or an
+    // interactive terminal. Passed to the capture as an option, never written
+    // back into the host environment.
+    let enableStderr = host.getEnv('MCP_ENABLE_STDERR') === 'true';
+    let stdoutCapture;
+    // WHICH BODY ANSWERED — one stderr line, before anything can swallow it.
+    // It must be here, above the shared-host relay below, because the relay
+    // RETURNS: a banner emitted after the serve body starts would never print on
+    // the path that actually serves most clients. Replaces the deleted
+    // `sourceWorkspaceDiverged` verdict (WU-11) with the three facts that do
+    // identify a thin-host body; see `host-provenance-banner.ts`.
+    // The host's declared process identity (executable and graph freshness);
+    // null when the host declares none, which leaves freshness unknowable.
+    const hostIdentity = await resolveServeHostIdentity(host);
+    await writeHostProvenanceBanner(host, hostIdentity);
+    if (mode === 'stdio') {
+        if (host.localEnvironment.terminal?.().stdinIsTerminal) {
+            stdio.write('stderr', `[mcp] Starting stdio MCP server (client=${opts.client || 'default'})\n`);
+            stdio.write('stderr', `[mcp] This binary is normally spawned by an MCP client (Grok, Claude, Cursor, etc.).\n`);
+            stdio.write('stderr', `[mcp] Protocol traffic is on stdin/stdout. Human-visible logs go to stderr + logs/stdout-capture.log.\n`);
+            stdio.write('stderr', `[mcp] Press Ctrl-C to stop.\n\n`);
+            enableStderr = true;
+        }
+        stdoutCapture = await acquireStdoutCapture(host, { mirrorToStderr: enableStderr });
+    }
+    // The workspace this serve host is bound to: the kernel's one binding
+    // (`--workspace-root`, else the nearest workspace above the cwd). The relay's
+    // host lookup, the HTTP host's port and claim, provenance and the stdio
+    // connection identity are all keyed by it, so an unbound host fails here with
+    // `workspace-unbound` and its recovery hint.
+    const workspaceRoot = await host.context('runtime/workspace-path');
+    // ── Shared-host relay ────────────────────────────────────────────────────
+    // This block MUST stay above the serve body (session, adapter, hot reload,
+    // indexing); a relay placed after it would forward correctly, log correctly,
+    // and save nothing. Measured 2026-08-21: 10 stdio servers on ONE workspace,
+    // 51.3GB resident, 8 with identical arguments. Since RC02 the serve host
+    // itself is booted by the CLI's serve transition BEFORE this action runs, so
+    // the relay composes its declared host but now defers autonomous activation
+    // to the shared serving body (see `effects.serve.deferActivationWhen`).
+    let isolation;
+    if (mode === 'stdio') {
+        if (opts.isolated === true || opts.finite === true) {
+            isolation = { reason: 'requested', workspaceRoot };
+        }
+        else {
+            const { resolveServeIdentity: resolveRelayIdentity } = await import("../../adapters/mcp/serve-identity.js");
+            const relayIdentity = resolveRelayIdentity(host, {
+                preset: opts.preset,
+                tools: opts.tools,
+                agent: opts.agent,
+                agentId: opts.agentId,
+                harness: opts.harness,
+                client: opts.client,
+                env: host.getEnvSnapshot()
+            }, runtimePurposePresets(host, configuredPresets));
+            const { resolveClientConnectionIdentity } = await import("./client-connection-identity.consumer.js");
+            const connection = await resolveClientConnectionIdentity(host, {
+                identity: relayIdentity,
+                env: host.getEnvSnapshot(),
+                workspaceRoot
+            });
+            const startup = await startStdioMcp({
+                lifecycle: host.lifecycle,
+                logger: getLogger('mcp.stdio-relay', host),
+                runtime: host,
+                workspaceRoot,
+                roots: getPathRoots(host),
+                processProbe: await hostProcessProbe(host),
+                identity: {
+                    preset: relayIdentity.preset,
+                    toolPatterns: relayIdentity.toolPatterns,
+                    agent: connection.agentId,
+                    harness: connection.harness,
+                    harnessSessionId: connection.harnessSessionId,
+                    agentSystemId: connection.agentSystemId,
+                    projectIds: connection.projectIds,
+                    home: connection.home,
+                    client: opts.client
+                },
+                hostUrl: host.getEnv('VIBES_MCP_HOST_URL')
+            }, managedHostDependencies(host)).then(() => ({ failure: undefined }), thrown => ({ failure: CaughtFailureSchema.parse(thrown) }));
+            if (startup.failure !== undefined) {
+                if (!isWorkspaceNotAdmitted(startup.failure))
+                    throw startup.failure;
+                await serveWorkspaceRefusal(host, startup.failure, () => stdoutCapture?.close() ?? Promise.resolve());
+            }
+            return;
+        }
+    }
+    const action = await (async () => {
+        let runtime = host;
+        await prepareMcpServeHost(runtime, workspaceRoot);
+        const resolvedLogger = await resolveMcpLogger(runtime, mode);
+        const logger = getLogger(resolvedLogger.fullNamespace, runtime);
+        // Runtime-owned and joined at disposal; started once per root.
+        void startConsumerBackgroundServices(runtime, logger);
+        // Fatal failures from background work are reported through the host's
+        // declared, runtime-scoped capability. Report-only: a crash is never
+        // swallowed for every runtime in the process (census #10).
+        const crashReporting = await subscribeServeCrashReports(runtime, logger);
+        const removeCrashIsolation = () => {
+            if (crashReporting.kind === 'subscribed')
+                crashReporting.stop();
+        };
+        // Dogfood: project .vibes/tools (registered by the boot's discovery pass)
+        // appear on MCP before selection/wire; their ids feed createMcpAdapter's
+        // [local] tagging.
+        const localToolsEnsure = reportLocalToolsForMcpServe(runtime, {
+            writeNotice: (line) => { stdio.write('stderr', `${line}\n`); },
+            logInfo: (message, meta) => logger.info(message, meta)
+        });
+        const localToolIds = localToolIdsForMcpAdapter(localToolsEnsure);
+        const customPresets = runtimePurposePresets(runtime, configuredPresets);
+        const { resolveServeIdentity } = await import("../../adapters/mcp/serve-identity.js");
+        const identity = resolveServeIdentity(runtime, {
+            preset: opts.preset,
+            tools: opts.tools,
+            agent: opts.agent,
+            agentId: opts.agentId,
+            harness: opts.harness,
+            client: opts.client,
+            env: runtime.getEnvSnapshot()
+        }, customPresets);
+        const mcpClientId = identity.harness;
+        // An HTTP host serves many agents and has no body of its own: it never
+        // writes an agent identity into its environment. Each connection declares
+        // its identity at `initialize`. Only a stdio server — spawned by one
+        // harness for one agent — resolves an identity for itself.
+        let stdioConnectionIdentity;
+        if (mode === 'stdio') {
+            const { resolveClientConnectionIdentity } = await import("./client-connection-identity.consumer.js");
+            stdioConnectionIdentity = WireInvokeCallerSchema.parse(await resolveClientConnectionIdentity(runtime, { identity, env: runtime.getEnvSnapshot(), workspaceRoot }));
+        }
+        const provenance = await getMcpBuildProvenance(runtime, workspaceRoot);
+        const { selectMcpTools, explainMcpToolSelection, mcpCatalogAttachKey } = await import('@vibesdotdev/mcp/adapters/mcp/tool-selection');
+        const enabledDescriptors = runtime.hasKind('tools/tool')
+            ? runtime.query('tools/tool').enabled().descriptors()
+            : [];
+        const selectedTools = selectMcpTools(enabledDescriptors, {
+            mcpClientId,
+            customPresets,
+            preset: identity.preset,
+            toolPatterns: identity.toolPatterns
+        });
+        const hasToolKind = runtime.hasKind('tools/tool');
+        const toolCount = hasToolKind ? selectedTools.descriptors.length : 0;
+        logger.info('MCP serve starting', {
+            hasToolKind,
+            toolCount,
+            localToolCount: localToolIds.length,
+            localToolIds: localToolIds.length > 0 ? localToolIds : undefined,
+            presetId: selectedTools.presetId,
+            harness: identity.harness,
+            agent: identity.agent,
+            identitySources: identity.sources,
+            limitedFrom: selectedTools.limitedFrom || undefined,
+            degraded: selectedTools.degraded || undefined,
+            buildProvenance: provenance.provenanceString,
+            sourceRoot: provenance.sourceRoot,
+            sourceGitRef: provenance.sourceGitRef,
+            sourceRefKind: provenance.sourceRefKind,
+            workspaceRoot: provenance.workspaceRoot,
+            workspaceGitRef: provenance.workspaceGitRef,
+            executableDistPath: provenance.executableDistPath,
+            distStale: provenance.distStale || undefined,
+            totalKinds: runtime.kindIds().length,
+            scope: runtime.scope
+        });
+        if (provenance.distStale) {
+            logger.warn('MCP serve with stale dist — code may not match current source', {
+                sourceGitRef: provenance.sourceGitRef,
+                commitTime: provenance.commitTime,
+                distStale: provenance.distStale
+            });
+        }
+        if (!provenance.sourceGitRef) {
+            logger.warn('MCP executable source cannot be certified', {
+                sourceRoot: provenance.sourceRoot,
+                sourceGitRef: provenance.sourceGitRef,
+                sourceRefKind: provenance.sourceRefKind,
+                workspaceRoot: provenance.workspaceRoot,
+                workspaceGitRef: provenance.workspaceGitRef,
+                executableDistPath: provenance.executableDistPath
+            });
+        }
+        if (selectedTools.degraded) {
+            logger.error('MCP serve DEGRADED — unknown client preset fallthrough', {
+                requestedClientId: mcpClientId,
+                resolvedPresetId: selectedTools.presetId,
+                degraded: selectedTools.degraded
+            });
+        }
+        // Exposure-funnel audit trail: registry → preset → wire. Tools used to
+        // vanish from MCP silently (config-gated plugins, preset filtering); this
+        // makes every exclusion and its reason greppable in stdout-capture.log.
+        // NOTE: no `availableIds` here — loader registration is still settling at
+        // this point (session bridge, scope qualifiers), so a loader check would
+        // report false zombies. buildServer logs the advisory separately.
+        if (hasToolKind) {
+            const exposure = explainMcpToolSelection(enabledDescriptors, {
+                mcpClientId,
+                customPresets,
+                preset: identity.preset,
+                toolPatterns: identity.toolPatterns
+            });
+            const excludedByReason = {};
+            for (const { id, reason } of exposure.excluded) {
+                (excludedByReason[reason] ??= []).push(id);
+            }
+            logger.info('MCP tool exposure', {
+                presetId: exposure.presetId,
+                registryEnabled: enabledDescriptors.length,
+                exposed: exposure.included.length,
+                exposedTools: exposure.included,
+                limitedFrom: exposure.limitedFrom || undefined,
+                degraded: exposure.degraded || undefined,
+                excludedByReason: Object.keys(excludedByReason).length > 0 ? excludedByReason : undefined
+            });
+        }
+        const initializeSessionContext = async () => {
+            const outcome = await (async () => {
+                const manager = await tryGetSessionManager(runtime);
+                const surfaceSessions = await loadSurfaceSessions(runtime);
+                if (manager) {
+                    const { setSessionManager } = await import('@vibesdotdev/session/mcp/utils/participant');
+                    setSessionManager(manager);
+                    await surfaceSessions?.ensureParticipant();
+                    // The HTTP host is one runtime serving many concurrent seats. It
+                    // installs Session authority here, but each request carries its own
+                    // participant/session through ToolCallContext. Adopting a process-global
+                    // active session would make the last client win and refold the entire MCP
+                    // catalog on every bind.
+                    if (mode === 'http')
+                        return;
+                    // stdio: bind a FRESH session per connection — never adopt the
+                    // workspace's persisted default/active session (would cross-
+                    // contaminate parallel external-agent instances). HTTP keeps its
+                    // own per-request model and never adopts an ambient active session.
+                    let boundSessionId;
+                    if (mode === 'stdio') {
+                        boundSessionId = await bindFreshStdioSession(runtime);
+                        // Self-healing sweep (L-03): crashed/killed stdio processes leak
+                        // their fresh sessions as permanently-active rows (740+ had
+                        // accumulated). Archive stale surface-owned sessions in the
+                        // background; never block the MCP handshake on it.
+                        if (runtime.scope.lifecycle !== 'finite' && surfaceSessions) {
+                            void surfaceSessions.reapStale({ excludeSessionId: boundSessionId })
+                                .then(() => ({ error: undefined }), error => ({ error: CaughtFailureSchema.parse(error) }))
+                                .then(outcome => {
+                                if (outcome.error !== undefined)
+                                    logger.warn('stale-session reap failed', { error: valueFreeFailure(outcome.error) });
+                            });
+                        }
+                    }
+                    if (boundSessionId) {
+                        await rebindWorkspaceEnvironmentForSession(runtime, boundSessionId);
+                    }
+                    else {
+                        await rebindWorkspaceEnvironmentForActiveSession(runtime);
+                    }
+                    // Runtime-native bootstrap: announce the bound session so brain,
+                    // presence and awareness pick it up for ALL harnesses at once
+                    // (scope.qualifiers.sessionId via the scope subscription, and a
+                    // turn.start awareness event) — no per-harness code.
+                    await announceSessionBound(runtime, {
+                        surface: 'mcp',
+                        sessionId: boundSessionId
+                    });
+                }
+                logger.info('Session context initialized');
+            })().then(() => ({ error: undefined }), error => ({ error: CaughtFailureSchema.parse(error) }));
+            if (outcome.error !== undefined)
+                logger.warn('Session context initialization failed', { error: valueFreeFailure(outcome.error) });
+        };
+        const sessionToolsSelected = hasSessionTools(selectedTools.descriptors);
+        if (runtime.hasContext('session/manager')) {
+            if (mode === 'http') {
+                if (sessionToolsSelected) {
+                    await initializeSessionContext();
+                    logger.info('Session context initialized during HTTP startup for session tools');
+                }
+                else {
+                    logger.info('Session context warm-up skipped during HTTP startup');
+                }
+            }
+            else {
+                await initializeSessionContext();
+            }
+        }
+        const envTimeout = runtime.getEnv('MCP_TOOL_TIMEOUT_MS');
+        const toolTimeoutMs = envTimeout ? parseInt(envTimeout, 10) : 10 * 60 * 1000;
+        const logLevel = z.enum(['debug', 'info', 'warn', 'error']).optional().parse(runtime.getEnv('MCP_LOG_LEVEL'));
+        const preloadTargets = parsePreloadKnowledgeBases(opts.preloadKnowledgeBases);
+        // Session authority belongs to the serving host, not an implementation
+        // generation. Retain the same manager and its connection/persistence maps.
+        const { registerHostBinding } = await import('@vibesdotdev/kernel/reload');
+        if (runtime.hasContext('session/manager')) {
+            const descriptor = runtime.assets('context').descriptor('session/manager');
+            if (descriptor)
+                registerHostBinding(runtime, ContextDescriptorSchema.parse(descriptor), await runtime.context('session/manager'));
+        }
+        const { startHostHotReload } = await import('@vibesdotdev/kernel-rpc/daemon/host-hot-reload');
+        const hotReload = runtime.scope.lifecycle === 'finite'
+            ? { enabled: false, reason: 'finite lifecycle' }
+            : await startHostHotReload(runtime, { installedUpdates: true, log: logger, validateCandidate: validateMcpGeneration });
+        if (hotReload.enabled) {
+            runtime = hotReload.runtime;
+            if (runtime.hasContext('session/manager')) {
+                const manager = await runtime.context('session/manager');
+                manager.bindRuntime(runtime);
+            }
+        }
+        if (mode === 'http') {
+            logger.debug('Entering HTTP serve branch');
+            // Workspace-scoped, not machine-global: an unset --port yields the port
+            // THIS workspace owns (cli/mcp/support/host-port.ts). An explicit
+            // --port is honoured exactly as given.
+            const { resolveMcpHostPort } = await import("../mcp/support/host-port.js");
+            const port = resolveMcpHostPort({ explicitPort: opts.port, workspaceRoot, env: host.getEnvSnapshot() });
+            // This host start's relay attestation (RC08 U7), on secrets' local
+            // attestation: a fresh secret in a 0600 claim beside the host claim.
+            // Only a relay that read it is attested; it rotates on every start and
+            // is withdrawn at stop.
+            const { createLocalAttestation } = await import('@vibesdotdev/secrets/attestation');
+            const { mcpRelayAttestationPath } = await import("../../adapters/mcp/host-registry.js");
+            const localAttestation = await createLocalAttestation({ claimPath: mcpRelayAttestationPath(workspaceRoot, getPathRoots(runtime)) }, runtime);
+            const relayAttestation = relayAttestationVerifier(localAttestation);
+            logger.debug('Creating MCP HTTP adapter');
+            const mcpSettings = await loadMcpConfig(runtime);
+            const adapter = createMcpAdapter(runtime, {
+                mode: 'http',
+                mcpClientId,
+                customPresets: configuredPresets,
+                preset: identity.preset,
+                toolPatterns: identity.toolPatterns,
+                port,
+                host: mcpSettings.httpHost,
+                relayAttestation,
+                logLevel,
+                toolExecutionTimeoutMs: toolTimeoutMs,
+                preloadedKnowledgeBaseIds: preloadTargets,
+                localToolIds,
+                buildProvenance: provenance.provenanceString,
+                staleBodyBanner: () => staleBodyBanner(runtime, hostIdentity),
+                scopedValues
+            }, logger);
+            logger.debug('Starting MCP HTTP adapter');
+            await adapter.start();
+            logger.debug('MCP HTTP adapter started');
+            // Self-heal for a replaced executable: banner on every result (stale-body.ts)
+            // and, for this managed body, a PM-rolled restart once the new file settles.
+            const freshnessWatch = runtime.scope.lifecycle === 'finite' || !hostIdentity ? null : startExecutableFreshnessWatch({ mode: 'http', runtime, workspaceRoot, managedProcessId: runtime.localEnvironment.managedProcessId?.() ?? null, identity: hostIdentity, logger, publishUpdate: hotReload.enabled ? () => hotReload.publishUpdate() : undefined });
+            // Advertise for relay clients. Written only AFTER a successful start,
+            // so a claim never points at a server that failed to bind.
+            const { writeHostClaim, clearHostClaim } = await import("../../adapters/mcp/host-registry.js");
+            const hostWorkspaceRoot = workspaceRoot;
+            // The claim names this process by the host's declared pid.
+            const hostPid = hostIdentity?.currentPid() ?? null;
+            const advertised = await (async () => {
+                if (hostPid === null) {
+                    throw new CapabilityError('The host declares no process identity, so this process cannot name itself in a host claim.', 'UNAVAILABLE', { reason: 'host-identity-unavailable' });
+                }
+                await writeHostClaim(runtime, {
+                    pid: hostPid,
+                    port,
+                    workspaceRoot: hostWorkspaceRoot,
+                    startedAt: new Date().toISOString(),
+                    // Advertise what this host actually serves so a relay can refuse
+                    // a catalog it cannot honour instead of silently substituting.
+                    presetId: selectedTools.presetId,
+                    presetPolicyKey: purposePresetPolicyKey(customPresets),
+                    catalogAttachKey: mcpCatalogAttachKey(selectedTools.presetId, customPresets),
+                    clientId: mcpClientId
+                }, getPathRoots(runtime));
+                logger.info('MCP host advertised for relay clients', {
+                    port,
+                    workspaceRoot: hostWorkspaceRoot
+                });
+            })().then(() => ({ error: undefined }), error => ({ error: CaughtFailureSchema.parse(error) }));
+            if (advertised.error !== undefined)
+                logger.warn('Could not advertise MCP host; relay clients cannot discover it', { error: valueFreeFailure(advertised.error) });
+            void triggerProgressiveIndexingInBackground(runtime, logger);
+            const lifetime = await createCLIActionLifetime(runtime, async () => {
+                freshnessWatch?.stop();
+                // Withdraw before shutting down, so a relay never attaches to a
+                // server that is on its way out — but only OUR claim: a stray body
+                // sharing this root must not un-advertise the live managed host.
+                const withdrawn = await localAttestation.dispose().then(() => ({ error: undefined }), error => ({ error: CaughtFailureSchema.parse(error) }));
+                if (withdrawn.error !== undefined)
+                    logger.warn('Could not withdraw the MCP relay attestation claim', { error: valueFreeFailure(withdrawn.error) });
+                if (hostPid !== null) {
+                    const cleared = await clearHostClaim(runtime, hostWorkspaceRoot, getPathRoots(runtime), { pid: hostPid, logger }).then(() => ({ error: undefined }), error => ({ error: CaughtFailureSchema.parse(error) }));
+                    if (cleared.error !== undefined)
+                        logger.warn('Could not withdraw the MCP host claim', { error: valueFreeFailure(cleared.error) });
+                }
+                const announced = await announceSessionUnbound(runtime, { surface: 'mcp', reason: 'signal' }).then(() => ({ error: undefined }), error => ({ error: CaughtFailureSchema.parse(error) }));
+                if (announced.error !== undefined)
+                    logger.warn('Could not announce MCP session closure', { error: valueFreeFailure(announced.error) });
+                removeCrashIsolation();
+                await adapter.shutdown();
+                if (hotReload.enabled)
+                    await hotReload.stop();
+            });
+            lifetime.bindProcessSignals();
+            await lifetime.wait();
+        }
+        else {
+            let resolvedStdinError = null;
+            let requestTransportClose = () => { };
+            let freshnessWatch = null;
+            const adapter = createMcpAdapter(runtime, {
+                mode: 'stdio',
+                mcpClientId,
+                customPresets: configuredPresets,
+                // The launch identity the spawning harness established: verified (RC08 U7).
+                verifiedConnectionIdentity: stdioConnectionIdentity ? { source: STDIO_LAUNCH_SOURCE, caller: stdioConnectionIdentity } : undefined,
+                preset: identity.preset,
+                toolPatterns: identity.toolPatterns,
+                logLevel,
+                toolExecutionTimeoutMs: toolTimeoutMs,
+                preloadedKnowledgeBaseIds: preloadTargets,
+                localToolIds,
+                buildProvenance: provenance.provenanceString,
+                staleBodyBanner: () => staleBodyBanner(runtime, hostIdentity),
+                isolation,
+                scopedValues,
+                onStdioClose: async () => {
+                    logger.debug('stdio transport closed');
+                    requestTransportClose();
+                }
+            }, logger);
+            const lifetime = await createCLIActionLifetime(runtime, async (reason) => {
+                logger.debug(`shutting down stdio server: ${reason}`);
+                // Every step runs; a failed step never blocks the rest, and the
+                // teardown then rejects typed so the lifetime observes it.
+                await runTeardown(logger, [
+                    // Close-half of announceSessionBound: emit session.unbound → turn.end
+                    // before the runtime tears down.
+                    ['session.unbound announcement', () => announceSessionUnbound(runtime, { surface: 'mcp', reason, sessionId: getBoundStdioSessionId(runtime) })],
+                    ['freshness watch', () => freshnessWatch?.stop()],
+                    // Close-half of bindFreshStdioSession (L-03): archive this process's
+                    // minted session so clean exits leave no active-session leak behind.
+                    ['stdio session archive', () => archiveBoundStdioSession(runtime)],
+                    ['crash reporting', () => removeCrashIsolation()],
+                    ['adapter shutdown', () => adapter.shutdown()],
+                    ['hot reload', () => (hotReload.enabled ? hotReload.stop() : undefined)],
+                    ['stdout capture close', () => stdoutCapture?.close()]
+                ]);
+            });
+            requestTransportClose = () => {
+                // The owner action's lifetime.wait() observes a cleanup failure.
+                void lifetime.request('transport-close');
+            };
+            await adapter.start();
+            // A stdio body cannot restart itself (its client owns it); the watch
+            // announces a replaced executable on every result and asks for help.
+            freshnessWatch = runtime.scope.lifecycle === 'finite' || !hostIdentity ? null : startExecutableFreshnessWatch({ mode: 'stdio', runtime, workspaceRoot, managedProcessId: runtime.localEnvironment.managedProcessId?.() ?? null, identity: hostIdentity, logger, publishUpdate: hotReload.enabled ? () => hotReload.publishUpdate() : undefined });
+            void triggerProgressiveIndexingInBackground(runtime, logger);
+            lifetime.bindProcessSignals();
+            const onStdinEnd = () => {
+                void lifetime.request('stdin-end');
+            };
+            const onStdinClose = () => {
+                void lifetime.request('stdin-close');
+            };
+            const onStdinError = (err) => {
+                resolvedStdinError = err ?? new CapabilityError('The stdin error event supplied no failure.', 'INVALID_INPUT', { reason: 'stdin-error-invalid' });
+                logger.error('stdin failed', { failure: valueFreeFailure(CaughtFailureSchema.parse(resolvedStdinError)) });
+                void lifetime.request('stdin-error');
+            };
+            const stdinEvents = await getRuntimeStdinEvents(runtime);
+            const detachStdin = [
+                stdinEvents.subscribeStdin('end', onStdinEnd),
+                stdinEvents.subscribeStdin('close', onStdinClose),
+                stdinEvents.subscribeStdin('error', onStdinError)
+            ];
+            // A pending promise is not an event-loop handle: while the lifetime is
+            // open, this runtime-owned tick keeps the serving process alive. It is
+            // the runtime's timer (RC07), cleared on dispose. A finite host refuses
+            // background intervals; that refusal is honoured (no keep-alive).
+            // The command's own runtime, not a hot-reload generation: a reload
+            // disposes its generation, and the serving process must outlive it.
+            const keepAlive = startLifecycleRepeat(host.lifecycle, 60_000, () => { });
+            if (keepAlive.kind === 'refused')
+                logger.debug('finite host: no stdio keep-alive tick', { reason: keepAlive.refusal.reason });
+            try {
+                await lifetime.wait();
+            }
+            finally {
+                if (keepAlive.kind === 'repeating')
+                    keepAlive.stop();
+                for (const detach of detachStdin)
+                    detach();
+            }
+            if (resolvedStdinError)
+                requestCLIExit(1, { cause: CaughtFailureSchema.parse(resolvedStdinError) });
+        }
+    })().then(() => ({ error: undefined }), error => ({ error: CaughtFailureSchema.parse(error) }));
+    if (action.error !== undefined) {
+        if (isCLIExitSignal(action.error))
+            throw action.error;
+        stdio.write('stderr', `FATAL: Failed to start MCP server: ${JSON.stringify(valueFreeFailure(action.error))}\n`);
+        requestCLIExit(1, { cause: action.error });
+    }
+}
+export default createRuntimeImplementation({
+    id: 'dev.mcp.serve',
+    kind: 'cli/command',
+    constraint: { hardware: ['consumer'] },
+    implementation: {
+        execute: executeMcpCommand,
+        // A default stdio relay runs on a transport host (CLI floor + entry): what it
+        // needs there before attaching to the shared body (see stdio-relay-transport.ts).
+        transportPlugins: stdioRelayTransportPlugins
+    }
+});
+//# sourceMappingURL=dev.mcp.serve.impl.consumer.js.map