@praxis-ai/praxis 0.1.4 → 0.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@praxis-ai/praxis",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "private": false,
   "type": "module",
   "description": "Praxis agentCore architecture scaffold, tests, and engineering contracts.",
@@ -129,6 +129,8 @@
     "example:minimal": "node --import tsx examples/minimal/runRepoInspector.ts",
     "example:fullstack": "node --import tsx examples/fullstack/runRepoInspector.ts",
     "smoke:agentCore": "node --import tsx examples/scripts/agentcore_smoke.ts",
+    "smoke:mcp-external-transport": "node --import tsx examples/scripts/agentcore_mcp_external_transport_smoke.ts --no-model",
+    "smoke:mcp-plus-native": "node --import tsx examples/scripts/mcp-plus-native-smoke.ts",
     "smoke:modelAdapter": "node --import tsx examples/scripts/modelAdapter_smoke.ts",
     "raxode:typecheck": "tsc -p raxode-tui/tsconfig.json --noEmit",
     "raxode:test:backend": "cd raxode-tui && node --import tsx --test raxode-cli/frontend/bridge/*.test.ts raxode-cli/frontend/tui/cli/*.test.ts raxode-cli/frontend/tui/input/*.test.ts raxode-cli/backend/tests/*.test.ts",

package/raxode-tui/dist/raxode-cli/backend/agents/codingAgent/prompts/tool-use.md

@@ -21,6 +21,6 @@ Tool use rules:
 - For prices, quotes, news, or other time-sensitive facts, do not answer from a prepared search request or an empty-source native search result. Report the source, timestamp/market date, and unit when available.
 - Browser, computer-use, image, audio, and media tools are optional extension tools. If they are not mounted in the current toolDeclarations, do not pretend they are available. Use deterministic shell, file, and web evidence when those optional tools are absent.
 - Use `web.search` and `web.fetch` for current external information and source-backed answers when they are mounted.
-- Use `mcp.use`, `mcp.resources`, and `skill.load` through their declared Praxis basetool surfaces.
+- Use `mcp.use`, `mcp.resources`, `mcp.prompts`, and `skill.load` through their declared Praxis basetool surfaces.
 - Use `tool.discover` and `tool.describe` when you need to confirm mounted tools or get tool-specific guidance.
 - Destructive actions must follow the active permission profile and application approval surface.

package/raxode-tui/dist/raxode-cli/backend/application/mcpConfig.d.ts

@@ -0,0 +1,9 @@
+import type { CreateApplicationProjectRuntimeOptions } from "@praxis-ai/praxis/application-layer";
+import { type RaxodeMcpConfig } from "../../frontend/tui/config/raxode-config.js";
+import { type RaxodeMcpReadinessSummary } from "./mcpReadinessSummary.js";
+type RuntimeMcpPlusOptions = CreateApplicationProjectRuntimeOptions["mcpPlus"];
+export declare function loadRaxodeMcpRuntimeOptions(fallbackDir?: string): Pick<CreateApplicationProjectRuntimeOptions, "mcpServers" | "mcpPlus">;
+export declare function createRaxodeMcpRuntimeOptions(config: RaxodeMcpConfig): Pick<CreateApplicationProjectRuntimeOptions, "mcpServers" | "mcpPlus">;
+export declare function loadRaxodeMcpReadinessSummary(fallbackDir?: string): RaxodeMcpReadinessSummary;
+export declare function mergeRaxodeMcpPlusRuntimeOptions(configured: RuntimeMcpPlusOptions, explicit: RuntimeMcpPlusOptions): RuntimeMcpPlusOptions;
+export {};

package/raxode-tui/dist/raxode-cli/backend/application/mcpConfig.js

@@ -0,0 +1,65 @@
+import { loadRaxodeMcpConfig, } from "../../frontend/tui/config/raxode-config.js";
+import { createRaxodeMcpReadinessSummary, } from "./mcpReadinessSummary.js";
+function runtimeMcpServerFromConfig(server) {
+    const common = {
+        serverId: server.serverId,
+        mode: server.mode,
+        title: server.title,
+        summary: server.summary,
+        timeoutMs: server.timeoutMs,
+        manifest: server.manifest,
+        metadata: {
+            ...(server.metadata ?? {}),
+            source: "raxode.config.mcp",
+        },
+    };
+    if (server.transport === "stdio") {
+        return {
+            ...common,
+            transport: "stdio",
+            command: server.command,
+            args: server.args,
+            cwd: server.cwd,
+            env: server.env,
+            framing: server.framing,
+        };
+    }
+    return {
+        ...common,
+        transport: server.transport,
+        url: server.url,
+        sseUrl: server.sseUrl,
+        headers: server.headers,
+    };
+}
+export function loadRaxodeMcpRuntimeOptions(fallbackDir = process.cwd()) {
+    return createRaxodeMcpRuntimeOptions(loadRaxodeMcpConfig(fallbackDir));
+}
+export function createRaxodeMcpRuntimeOptions(config) {
+    const servers = config.servers
+        .filter((server) => server.enabled)
+        .map(runtimeMcpServerFromConfig);
+    const mcpPlus = config.projectId === undefined && config.reprofileConsecutiveIndexedCalls === undefined
+        ? undefined
+        : {
+            projectId: config.projectId,
+            reprofileConsecutiveIndexedCalls: config.reprofileConsecutiveIndexedCalls,
+        };
+    return {
+        ...(servers.length === 0 ? {} : { mcpServers: servers }),
+        ...(mcpPlus === undefined ? {} : { mcpPlus }),
+    };
+}
+export function loadRaxodeMcpReadinessSummary(fallbackDir = process.cwd()) {
+    return createRaxodeMcpReadinessSummary(loadRaxodeMcpConfig(fallbackDir));
+}
+export function mergeRaxodeMcpPlusRuntimeOptions(configured, explicit) {
+    if (configured === undefined)
+        return explicit;
+    if (explicit === undefined)
+        return configured;
+    return {
+        ...configured,
+        ...explicit,
+    };
+}

package/raxode-tui/dist/raxode-cli/backend/application/mcpReadinessSummary.d.ts

@@ -0,0 +1,28 @@
+import type { CreateApplicationProjectRuntimeOptions } from "@praxis-ai/praxis/application-layer";
+import type { RaxodeMcpConfig } from "../../frontend/tui/config/raxode-config.js";
+export type RaxodeMcpReadinessSummary = {
+    kind: "raxode.mcpReadinessSummary";
+    schemaVersion: "raxode.mcpReadinessSummary.v1";
+    configuredServerCount: number;
+    enabledServerCount: number;
+    disabledServerCount: number;
+    enabledMcpPlusServerCount: number;
+    enabledNativeServerCount: number;
+    configuredServerIds: readonly string[];
+    enabledServerIds: readonly string[];
+    enabledMcpPlusServerIds: readonly string[];
+    enabledNativeServerIds: readonly string[];
+    recommendedMode: "mcp-plus";
+    nativeCompatible: true;
+    publicSafe: true;
+    profileIdentity: "serverId+project";
+    runtimeOverlayIdentity: "serverId+session";
+    schemaRefreshBoundary: "session-checkpoint";
+    projectId?: string;
+    reprofileConsecutiveIndexedCalls?: number;
+};
+export declare function createRaxodeMcpReadinessSummary(config?: RaxodeMcpConfig): RaxodeMcpReadinessSummary;
+export declare function createRaxodeMcpReadinessSummaryFromRuntimeOptions(input: {
+    mcpServers?: CreateApplicationProjectRuntimeOptions["mcpServers"];
+    mcpPlus?: CreateApplicationProjectRuntimeOptions["mcpPlus"];
+}): RaxodeMcpReadinessSummary;

package/raxode-tui/dist/raxode-cli/backend/application/mcpReadinessSummary.js

@@ -0,0 +1,57 @@
+/*
+ * 文件定位：raxode-cli / MCP readiness summary。
+ * 核心目的：把 Raxode MCP 配置转成 public-safe 的 runtime readiness 事实，不泄露 command/env/header。
+ */
+export function createRaxodeMcpReadinessSummary(config) {
+    const servers = config?.servers ?? [];
+    const enabled = servers.filter((server) => server.enabled);
+    const mcpPlus = enabled.filter((server) => server.mode === "mcp-plus");
+    const native = enabled.filter((server) => server.mode === "native");
+    return {
+        kind: "raxode.mcpReadinessSummary",
+        schemaVersion: "raxode.mcpReadinessSummary.v1",
+        configuredServerCount: servers.length,
+        enabledServerCount: enabled.length,
+        disabledServerCount: servers.length - enabled.length,
+        enabledMcpPlusServerCount: mcpPlus.length,
+        enabledNativeServerCount: native.length,
+        configuredServerIds: servers.map((server) => server.serverId),
+        enabledServerIds: enabled.map((server) => server.serverId),
+        enabledMcpPlusServerIds: mcpPlus.map((server) => server.serverId),
+        enabledNativeServerIds: native.map((server) => server.serverId),
+        recommendedMode: "mcp-plus",
+        nativeCompatible: true,
+        publicSafe: true,
+        profileIdentity: "serverId+project",
+        runtimeOverlayIdentity: "serverId+session",
+        schemaRefreshBoundary: "session-checkpoint",
+        projectId: config?.projectId,
+        reprofileConsecutiveIndexedCalls: config?.reprofileConsecutiveIndexedCalls,
+    };
+}
+export function createRaxodeMcpReadinessSummaryFromRuntimeOptions(input) {
+    const servers = input.mcpServers ?? [];
+    const mcpPlus = servers.filter((server) => server.mode === "mcp-plus");
+    const native = servers.filter((server) => server.mode === "native");
+    return {
+        kind: "raxode.mcpReadinessSummary",
+        schemaVersion: "raxode.mcpReadinessSummary.v1",
+        configuredServerCount: servers.length,
+        enabledServerCount: servers.length,
+        disabledServerCount: 0,
+        enabledMcpPlusServerCount: mcpPlus.length,
+        enabledNativeServerCount: native.length,
+        configuredServerIds: servers.map((server) => server.serverId),
+        enabledServerIds: servers.map((server) => server.serverId),
+        enabledMcpPlusServerIds: mcpPlus.map((server) => server.serverId),
+        enabledNativeServerIds: native.map((server) => server.serverId),
+        recommendedMode: "mcp-plus",
+        nativeCompatible: true,
+        publicSafe: true,
+        profileIdentity: "serverId+project",
+        runtimeOverlayIdentity: "serverId+session",
+        schemaRefreshBoundary: "session-checkpoint",
+        projectId: input.mcpPlus?.projectId,
+        reprofileConsecutiveIndexedCalls: input.mcpPlus?.reprofileConsecutiveIndexedCalls,
+    };
+}

package/raxode-tui/dist/raxode-cli/backend/application/runtimeReadiness.d.ts

@@ -2,9 +2,10 @@ import type { AgentManifest, DependencyDeclaration } from "@praxis-ai/praxis";
 import type { PraxisApplicationEvent, PraxisApplicationViewModel } from "@praxis-ai/praxis/application-layer";
 import type { RaxodeOptions } from "../agents/codingAgent/config/raxodeOptions.js";
 import { type RaxodeBackendModuleInventory } from "./backendModuleInventory.js";
+import { type RaxodeMcpReadinessSummary } from "./mcpReadinessSummary.js";
 import { type RaxodeDependencyProbe, type RaxodeLocalReadinessProbe, type RaxodeLocalReadinessProbeInput } from "./localReadinessProbe.js";
 export type RaxodeReadinessStatus = "ready" | "passive-ready" | "contract-ready" | "degraded" | "missing";
-export type RaxodeReadinessOwner = "basetool" | "promptPack" | "applicationLayer" | "runtime" | "authPlane" | "dependencyPlane" | "sandboxPlane" | "cachePlane" | "multiagentPlane";
+export type RaxodeReadinessOwner = "basetool" | "promptPack" | "applicationLayer" | "runtime" | "authPlane" | "dependencyPlane" | "sandboxPlane" | "cachePlane" | "multiagentPlane" | "mcpPlane";
 export type RaxodeReadinessPhase = "implemented" | "passive" | "declared" | "adapter-ready" | "missing";
 export type RaxodeReadinessSeverity = "ok" | "info" | "warning" | "blocking";
 export type RaxodeReadinessArea = {
@@ -40,6 +41,7 @@ export type RaxodeBackendReadiness = {
         expectedCoreToolIds: readonly string[];
         mountedToolIds: readonly string[];
     };
+    mcp: RaxodeMcpReadinessSummary;
     dependencies: readonly {
         dependencyId: string;
         kind: DependencyDeclaration["kind"];
@@ -82,6 +84,7 @@ export declare function inspectRaxodeBackendReadiness(input?: {
     now?: () => string;
     probe?: RaxodeLocalReadinessProbe;
     ports?: Partial<RaxodeBackendReadiness["ports"]>;
+    mcp?: RaxodeMcpReadinessSummary;
 }): RaxodeBackendReadiness;
 export declare function inspectRaxodeBackendReadinessWithLocalProbe(input?: {
     manifest?: AgentManifest;
@@ -90,6 +93,7 @@ export declare function inspectRaxodeBackendReadinessWithLocalProbe(input?: {
     now?: () => string;
     localProbe?: Omit<RaxodeLocalReadinessProbeInput, "manifest">;
     ports?: Partial<RaxodeBackendReadiness["ports"]>;
+    mcp?: RaxodeMcpReadinessSummary;
 }): RaxodeBackendReadiness;
 export declare function createRaxodeReadinessEvent(input: {
     readiness: RaxodeBackendReadiness;

package/raxode-tui/dist/raxode-cli/backend/application/runtimeReadiness.js

@@ -10,6 +10,7 @@ import { mpBridge } from "../memory/memoryBridge.js";
 import { providerProfiles } from "../authentication/providerProfiles.js";
 import { inspectRaxodeMultiagentTopology, topology } from "../topology/multiagentTopology.js";
 import { createRaxodeBackendModuleInventory, } from "./backendModuleInventory.js";
+import { createRaxodeMcpReadinessSummary, } from "./mcpReadinessSummary.js";
 import { probeLocalRaxodeReadiness, } from "./localReadinessProbe.js";
 const EXPECTED_AGENT_CORE_TOOL_IDS = [
     "shell.run",
@@ -32,6 +33,8 @@ const EXPECTED_AGENT_CORE_TOOL_IDS = [
     "agent.kill",
     "mcp.use",
     "mcp.resources",
+    "mcp.prompts",
+    "mcp.completions",
     "process.wait",
     "process.kill",
     "media.viewImage",
@@ -117,6 +120,7 @@ export function inspectRaxodeBackendReadiness(input = {}) {
     const providerRoute = typeof manifest.model.metadata?.providerRoute === "string"
         ? manifest.model.metadata.providerRoute
         : undefined;
+    const mcpSummary = input.mcp ?? createRaxodeMcpReadinessSummary();
     const modelRouteReady = providerProfiles.primary.authSource === "codex-openai-profile"
         && (providerRoute !== undefined || manifest.model.endpointShape !== undefined);
     const areas = [
@@ -177,6 +181,40 @@ export function inspectRaxodeBackendReadiness(input = {}) {
                 surfaces: cmpBridge.surfaces,
             },
         },
+        {
+            area: "mcp",
+            status: "ready",
+            owner: "mcpPlane",
+            phase: "implemented",
+            severity: "ok",
+            summary: "MCP is mounted as a first-class runtime plane with bare MCP compatibility and MCP+ as the recommended exposure layer.",
+            evidence: [
+                `configured=${mcpSummary.configuredServerCount}`,
+                `enabled=${mcpSummary.enabledServerCount}`,
+                `mcpPlus=${mcpSummary.enabledMcpPlusServerCount}`,
+                `native=${mcpSummary.enabledNativeServerCount}`,
+                `schemaRefreshBoundary=${mcpSummary.schemaRefreshBoundary}`,
+                `profileIdentity=${mcpSummary.profileIdentity}`,
+            ],
+            facts: {
+                configuredServerCount: mcpSummary.configuredServerCount,
+                enabledServerCount: mcpSummary.enabledServerCount,
+                disabledServerCount: mcpSummary.disabledServerCount,
+                enabledMcpPlusServerCount: mcpSummary.enabledMcpPlusServerCount,
+                enabledNativeServerCount: mcpSummary.enabledNativeServerCount,
+                configuredServerIds: mcpSummary.configuredServerIds,
+                enabledServerIds: mcpSummary.enabledServerIds,
+                enabledMcpPlusServerIds: mcpSummary.enabledMcpPlusServerIds,
+                enabledNativeServerIds: mcpSummary.enabledNativeServerIds,
+                recommendedMode: mcpSummary.recommendedMode,
+                nativeCompatible: mcpSummary.nativeCompatible,
+                profileIdentity: mcpSummary.profileIdentity,
+                runtimeOverlayIdentity: mcpSummary.runtimeOverlayIdentity,
+                schemaRefreshBoundary: mcpSummary.schemaRefreshBoundary,
+                projectId: mcpSummary.projectId ?? "",
+                reprofileConsecutiveIndexedCalls: mcpSummary.reprofileConsecutiveIndexedCalls ?? 0,
+            },
+        },
         {
             area: "memory",
             status: mpBridge.status,
@@ -377,6 +415,7 @@ export function inspectRaxodeBackendReadiness(input = {}) {
             expectedCoreToolIds: EXPECTED_AGENT_CORE_TOOL_IDS,
             mountedToolIds: manifest.harness.tools.map((tool) => tool.toolId),
         },
+        mcp: mcpSummary,
         dependencies: manifest.dependencies.map((dependency) => dependencySummary(dependency, dependencyProbes.get(dependency.dependencyId))),
         policy: {
             permissionProfile: view?.permissionProfile ?? manifest.toolPolicy.profile,
@@ -424,6 +463,7 @@ export function inspectRaxodeBackendReadinessWithLocalProbe(input = {}) {
         now: input.now,
         probe,
         ports: input.ports,
+        mcp: input.mcp,
     });
 }
 export function createRaxodeReadinessEvent(input) {

package/raxode-tui/dist/raxode-cli/backend/application/stdioApplicationServer.js

@@ -8,6 +8,7 @@ import { createApplicationProjectRuntime, createLocalApplicationTransport, } fro
 import { createRaxodeLiveProvider, resolveRaxodeConfiguredModelOptions, } from "../authentication/liveProvider.js";
 import { inspectRaxodeMemoryBridge } from "../memory/memoryBridge.js";
 import { raxodeApplication } from "./raxodeApplication.js";
+import { loadRaxodeMcpReadinessSummary, loadRaxodeMcpRuntimeOptions, } from "./mcpConfig.js";
 import { resolveRaxodeRaxcellSandboxProvider } from "./raxcellSandboxProvider.js";
 import { createRaxodeReadinessEvent, inspectRaxodeBackendReadinessWithLocalProbe, } from "./runtimeReadiness.js";
 function defaultProjectRoot() {
@@ -78,6 +79,8 @@ export async function startRaxodeStdioApplicationServer(options = {}) {
         sandboxProfile: options.sandboxProfile,
         sandboxProvider: options.sandboxProvider,
     });
+    const configuredMcp = loadRaxodeMcpRuntimeOptions(startDir);
+    const mcpReadiness = loadRaxodeMcpReadinessSummary(startDir);
     const created = await createApplicationProjectRuntime(projectRoot, {
         applicationId: raxodeApplication.id,
         cwd: startDir,
@@ -94,6 +97,8 @@ export async function startRaxodeStdioApplicationServer(options = {}) {
         agentOptions,
         sandboxProvider,
         now: options.now,
+        mcpServers: configuredMcp.mcpServers,
+        mcpPlus: configuredMcp.mcpPlus,
         liveProviderResolver: async (manifest, context) => createRaxodeLiveProvider(manifest, {
             startDir,
             sessionId: context?.sessionId,
@@ -134,6 +139,7 @@ export async function startRaxodeStdioApplicationServer(options = {}) {
                     options: agentOptions,
                     now: options.now,
                     localProbe: options.localReadinessProbe,
+                    mcp: mcpReadiness,
                     ports: {
                         sandboxProvider: sandboxProvider ? "configured" : "not-configured",
                         liveProviderResolver: "configured",

package/raxode-tui/dist/raxode-cli/backend/directApplicationBackend.d.ts

@@ -19,6 +19,10 @@ type DirectApplicationBackendOptions = RaxodeOptions & {
     preCompactGovernanceEnabled?: CreateApplicationProjectRuntimeOptions["preCompactGovernanceEnabled"];
     compactContextWindowTokens?: CreateApplicationProjectRuntimeOptions["compactContextWindowTokens"];
     compactThresholdRatio?: CreateApplicationProjectRuntimeOptions["compactThresholdRatio"];
+    mcpServers?: CreateApplicationProjectRuntimeOptions["mcpServers"];
+    mcpPlusServers?: CreateApplicationProjectRuntimeOptions["mcpPlusServers"];
+    mcpModule?: CreateApplicationProjectRuntimeOptions["mcpModule"];
+    mcpPlus?: CreateApplicationProjectRuntimeOptions["mcpPlus"];
     sandboxProvider?: SandboxExecutionProviderPort;
     localReadinessProbe?: Omit<RaxodeLocalReadinessProbeInput, "manifest">;
 };

package/raxode-tui/dist/raxode-cli/backend/directApplicationBackend.js

@@ -6,6 +6,8 @@ import { mkdir, appendFile } from "node:fs/promises";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { inspectRaxodeMemoryBridge } from "./memory/memoryBridge.js";
+import { loadRaxodeMcpRuntimeOptions, mergeRaxodeMcpPlusRuntimeOptions, } from "./application/mcpConfig.js";
+import { createRaxodeMcpReadinessSummaryFromRuntimeOptions } from "./application/mcpReadinessSummary.js";
 import { resolveRaxodeRaxcellSandboxProvider } from "./application/raxcellSandboxProvider.js";
 import { loadDirectTuiSessionSnapshot, listDirectTuiAgents, saveDirectTuiAgent, saveDirectTuiSessionSnapshot, } from "../frontend/tui/input/direct-session-store.js";
 function defaultProjectRoot() {
@@ -897,6 +899,13 @@ export async function startDirectApplicationBackend(options = {}) {
     const reasoningEffort = options.reasoningEffort ?? modelOptions.reasoningEffort;
     const maxOutputTokens = options.maxOutputTokens ?? modelOptions.maxOutputTokens;
     const compactOptions = resolveDirectCompactOptions(options);
+    const configuredMcp = loadRaxodeMcpRuntimeOptions(cwd);
+    const mcpServers = options.mcpServers ?? configuredMcp.mcpServers;
+    const mcpPlus = mergeRaxodeMcpPlusRuntimeOptions(configuredMcp.mcpPlus, options.mcpPlus);
+    const mcpReadiness = createRaxodeMcpReadinessSummaryFromRuntimeOptions({
+        mcpServers,
+        mcpPlus,
+    });
     const projectRoot = path.resolve(options.projectRoot ?? defaultProjectRoot());
     const memoryBridge = await inspectRaxodeMemoryBridge({
         projectRoot,
@@ -944,6 +953,10 @@ export async function startDirectApplicationBackend(options = {}) {
         preCompactGovernanceEnabled: options.preCompactGovernanceEnabled,
         compactContextWindowTokens: compactOptions.compactContextWindowTokens,
         compactThresholdRatio: compactOptions.compactThresholdRatio,
+        mcpServers,
+        mcpPlusServers: options.mcpPlusServers,
+        mcpModule: options.mcpModule,
+        mcpPlus,
         liveProviderResolver: options.liveProviderResolver ?? (async (manifest, context) => liveProviderModule.createRaxodeLiveProvider(manifest, {
             startDir: cwd,
             sessionId: context?.sessionId,
@@ -1060,6 +1073,7 @@ export async function startDirectApplicationBackend(options = {}) {
         options: agentOptions,
         now: options.now,
         localProbe: options.localReadinessProbe,
+        mcp: mcpReadiness,
         ports: {
             approvalResolver: "configured",
             sandboxProvider: sandboxProvider ? "configured" : "not-configured",

package/raxode-tui/dist/raxode-cli/backend/raxodeBackend.d.ts

@@ -13,7 +13,7 @@ export type RaxodeBackendCommand = {
     toolProfile?: PraxisApplicationToolProfile;
 };
 export type RaxodeBackendResult = PraxisApplicationCommandResult;
-type RaxodeBackendRuntimePorts = Pick<CreateApplicationProjectRuntimeOptions, "approvalResolver" | "agentReviewResolver" | "contextArtifactAdapters" | "baseToolAdapters" | "authStateProvider" | "sandboxProvider" | "foundationProject" | "openFoundationProject" | "liveProviderResolver" | "compactExecutor" | "preCompactGovernanceExecutor" | "preCompactGovernanceEnabled" | "compactContextWindowTokens" | "compactThresholdRatio">;
+type RaxodeBackendRuntimePorts = Pick<CreateApplicationProjectRuntimeOptions, "approvalResolver" | "agentReviewResolver" | "contextArtifactAdapters" | "baseToolAdapters" | "authStateProvider" | "sandboxProvider" | "foundationProject" | "openFoundationProject" | "liveProviderResolver" | "compactExecutor" | "preCompactGovernanceExecutor" | "preCompactGovernanceEnabled" | "compactContextWindowTokens" | "compactThresholdRatio" | "mcpServers" | "mcpPlusServers" | "mcpModule" | "mcpPlus">;
 export type RaxodeBackendOptions = RaxodeOptions & RaxodeBackendRuntimePorts & {
     projectRoot?: string;
     cwd?: string;

package/raxode-tui/dist/raxode-cli/backend/raxodeBackend.js

@@ -10,6 +10,8 @@ import { resolveRaxodeRaxcellSandboxProvider } from "./application/raxcellSandbo
 import { createRaxodeAuthStateProvider } from "./authentication/authStateProvider.js";
 import { createRaxodeContextAdapter } from "./context/contextBridge.js";
 import { inspectRaxodeMemoryBridge } from "./memory/memoryBridge.js";
+import { loadRaxodeMcpRuntimeOptions, mergeRaxodeMcpPlusRuntimeOptions, } from "./application/mcpConfig.js";
+import { createRaxodeMcpReadinessSummaryFromRuntimeOptions } from "./application/mcpReadinessSummary.js";
 import { inspectRaxodeBackendReadinessWithLocalProbe, } from "./application/runtimeReadiness.js";
 function configuredRuntimePorts(options) {
     return {
@@ -43,6 +45,13 @@ async function createRaxodeRuntime(options = {}) {
     const reasoningEffort = options.reasoningEffort ?? modelOptions.reasoningEffort;
     const maxOutputTokens = options.maxOutputTokens ?? modelOptions.maxOutputTokens;
     const permissionProfile = options.policyProfile ?? "permissive";
+    const configuredMcp = loadRaxodeMcpRuntimeOptions(startDir);
+    const mcpServers = options.mcpServers ?? configuredMcp.mcpServers;
+    const mcpPlus = mergeRaxodeMcpPlusRuntimeOptions(configuredMcp.mcpPlus, options.mcpPlus);
+    const mcpReadiness = createRaxodeMcpReadinessSummaryFromRuntimeOptions({
+        mcpServers,
+        mcpPlus,
+    });
     const agentOptions = {
         policyProfile: permissionProfile,
         sandboxProfile: options.sandboxProfile,
@@ -104,6 +113,10 @@ async function createRaxodeRuntime(options = {}) {
         preCompactGovernanceEnabled: options.preCompactGovernanceEnabled,
         compactContextWindowTokens: options.compactContextWindowTokens,
         compactThresholdRatio: options.compactThresholdRatio,
+        mcpServers,
+        mcpPlusServers: options.mcpPlusServers,
+        mcpModule: options.mcpModule,
+        mcpPlus,
         liveProviderResolver: options.liveProviderResolver ?? (async (manifest, context) => createRaxodeLiveProvider(manifest, {
             startDir,
             sessionId: context?.sessionId,
@@ -127,10 +140,11 @@ async function createRaxodeRuntime(options = {}) {
             authStateProvider,
             openFoundationProject,
         }),
+        mcpReadiness,
     };
 }
 export async function createRaxodeBackend(options = {}) {
-    const { projectRoot, runtime, readinessOptions, readinessPorts } = await createRaxodeRuntime(options);
+    const { projectRoot, runtime, readinessOptions, readinessPorts, mcpReadiness } = await createRaxodeRuntime(options);
     const transport = createLocalApplicationTransport(runtime);
     return {
         backendId: "applicationLayer",
@@ -145,6 +159,7 @@ export async function createRaxodeBackend(options = {}) {
                 now: options.now,
                 localProbe: options.localReadinessProbe,
                 ports: readinessPorts,
+                mcp: mcpReadiness,
             });
         },
         async dispatch(command) {

package/raxode-tui/dist/raxode-cli/contracts.d.ts

@@ -1,4 +1,5 @@
 export type { PraxisApplicationAttachment as RaxodeApplicationAttachment, PraxisApplicationCommand as RaxodeApplicationCommand, PraxisApplicationCommandResult as RaxodeApplicationBackendResult, PraxisApplicationEvent as RaxodeApplicationEvent, PraxisApplicationInputEnvelope as RaxodeApplicationInputEnvelope, PraxisApplicationPermissionProfile as RaxodeApplicationPermissionProfile, PraxisApplicationReasoningEffort as RaxodeApplicationReasoningEffort, PraxisApplicationRuntimeMode as RaxodeApplicationRunMode, PraxisApplicationStatus as RaxodeApplicationStatus, PraxisApplicationViewModel as RaxodeApplicationViewModel, } from "@praxis-ai/praxis/application-layer";
 export type { RaxodeBackendReadiness, RaxodeReadinessArea, RaxodeReadinessOwner, RaxodeReadinessPhase, RaxodeReadinessSeverity, RaxodeReadinessStatus, } from "./backend/application/runtimeReadiness.js";
+export type { RaxodeMcpReadinessSummary, } from "./backend/application/mcpReadinessSummary.js";
 export type { RaxodeBackendModuleId, RaxodeBackendModuleInventory, RaxodeBackendModuleInventoryItem, RaxodeBackendModuleStatus, } from "./backend/application/backendModuleInventory.js";
 export type { RaxodeDependencyProbe, RaxodeDependencyProbeStatus, RaxodeLocalReadinessProbe, RaxodeSandboxProbe, RaxodeSandboxProbeStatus, } from "./backend/application/localReadinessProbe.js";

package/raxode-tui/dist/raxode-cli/frontend/bridge/readiness.js

@@ -63,6 +63,29 @@ function isReadinessTools(value) {
         isStringArray(record.expectedCoreToolIds) &&
         isStringArray(record.mountedToolIds);
 }
+function isReadinessMcp(value) {
+    const record = recordValue(value);
+    return record !== undefined &&
+        record.kind === "raxode.mcpReadinessSummary" &&
+        record.schemaVersion === "raxode.mcpReadinessSummary.v1" &&
+        typeof record.configuredServerCount === "number" &&
+        typeof record.enabledServerCount === "number" &&
+        typeof record.disabledServerCount === "number" &&
+        typeof record.enabledMcpPlusServerCount === "number" &&
+        typeof record.enabledNativeServerCount === "number" &&
+        isStringArray(record.configuredServerIds) &&
+        isStringArray(record.enabledServerIds) &&
+        isStringArray(record.enabledMcpPlusServerIds) &&
+        isStringArray(record.enabledNativeServerIds) &&
+        record.recommendedMode === "mcp-plus" &&
+        record.nativeCompatible === true &&
+        record.publicSafe === true &&
+        record.profileIdentity === "serverId+project" &&
+        record.runtimeOverlayIdentity === "serverId+session" &&
+        record.schemaRefreshBoundary === "session-checkpoint" &&
+        (record.projectId === undefined || typeof record.projectId === "string") &&
+        (record.reprofileConsecutiveIndexedCalls === undefined || typeof record.reprofileConsecutiveIndexedCalls === "number");
+}
 function isReadinessDependency(value) {
     const record = recordValue(value);
     const probe = recordValue(record?.probe);
@@ -158,6 +181,7 @@ export function isRaxodeBackendReadiness(value) {
         typeof record.storageKind === "string" &&
         isReadinessModel(record.model) &&
         isReadinessTools(record.tools) &&
+        isReadinessMcp(record.mcp) &&
         Array.isArray(record.dependencies) &&
         record.dependencies.every(isReadinessDependency) &&
         isReadinessPolicy(record.policy) &&

package/raxode-tui/dist/raxode-cli/frontend/tui/app/direct-tui.js

@@ -1028,6 +1028,36 @@ function isDirectTuiInitRunningStatus(status) {
         || status === "waiting"
         || status === "started";
 }
+function cloneRaxodeMcpServerConfig(server) {
+    const common = {
+        serverId: server.serverId,
+        mode: server.mode,
+        title: server.title,
+        summary: server.summary,
+        enabled: server.enabled,
+        timeoutMs: server.timeoutMs,
+        manifest: server.manifest ? { ...server.manifest } : undefined,
+        metadata: server.metadata ? { ...server.metadata } : undefined,
+    };
+    if (server.transport === "stdio") {
+        return {
+            ...common,
+            transport: "stdio",
+            command: server.command,
+            args: server.args ? [...server.args] : undefined,
+            cwd: server.cwd,
+            env: server.env ? { ...server.env } : undefined,
+            framing: server.framing,
+        };
+    }
+    return {
+        ...common,
+        transport: server.transport,
+        url: server.url,
+        sseUrl: server.sseUrl,
+        headers: server.headers ? { ...server.headers } : undefined,
+    };
+}
 function cloneRaxodeConfigFile(configFile) {
     return {
         schemaVersion: configFile.schemaVersion,
@@ -1045,6 +1075,11 @@ function cloneRaxodeConfigFile(configFile) {
         },
         workspace: { ...configFile.workspace },
         ui: { ...configFile.ui },
+        mcp: {
+            projectId: configFile.mcp.projectId,
+            reprofileConsecutiveIndexedCalls: configFile.mcp.reprofileConsecutiveIndexedCalls,
+            servers: configFile.mcp.servers.map(cloneRaxodeMcpServerConfig),
+        },
         permissions: {
             ...configFile.permissions,
             requireHumanOnRiskLevels: [...configFile.permissions.requireHumanOnRiskLevels],

package/raxode-tui/dist/raxode-cli/frontend/tui/cli/raxode-cli.d.ts

@@ -1,4 +1,5 @@
 import { type RaxodeResolvedRoleConfig } from "../config/raxode-config.js";
+import type { RaxodeMcpReadinessSummary } from "../../../backend/application/mcpReadinessSummary.js";
 import type { RaxodeLocalReadinessProbeInput } from "../../../backend/application/localReadinessProbe.js";
 import type { RaxodeOptions } from "../../../backend/agents/codingAgent/config/raxodeOptions.js";
 export type RaxodeUiCommand = "tui";
@@ -13,6 +14,7 @@ export declare function buildBackendReadinessStatusLines(input?: {
     backendOptions?: RaxodeOptions;
     now?: () => string;
     localProbe?: Omit<RaxodeLocalReadinessProbeInput, "manifest">;
+    mcp?: RaxodeMcpReadinessSummary;
 }): string[];
 export declare function resolveRaxodeCliCommand(argv: string[]): {
     command: RaxodeUiCommand | "login" | "logout" | "status" | "help" | "resume";

package/raxode-tui/dist/raxode-cli/frontend/tui/cli/raxode-cli.js

@@ -9,6 +9,7 @@ import { listDirectTuiSessions, resolveDirectTuiSessionSelection, } from "../inp
 import { loadWorkspaceRaxodeAgent } from "../input/workspace-raxode-store.js";
 import { formatBackendModuleGapsLine, formatBackendModuleStatusLine, } from "../input/backend-readiness-status.js";
 import { summarizeRaxodeReadiness } from "../../bridge/readiness.js";
+import { loadRaxodeMcpReadinessSummary } from "../../../backend/application/mcpConfig.js";
 import { inspectRaxodeBackendReadinessWithLocalProbe } from "../../../backend/application/runtimeReadiness.js";
 const PRIMARY_CLI_COMMAND = "raxode";
 const CLI_DISPLAY_NAME = "Raxode";
@@ -44,6 +45,7 @@ export function buildBackendReadinessStatusLines(input = {}) {
             options: input.backendOptions,
             now: input.now,
             localProbe: input.localProbe,
+            mcp: input.mcp,
             ports: {
                 contextArtifactAdapters: "configured",
                 authStateProvider: "configured",
@@ -77,11 +79,16 @@ export function buildBackendReadinessStatusLines(input = {}) {
                 `fallback=${readiness.sandbox.probe.fallback}`,
             ].join(", ")
             : "none";
+        const mcpServersLine = readiness.mcp.enabledServerIds.length === 0
+            ? "none"
+            : readiness.mcp.enabledServerIds.join(", ");
         return [
             `Praxis backend readiness: ${digest.status}`,
             `Praxis backend modules: ${formatBackendModuleStatusLine(digest)}`,
             `Praxis backend module gaps: ${formatBackendModuleGapsLine(digest)}`,
             `Praxis backend runtime ports: ${runtimePortLine}`,
+            `Praxis backend MCP: configured=${readiness.mcp.configuredServerCount} enabled=${readiness.mcp.enabledServerCount} mcpPlus=${readiness.mcp.enabledMcpPlusServerCount} native=${readiness.mcp.enabledNativeServerCount} checkpoint=${readiness.mcp.schemaRefreshBoundary} profile=${readiness.mcp.profileIdentity}`,
+            `Praxis backend MCP servers: ${mcpServersLine}`,
             `Praxis backend model: provider=${readiness.model.provider ?? "unknown"}, model=${readiness.model.model}, route=${readiness.model.providerRoute ?? readiness.model.endpointShape ?? "auto"}`,
             `Praxis backend tools: ${readiness.toolProfile} mounted=${readiness.tools.mountedToolIds.length} expected=${readiness.tools.expectedCoreToolIds.length}`,
             `Praxis backend sandbox: ${readiness.sandbox.profile} execution=${readiness.sandbox.defaultExecution} fallback=${readiness.sandbox.fallback}`,
@@ -384,6 +391,7 @@ function printStatus() {
         backendOptions: primaryResolved === undefined
             ? undefined
             : raxodeBackendOptionsFromResolvedRole(primaryResolved),
+        mcp: loadRaxodeMcpReadinessSummary(),
     })) {
         process.stdout.write(`${line}\n`);
     }