Trestle MCP
OfficialThis server lets an MCP-compliant agent drive the OSCAL compliance-trestle CLI: set up a workspace, move models in and out, round-trip them through markdown, and convert CSV/XLSX into OSCAL artifacts.
Initialize a workspace (
trestle_init): create the Trestle directory layout in local, full, or govdocs mode.Import models (
trestle_import): pull a Catalog, Profile, Component Definition, or SSP from a file path or URL into the right workspace folder, optionally regenerating UUIDs.Validate OSCAL (
trestle_validate): check a standalone .json/.yaml/.yml file against the OSCAL schema plus optional semantic checks (duplicate UUIDs, broken references, links, rule parameters), enforcing an expected model type such asplan-of-action-and-milestones.Author catalogs (
trestle_author_catalog_generate): split a catalog into control-wise markdown files, with YAML headers, force-overwrite, and header-value control.Author profiles (
trestle_author_profile_generate,..._assemble,..._resolve): generate profile markdown docs, assemble markdown back intoprofile.json, and resolve a profile into a parameter-resolved catalog (show values/labels, bracket formats, assigned/unassigned prefixes).Convert tabular data to OSCAL (
trestle_task_csv_to_oscal_cd,trestle_task_xlsx_to_oscal_poam): turn a structured CSV into a component definition, or a FedRAMP XLSX POA&M sheet intoplan-of-action-and-milestones.json, with control validation and required-field checking modes.Common controls across tools: optional
trestle_roottargeting,verboseoutput, and consistent success/error result messages.
Note: this schema exposes 9 tools; the full server offers more (e.g. create/split/merge/describe/replicate, SSP authoring, generic task runner), selectable via TRESTLE_MCP_TOOLS or --tools.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Trestle MCP Initialize a new trestle workspace for my project."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Trestle MCP
MCP server to easily use compliance-trestle (OSCAL tool) from OpenCode, Claude, or any MCP-compliant client.
mcp-name: io.github.oscal-compass/compliance-trestle-mcp
Getting Started
This project can be used in the following two ways:
Usage from a coding agent (OpenCode): Use Trestle-MCP from OpenCode via MCP.
Usage from CLI (MCP Client): Invoke Trestle-MCP directly using an MCP CLI client.
Choose the option that best fits your workflow.
Related MCP server: MCP REST API Server
Usage from OpenCode
Add the following to
opencode.jsonin your workspace:{ "mcp": { "trestle": { "type": "local", "command": ["uvx", "--from", "compliance-trestle-mcp==<version>", "trestle-mcp"], "environment": { "TRESTLE_MCP_TOOLS": "all" }, "enabled": true } } }Replace
<version>with the release you want; drop==<version>to track the latest.TRESTLE_MCP_TOOLSchooses how much of the command surface to expose —allis every tool, and the default without it is the authoring lifecycle. See Choosing which tools are exposed.Open OpenCode, confirm the
trestletools are listed, and execute as needed.https://github.com/user-attachments/assets/a85b0927-4981-41d1-9a03-f22becb7a6e2
Usage from CLI (MCP Client)
Step 1: Write your mcp.json config
{
"mcpServers": {
"trestle": {
"command": "uvx",
"args": ["--from", "./trestle-mcp-tmp", "trestle-mcp"]
}
}
}Save this as mcp.json in your current directory.
Step 2: List Available Tools
uvx mcp-cli tools --config-file mcp.jsonSample output (tools available):
13 Available Tools
┌─────────┬───────────────────────────────────┬───────────────────────────────────────────────────────────────────┐
│ Server │ Tool │ Description │
├─────────┼───────────────────────────────────┼───────────────────────────────────────────────────────────────────┤
│ trestle │ trestle_init │ Initialize a trestle working directory. │
│ trestle │ trestle_import │ Import an existing OSCAL model into the trestle workspace. │
│ trestle │ trestle_validate │ Validate a standalone OSCAL file against the OSCAL schema. │
│ trestle │ trestle_author_catalog_generate │ Generate Catalog controls in markdown form from a catalog. │
│ trestle │ trestle_author_catalog_assemble │ Assemble markdown files of controls into a Catalog json file. │
│ trestle │ trestle_author_profile_generate │ Generate markdown documentation set for controls in a profile. │
│ trestle │ trestle_author_profile_assemble │ Assemble markdown controls into a Profile JSON file. │
│ trestle │ trestle_author_profile_resolve │ Resolve an OSCAL profile to a resolved profile catalog. │
│ trestle │ trestle_author_component_generate │ Generate component markdown from a component-definition. │
│ trestle │ trestle_author_component_assemble │ Assemble markdown controls into a component-definition json file. │
│ trestle │ trestle_task_csv_to_oscal_cd │ Convert a CSV file to an OSCAL component definition. │
│ trestle │ trestle_task_csv_to_oscal_mc │ Convert a CSV file to an OSCAL mapping collection. │
│ trestle │ trestle_task_xlsx_to_oscal_poam │ Convert a FedRAMP XLSX spreadsheet to an OSCAL POA&M. │
└─────────┴───────────────────────────────────┴───────────────────────────────────────────────────────────────────┘Those 13 are the default selection. The server implements 29 tools in all: 28
that groups can select, plus trestle_remove, which is registered only when
named explicitly. See
Choosing which tools are exposed, and
Commands deliberately not covered
for the parts of the trestle CLI that have no tool and why.
Step 3: Execute a Tool (e.g., trestle_init)
Start MCP interactive shell:
uvx mcp-cli interactive --config-file mcp.jsonThen run, for example:
> execute trestle_init '{"params": {}}'Typical result:
✓ ✅ Tool executed successfully
{
"result": {
...
"content": [
{
"type": "text",
"text": "✅ Trestle workspace initialized successfully"
}
]
}
}You'll see folders as follows:
assessment-plans catalogs plan-of-action-and-milestones system-security-plans
assessment-results component-definitions profilesChoosing which tools are exposed
Every tool a server registers costs the caller context: an MCP client loads each tool's name, input schema and description into the model's context window on every session. This server covers the trestle command surface an agent should drive, but exposes only the authoring lifecycle unless you ask for more, so a session carries the part of that surface it will actually call and the rest is one setting away.
The selection is a comma-separated list of group names and/or individual tool
names, read from the --tools flag or the TRESTLE_MCP_TOOLS environment
variable. The flag wins over the environment variable. Naming something that
does not exist fails at startup with the list of valid names, rather than
starting up with the tool quietly missing — and the flag has to be spelled in
full, so a config file carrying --tool is rejected instead of guessed at.
Value | Tools |
| Meaning |
| 13 | 47,342 | The curated authoring lifecycle. The default. |
| 12 | 39,668 | The top-level trestle commands |
| 11 | 39,684 | Every |
| 5 | 20,318 | Every |
| 28 | 99,668 | Everything a group can select |
| 1 | 4,630 | Any single tool, by its registered name |
The default is less than half the size of all, and selections combine, so you
pay only for what you name. Measure any selection yourself with
python scripts/tool_context_cost.py; see
What each tool selection costs in context for the
current figures per selection and per tool, and for how to narrow the default
further.
core, author and task mirror the trestle CLI's own command structure, so
which tool is in which group follows from the CLI. authoring is the one
curated preset that cuts across them.
Tools no group selects. trestle_remove deletes an element from a model in
place, with no backup, so no group selects it — all included. It is registered
only when the selection names it exactly, e.g. authoring,trestle_remove.
Default (the authoring lifecycle) — no configuration needed:
{
"mcpServers": {
"trestle": {
"command": "uvx",
"args": ["--from", "compliance-trestle-mcp", "trestle-mcp"]
}
}
}Everything, via the environment variable:
{
"mcpServers": {
"trestle": {
"command": "uvx",
"args": ["--from", "compliance-trestle-mcp", "trestle-mcp"],
"env": { "TRESTLE_MCP_TOOLS": "all" }
}
}
}A mixed selection, via the flag — the authoring lifecycle plus SSP generation and the generic task runner:
{
"mcpServers": {
"trestle": {
"command": "uvx",
"args": [
"--from", "compliance-trestle-mcp", "trestle-mcp",
"--tools", "authoring,trestle_author_ssp_generate,trestle_task_run"
]
}
}
}The examples above use the mcpServers shape most MCP clients take. OpenCode
spells the same things differently — mcp rather than mcpServers, command
as one array instead of a command plus args, and environment rather than
env — so the "everything" selection looks like
the entry at the top of this README.
Run trestle-mcp --help for the group list, and watch stderr on startup for the
line reporting the selection and how many tools it registered.
Tool List & Quick Reference
Tools marked (default) are in the authoring preset.
core — top-level trestle commands
trestle_init(default): Initialize a trestle workspacetrestle_import(default): Import OSCAL models (Catalog/Profile/etc.) from a file or URLtrestle_validate(default): Validate a standalone OSCAL file (any top-level model, e.g. POA&M) against the OSCAL schema (and trestle's semantic checks)trestle_create: Create a sample OSCAL model, or a new element inside an existing model filetrestle_assemble: Assemble a split model into a single file underdisttrestle_split: Split subcomponents of a model into separate filestrestle_merge: Merge split subcomponents back into a modeltrestle_describe: Describe the contents of a model file, optionally at an element pathtrestle_replicate: Copy a top-level model to a new name, optionally with fresh uuidstrestle_href: List or repoint the import hrefs of a profiletrestle_partial_object_validate: Validate a single OSCAL object held in a filetrestle_version: Report the trestle and OSCAL versions, or a model's own document version (metadata.version, not its OSCAL version)
author — trestle author subcommands
trestle_author_catalog_generate(default): Generate markdown controls from a catalogtrestle_author_catalog_assemble(default): Assemble markdown controls back into a catalog JSONtrestle_author_profile_generate(default): Generate markdown for profilestrestle_author_profile_assemble(default): Assemble markdown controls into profile JSONtrestle_author_profile_resolve(default): Resolve a profile to a catalogtrestle_author_profile_inherit: Derive a profile from a parent profile and a leveraged SSPtrestle_author_component_generate(default): Generate markdown from a component definitiontrestle_author_component_assemble(default): Assemble markdown back into a component definitiontrestle_author_ssp_generate: Generate SSP markdown from a profile and component definitionstrestle_author_ssp_assemble: Assemble SSP markdown into a system-security-plan JSONtrestle_author_ssp_filter: Filter an SSP by profile, components, implementation status or control origination
task — trestle task wrappers
trestle_task_csv_to_oscal_cd(default): Convert a CSV mapping file into an OSCAL component definitiontrestle_task_csv_to_oscal_mc(default): Convert a CSV crosswalk into an OSCAL mapping collectiontrestle_task_xlsx_to_oscal_poam(default): Convert a FedRAMP-format XLSX spreadsheet into an OSCAL Plan of Action and Milestones (POA&M)trestle_task_list: List the available trestle tasks, or describe one task's configuration keystrestle_task_run: Run any trestle task from a configuration dictionary
trestle_task_run covers every task the installed trestle provides, including
ones with no typed tool here. Prefer the typed tools where they exist: they
validate their arguments and document the input format.
Not covered
The signing and provenance commands (sign, verify, generate-manifest,
sign-manifest, verify-manifest, canonicalize), the beta feature-flag
command, and the markdown governance commands (author docs, author folders,
author headers, author jinja) have no tools here. The reasons are recorded
in the development guide.
For advanced use, refer to the official compliance-trestle docs; to add or change a tool here, see the development guide.
Troubleshooting & Help
Make sure uvx is installed and on your PATH.
If you see command/module errors, check the MCP server path in
mcp.jsonis correct.
We are a Cloud Native Computing Foundation sandbox project.
The Linux Foundation® (TLF) has registered trademarks and uses trademarks. For a list of TLF trademarks, see Trademark Usage.
OSCAL Compass is an independent open source project. It is not affiliated with, endorsed by, or sponsored by the National Institute of Standards and Technology (NIST) or any other government agency.
OSCAL Compass was originally contributed by IBM.
Available Tools
13 toolstrestle_author_catalog_assembleAssemble Catalog JSON from MarkdownADestructive
Assemble markdown files of controls into a Catalog json file.
This is the return leg of the catalog authoring round trip: run
trestle_author_catalog_generate to get markdown, edit the control prose or
the yaml header, then run this tool to write the edits back into
catalogs//catalog.json.
Set set_parameters when the edits include parameter values or properties in
the markdown yaml header — without it only the control prose is read back,
and header edits are silently discarded.
Args: params (TrestleAuthorCatalogAssembleInput): Input parameters with: - markdown (str): Input markdown control directory (required) - output (str): Output json catalog name (required) - name (Optional[str]): Source catalog model name (defaults to output) - set_parameters (bool): Read parameters and properties from the markdown yaml header (default: false) - regenerate (bool): Force generation of new uuids (default: false) - version (Optional[str]): New version for the assembled model - trestle_root (Optional[str]): Trestle workspace root path - verbose (bool): Display verbose output
Returns: str: Success or error message
Examples:
- Use when: "Write my markdown control edits back into the catalog json"
- Use when: "Assemble a catalog from markdown and stamp it version 1.1.0"
- Don't use when: The markdown directory was never generated from a
catalog — assemble cannot invent the catalog metadata it needs.
- Don't use when: You want a profile json out of profile markdown; use
trestle_author_profile_assemble.
Inputs: params (required). Returns: result
trestle_author_catalog_generateGenerate Catalog Markdown ControlsADestructive
Generate Catalog controls in markdown form from a catalog in the trestle workspace.
Args: params (TrestleCatalogGenerateInput): Input parameters with: - name (str): Catalog model name (required) - output (str): Output markdown folder (required) - force_overwrite (bool): Force overwrite markdowns (optional) - yaml_header (Optional[str]): Path to yaml header file (optional) - overwrite_header_values (bool): Overwrite markdown header values (optional) - trestle_root (Optional[str]): Trestle workspace root path (optional) - verbose (bool): Display verbose output (optional)
Returns: str: Success or error message
Examples: - Use when: "Generate markdown controls from a catalog" - Use when: "Split a catalog JSON into control-wise markdowns" - Don't use when: "Catalog is missing or output directory already exists and not overwritten"
Inputs: params (required). Returns: result
trestle_author_component_assembleAssemble Component Definition from MarkdownADestructive
Assemble markdown files of controls into a component-definition json file.
This is the return leg of the component authoring round trip: generate
markdown with trestle_author_component_generate, edit the implementation
prose and the rule/parameter yaml headers, then assemble back into
component-definitions//component-definition.json.
Unlike catalog-assemble and profile-assemble there is no set-parameters flag — component markdown headers (rules, parameter values, implementation status) are always read back.
Pass name whenever output is a name that does not already exist. The
source model defaults to the output name, so assembling into a new
component-definition without name fails with "Unable to load model
without specifying json or yaml". (catalog-assemble does not have
this constraint — it takes the source from the markdown header.)
Args: params (TrestleAuthorComponentAssembleInput): Input parameters with: - markdown (str): Source markdown directory (required) - output (str): Output json component-definition name (required) - name (Optional[str]): Source component-definition model name (defaults to output) - regenerate (bool): Force generation of new uuids (default: false) - version (Optional[str]): New version for the assembled model - trestle_root (Optional[str]): Trestle workspace root path - verbose (bool): Display verbose output
Returns: str: Success or error message
Examples: - Use when: "Write the implementation prose I edited back into the component definition" - Use when: "Assemble the component definition and bump its version" - Don't use when: The markdown directory was not produced by component-generate.
Inputs: params (required). Returns: result
trestle_author_component_generateGenerate Component MarkdownADestructive
Generate component in markdown form from a component-definition in the trestle workspace.
This writes one markdown file per control implementation, per component, under
///. The markdown is where an author writes
the implementation prose and the rule/parameter yaml header that
trestle_author_component_assemble reads back.
Note that generate only writes what the component-definition already declares: it will not create implemented requirements for controls the component-definition does not claim.
Args: params (TrestleAuthorComponentGenerateInput): Input parameters with: - name (str): Source component-definition model name (required) - output (str): Output markdown folder (required) - force_overwrite (bool): Overwrite existing markdown content, discarding edits (default: false) - trestle_root (Optional[str]): Trestle workspace root path - verbose (bool): Display verbose output
Returns: str: Success or error message
Examples:
- Use when: "Generate editable markdown for this component definition"
- Use when: "Let me write implementation prose for each control a
component claims"
- Don't use when: There is no component-definition in the workspace yet;
import one, or create one with trestle_task_csv_to_oscal_cd.
- Don't use when: You only want to regenerate without losing edits —
force_overwrite discards author prose.
Inputs: params (required). Returns: result
trestle_author_profile_assembleAssemble Profile JSON from Markdown DirectoryADestructive
Assemble markdown controls into a Profile JSON file.
This tool assembles an OSCAL profile JSON (profile.json) from a directory of markdown controls for a profile.
Args: params (TrestleAuthorProfileAssembleInput): - markdown_dir (str): Markdown controls directory (required) - output_profile (str): Output profile directory name (required) - name (Optional[str]): Profile model name - set_parameters (bool): Expand parameters from YAML frontmatter - regenerate (bool): Force UUID regeneration - version (Optional[str]): Model version - sections (Optional[str]): Section info (short:long, comma-separated) - required_sections (Optional[str]): Required section short names, comma-separated - allowed_sections (Optional[str]): Allowed section short names, comma-separated - verbose (bool): Verbose output - trestle_root (Optional[str]): Path of trestle root directory
Returns: str: Success message with stdout, or error message with stderr details
Examples: - Use when: Automatically assemble OSCAL profile from markdown directory - Use when: CI/CD profile assembling, parameter expansion - Don't use when: Input markdown_dir does not exist, or malformed markdown
Inputs: params (required). Returns: result
trestle_author_profile_generateGenerate Profile Markdown ControlsBDestructive
Generate markdown documentation set for controls defined in specified profile.
This tool extracts controls defined in the specified profile (profiles//profile.json) and generates a set of markdown documents for them. This set can be used for custom documentation, reviews, and organization-specific profile documentation.
Args: params (TrestleAuthorProfileGenerateInput): - name (str): profile name (required) - output (str): output directory for markdown docs (required) - yaml_header (Optional[str]): yaml header file path - force_overwrite (bool): overwrite all in output dir - overwrite_header_values (bool): overwrite header values only - sections (Optional[str]): targeted sections in markdown - required_sections (Optional[str]): required section short names, comma-separated - trestle_root (Optional[str]): workspace root path - verbose (bool): verbose output
Returns: str: Success message or error details
Examples: - Use when: "Generate markdown controls for a given profile" - Use when: "Customize output with required sections or header overwrite" - Don't use when: Profile file does not exist
Inputs: params (required). Returns: result
trestle_author_profile_resolveResolve Profile to CatalogADestructive
Resolve an OSCAL profile to a resolved profile catalog.
This tool resolves a specified OSCAL profile (by name from profiles//profile.json) into an operational, parameter-resolved OSCAL catalog, with flexible output and formatting options.
Args: params (TrestleAuthorProfileResolveInput): - name (str): Source profile name (required) - output (str): Output catalog name (required) - show_values (bool): Show parameter values in prose (optional) - show_labels (bool): Show parameter labels in prose (optional) - bracket_format (str): Bracket format for values (optional) - value_assigned_prefix (str): Prefix if value is assigned (optional) - value_not_assigned_prefix (str): Prefix if value not assigned (optional) - label_prefix (str): Prefix for label output (optional) - verbose (bool): Display verbose output (optional) - trestle_root (str): Path to trestle root directory (optional)
Returns: str: Result summary string. On success, a checked message with output. On failure, a cross mark and error details.
Examples: - Minimal invocation trestle_author_profile_resolve(name="myprofile", output="catalog_resolved") - With options trestle_author_profile_resolve(name="myprofile", output="catalog_resolved", show_values=True, bracket_format="(.)")
Inputs: params (required). Returns: result
trestle_importImport OSCAL ModelA
Import an existing OSCAL model into the trestle workspace.
This tool imports OSCAL models from URLs or local file paths. The imported file will be saved in the appropriate directory based on its OSCAL type (e.g., catalogs/, profiles/, component-definitions/).
Import Behavior:
Catalog → catalogs/{output}/catalog.json
Profile → profiles/{output}/profile.json
Component Definition → component-definitions/{output}/component-definition.json
SSP → system-security-plans/{output}/system-security-plan.json
Args: params (TrestleImportInput): Validated input parameters containing: - file (str): OSCAL file to import (URL or file path) - output (str): Name of output element - regenerate (bool): Force generation of new UUIDs (default: false) - trestle_root (Optional[str]): Path to trestle root directory - verbose (bool): Display verbose output (default: false)
Returns: str: Success message with import details or error
Examples: - Import NIST SP800-53 Rev5 Catalog: file="https://raw.githubusercontent.com/usnistgov/oscal-content/refs/heads/main/nist.gov/SP800-53/rev5/json/NIST_SP-800-53_rev5_catalog.json" output="nist_sp800_53_rev5"
- Import from local file:
file="./resources/catalogs/your_catalog.json"
output="mycatalog"
Inputs: params (required). Returns: result
trestle_initInitialize Trestle WorkspaceADestructive
Initialize a trestle working directory.
This tool initializes the current directory as a Trestle workspace, creating the necessary directory structure for OSCAL model management.
Do not run this on a workspace that is already initialized. Creating
the directories is harmless -- they are only made when missing -- but
local and full mode also copy trestle's stock .trestle/config.ini
over whatever is there, with no check and no warning, and still report
success. That file is where trestle task reads its [task.*] sections
from, so an operator's task configuration is gone. Check for a .trestle
directory before calling this; there is nothing to gain by running it
again.
OSCAL Model Types supported:
Catalog
Profile
Component Definition
System Security Plan (SSP)
Assessment Plan
Assessment Result
Plan of Action and Milestones (POAM)
Args: params (TrestleInitInput): Validated input parameters containing: - mode (InitMode): Initialization mode (local/full/govdocs, default: local) - trestle_root (Optional[str]): Path to trestle root directory - verbose (bool): Display verbose output (default: false)
Returns: str: Success message or error details
Examples: - Use when: "Initialize trestle workspace" - Use when: "Set up trestle in full mode" - Don't use when: Workspace is already initialized — this overwrites .trestle/config.ini rather than leaving it alone.
Inputs: params (required). Returns: result
trestle_task_csv_to_oscal_cdConvert CSV to OSCAL Component DefinitionBDestructive
Convert a CSV file to an OSCAL component definition JSON file.
This tool runs the trestle task csv-to-oscal-cd command, which reads a specially formatted CSV file and produces an OSCAL component_definition .json file.
The CSV must have:
Row 1: column headings
Row 2: column descriptions
Row 3+: data rows
Required CSV columns:
$$Component_Title, $$Component_Description, $$Component_Type
$$Rule_Id, $$Rule_Description, $$Profile_Source, $$Profile_Description
$$Control_Id_List, $$Namespace
Args: params (TrestleTaskCsvToOscalCdInput): Input parameters with: - title (str): Component definition title (required) - version (str): Component definition version (required) - csv_file (str): Path to the input CSV file (required) - output_dir (str): Output directory for OSCAL JSON files (required) - component_definition (Optional[str]): Existing component-definition to update (optional) - output_overwrite (bool): Overwrite existing output (default: true) - validate_controls (str): Control validation mode: on/warn/off (default: off) - class_column_mappings (Optional[dict]): Column-to-class mappings (optional) - trestle_root (Optional[str]): Trestle workspace root path (optional) - verbose (bool): Display verbose output (optional)
Returns: str: Success or error message with output file location
Examples: - Use when: "Convert CSV to OSCAL component definition" - Use when: "Generate component_definition.json from a CSV mapping file" - Don't use when: Input CSV is missing required columns
Inputs: params (required). Returns: result
trestle_task_csv_to_oscal_mcConvert CSV to OSCAL Mapping CollectionADestructive
Convert a CSV file to an OSCAL mapping-collection JSON file.
This tool runs the trestle task csv-to-oscal-mc command, which reads a specially formatted CSV of control-to-control correspondences and produces mapping-collection.json — the OSCAL model for "control X over here means the same thing as controls Y and Z over there".
The CSV must have:
Row 1: column headings
Row 2: column descriptions
Row 3+: data rows
Required CSV columns:
$$Source_Resource, $$Target_Resource: for each side, a path to a catalog JSON file or an href to a profile. Both sides are loaded and every id in the ref lists is looked up in them. An id that is not found is dropped without a warning, and the row is still written with whatever ids did resolve:
ac-1 ac-99-typoon one side produces a map namingac-1only, and the run reports success. It fails only when nothing in a row's list resolves at all. So a successful run does not mean every id in the CSV made it into the output -- check the id-refs in mapping-collection.json against the CSV if the mapping has to be complete.$$Map_Source_Id_Ref_List, $$Map_Target_Id_Ref_List: whitespace-separated control ids, or statement ids such as
ac-1_smt.a. Several ids on one side are what makes a mapping many-to-many.$$Map_Relationship: the relationship type, as an NCName token. The conventional values are the NIST IR 8477 section 4.3 set-theory relationships —
equivalent,subset-of,superset-of,intersects-with,no-relationship— but trestle does not restrict the vocabulary. Leave the cell empty to declare a control unmapped: it is then recorded in the gap summary instead of producing a map entry.
Optional CSV columns:
$$Map_Confidence_Score, $$Map_Coverage: percentages expressed in the range 0 to 1, not 0 to 100. A value of 80 is silently dropped with a "Percentage value out of range" warning and the map entry is written without it; write 0.8.
Resource paths in the CSV are resolved relative to the trestle process's
working directory, which is trestle_root when you pass one and wherever
the server was started when you do not. Pass trestle_root, or use absolute
paths, so the CSV does not depend on how the server was launched.
Args: params (TrestleTaskCsvToOscalMcInput): Input parameters with: - title (str): Mapping collection title (required) - version (str): Mapping collection version (required) - csv_file (str): Path to the input CSV file (required) - output_dir (str): Output directory for mapping-collection.json (required) - output_overwrite (bool): Overwrite existing output (default: true) - trestle_root (Optional[str]): Trestle workspace root path (optional) - verbose (bool): Display verbose output (optional)
Returns: str: Success or error message with the output file location
Examples:
- Use when: "Map our internal control set onto NIST SP 800-53"
- Use when: "Produce an OSCAL mapping collection from this crosswalk
spreadsheet"
- Don't use when: You want a component definition out of a CSV; use
trestle_task_csv_to_oscal_cd.
- Don't use when: The CSV is missing a required column, or names control
ids that are not in the source or target resource.
Inputs: params (required). Returns: result
trestle_task_xlsx_to_oscal_poamConvert FedRAMP XLSX to OSCAL POA&MADestructive
Convert a FedRAMP XLSX spreadsheet to an OSCAL POA&M JSON file.
This tool runs the trestle task xlsx-to-oscal-poam command, which reads a FedRAMP-format .xlsx spreadsheet and produces an OSCAL plan-of-action-and-milestones .json file. The converter auto-generates the observations[] and risks[] and cross-links each poam-item to them with deterministic UUIDs.
This command must run inside a trestle workspace: initialize one first with trestle_init and pass its path as trestle_root (or run from within it).
The spreadsheet must have:
Row 1: title
Rows 2-4: instructions (ignored)
Row 5: column headers
Row 6+: data rows
Required columns:
POAM ID, Weakness Name, Weakness Description, Controls
Args: params (TrestleTaskXlsxToOscalPoamInput): Input parameters with: - title (str): POA&M title (required) - version (str): POA&M version (required) - xlsx_file (str): Path to the input .xlsx file (required) - output_dir (str): Output directory for the OSCAL JSON (required) - work_sheet_name (Optional[str]): Worksheet name (default: 'Open POA&M Items') - system_id (Optional[str]): System identifier (optional) - output_overwrite (bool): Overwrite existing output (default: true) - validate_required_fields (str): Required-field check: on/warn/off (default: warn) - quiet (bool): Suppress per-item output (default: false) - trestle_root (Optional[str]): Trestle workspace root path (optional) - verbose (bool): Display verbose output (optional)
Returns: str: Success or error message with output file location
Examples: - Use when: "Convert this FedRAMP POA&M spreadsheet to OSCAL" - Use when: "Generate plan-of-action-and-milestones.json from an xlsx" - Don't use when: The input is a CSV, or is missing required columns
Inputs: params (required). Returns: result
trestle_validateValidate OSCAL DocumentARead-onlyIdempotent
Validate a standalone OSCAL file against the OSCAL schema.
This tool loads the OSCAL document through the trestle model classes, which enforces the OSCAL schema (required fields, field types, enums, UUID formats, and nesting). Optionally it also runs trestle's semantic validators (duplicate UUIDs, broken internal references, links, and rule parameters).
It detects the model type from the file's single top-level wrapper key, so
it validates any top-level OSCAL model: catalog, profile,
component-definition, system-security-plan, assessment-plan,
assessment-results, mapping-collection, or plan-of-action-and-milestones --
the same list as model_type elsewhere in this server.
Unlike trestle validate on the CLI, this works on a standalone file that
is not part of a trestle workspace — for example a POA&M JSON produced by an
authoring flow.
Args: params (TrestleValidateInput): Input parameters with: - file (str): Path to the OSCAL .json/.yaml/.yml file (required) - expected_model_type (Optional[str]): Enforce the file is this model type (e.g. 'plan-of-action-and-milestones') - semantic (bool): Run semantic validators too (default: true)
Returns: str: A pass/fail message; on failure, the concrete reasons.
Examples:
- Use when: "Validate this POA&M JSON is valid OSCAL"
file="./poam.json", expected_model_type="plan-of-action-and-milestones"
- Use when: "Check that catalog.json conforms to the OSCAL schema"
- Don't use when: The file is inside a trestle workspace and you want
the full trestle validate workspace checks.
Inputs: params (required). Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 13 tools
Each tool targets a distinct model+action combination: the catalog/profile/component generate-vs-assemble pairs are explicitly framed as round-trip halves, and the task converters are separated by input format and output model. trestle_validate and trestle_import have clear roles, and profile_resolve is uniquely a profile-to-catalog operation.
All names are snake_case with a coherent trestle_ prefix and a consistent verb_noun shape within three clear sub-namespaces (trestle_<verb>, trestle_author_<model>_<verb>, trestle_task_<format>_to_oscal_<model>). The only minor deviation is profile_resolve sitting among the authoring verbs, but it remains readable and predictable.
Thirteen tools is squarely in the well-scoped range and each earns its place: one init/import/validate plus paired authoring tools for three model types plus three format converters. There is no filler or duplicate tool.
The surface covers the core lifecycle: workspace init, import, validate, full generate/assemble round-trips for catalog, profile, and component-definition, and CSV/XLSX conversion tasks. Gaps remain — no listing/inventory of workspace models, no explicit export, and SSP/assessment/POA&M authoring only via import or conversion — but these are workaroundable.
Maintenance
Related MCP Connectors
MCP server for mandates, delegation, policy-gated execution, credential grants, and audit.
Authenticated MCP server for ClearPolicy policy and compliance workflows.
An MCP server that provides an API to LLMs to manage their JumpCloud resources.
An MCP server that provides Javelin Standalone Guardrails
Related MCP Servers
- AlicenseNot gradedqualityBmaintenanceMCP server providing token-efficient access to OpenAPI/Swagger specs via MCP Resources for client-side exploration.582 npm76MIT
- FlicenseNot gradedqualityDmaintenanceA server implementation of the Model Context Protocol (MCP) that provides REST API endpoints for managing and interacting with MCP resources.-
- AlicenseAqualityDmaintenanceMCP server for running infrastructure health checks with TIBET provenance. It enables users to define, execute, and audit process health checks with dependency chaining and drift tracking.6MIT
- AlicenseNot gradedqualityDmaintenanceRuntime MCP server that dynamically bridges any OpenAPI 3.x spec to MCP tools.9 npmMIT