Skip to main content
Glama

Server Configuration

Describes the environment variables required to run the server.

NameRequiredDescriptionDefault
GUARD_APPROVERNoDeclared approver identity. When `requireDistinctActor` is enabled in `rules.json` (`approval.requireDistinctActor: true`), CLI and permitted MCP approvals require `GUARD_APPROVER`, and Guard rejects the same declared actor used to generate a proposal via `GUARD_PROPOSER`. These variables provide declared provenance only; external branch protection or signed identity remains responsible for proving who approved the change.
GUARD_PROPOSERNoDeclared proposer identity, recorded as provenance when a proposal is generated. Used together with `GUARD_APPROVER` under `approval.requireDistinctActor` to reject an approval coming from the same declared actor that generated the proposal. These variables provide declared provenance only; external branch protection or signed identity remains responsible for proving who approved the change.

Instructions

Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.

This server publishes no instructions, or was last inspected before Glama recorded them.

Capabilities

Features and capabilities supported by this server

Protocol revision2025-11-25

CapabilityDetails
tools
{
  "listChanged": true
}
prompts
{
  "listChanged": true
}
resources
{
  "listChanged": true
}

Tools

Functions exposed to the LLM to take actions

NameDescription
codapult_guard_analyzeA

Rediscover the repository and persist its current project facts and snapshots. Use after repository changes when codapult_guard_next_action returns needs-refresh or needs-setup; this does not change Guard rules, contracts, or baseline. Returns the new revision and discovery metrics.

codapult_guard_next_actionA

Choose the next bounded step in the Guard workflow without writing project files. Call at task start or after a step: it checks setup, stale project facts/proposals, changed-file findings, and policy contracts, then returns an action such as init, analyze, policy review, repair, or verify with the reason.

codapult_guard_contextA

Read the project model, architecture insights, conventions, active policy, proposals, baseline, waivers, and completion-gate settings in one structured response. Works before Guard initialization. Use refresh=true (default) for current repository state; refresh=false prefers persisted snapshots and is useful when inspecting the last saved model.

codapult_guard_proposeA

Generate evidence-backed candidate architecture rules and contracts from the current project model. Use to review possible policy after setup or structural changes; proposals are never activated automatically. The result includes evidence, questions, freshness, and persistence status. Persisted proposals still require an explicit decision with codapult_guard_proposal_decide.

codapult_guard_initA

Create the initial Guard policy, project model, and supporting artifacts for a repository that has not been initialized. Existing Guard state is preserved by default. Use force only to replace existing state after reviewing the consequences; the result reports initialization findings.

codapult_guard_proposal_decideA

Record an explicit approval or rejection for the selected current proposals. Approval activates the selected rules/contracts in Guard policy; rejection records the decision without activation. Stale proposals cannot be decided, and protected approval policy may require a non-MCP reviewer. Returns the decision and affected IDs.

codapult_guard_verifyA

Run the configured completion gate: selected project checks plus Guard architecture and policy checks, returning structured results. Use after implementation and semantic review; this executes project commands but does not edit source. Defaults come from agent.json where omitted. Pass requirement to bind verification to the task and increment iteration on each retry.

codapult_guard_governanceB

Inspect proposal and approval provenance metadata, policy bindings, and whether retained verification evidence is reachable from decisions. Use for a governance trail audit; output describes declared metadata and does not authenticate identities or verify signatures.

codapult_guard_auditA

Scan the entire current repository against active Guard rules, including findings normally hidden by the baseline, and validate policy contracts. Use for a full health review; unlike codapult_guard_check, this is not limited to changed files. Returns findings, contract issues, counts, and overall status.

codapult_guard_reviewA

Build a bounded packet for an AI semantic reviewer containing the diff, project context, active contracts, and deterministic Guard findings. Use after coding and before verification. The result needs human/agent review; it is not itself an approval or verification. Set base for PR comparisons and requirement to focus the review.

codapult_guard_checkA

Run active architecture rules and contract validation, returning structured findings and status. Use for a fast deterministic policy check: changed_only=true focuses on changed files and respects the baseline; false scans the full project. Omitted uses the scanner default. For a full audit that ignores baseline suppression, use codapult_guard_audit.

codapult_guard_waiversA

List or manage owner-attributed, time-limited exceptions tied to exact active finding fingerprints. Use list to inspect current waivers; add requires fingerprint, owner, expiry, and reason; renew/remove require waiver id and reason. Every mutation requires confirm=true and may be restricted by protected approval policy. Adding a waiver does not change the underlying rule.

codapult_guard_impactA

Trace the likely project impact of one or more file paths through the discovered dependency graph, including dependents, routes, capabilities, contracts, and graph paths. Use before changing a file to understand downstream areas to inspect. This is repository analysis, not a policy pass/fail check; returns structured impact details.

codapult_guard_explainA

Look up one active Guard rule or contract by ID and return its definition, evidence, guidance, and suggested next steps. Use when a check reports a rule ID or when deciding how to comply. For a finding-specific explanation, inspect the finding from codapult_guard_check or codapult_guard_audit as well.

Prompts

Interactive templates invoked by user choice

NameDescription
codapult_guard_proposal_reviewRefine evidence-backed Guard rule and contract proposals before activation.
codapult_guard_semantic_reviewReview a Guard packet against project-specific contracts and architecture context.

Resources

Contextual data attached and managed by the client

NameDescription
codapult_guard_runsLocal verification outcomes, gates, and stage timings.
codapult_guard_rulesLocal architecture invariants available to CLI checks and AI agents
codapult_guard_contextCurrent project model, architecture policy, contracts, and gate settings.
codapult_guard_architectureObserved architecture and conventions.
codapult_guard_waiversActive and expired time-bounded exceptions to Guard findings.
codapult_guard_proposalsEvidence-backed rules and contracts awaiting review.

TDQS

A4/5.0

Scored across 14 tools

Disambiguation4/5

The tools cover distinct workflow stages, and descriptions explicitly contrast check vs audit vs verify vs review. Some overlap remains among policy-checking and orchestration tools such as next_action, check, audit, verify, and review, but boundaries are mostly clear.

Naming Consistency4/5

All names share the codapult_guard_ prefix and snake_case formatting, which is highly consistent. However, suffixes mix verbs and nouns such as analyze, context, proposal_decide, and waivers, so it is not a pure verb_noun pattern.

Tool Count5/5

Fourteen tools is within the well-scoped range for a multi-stage governance workflow. Each tool maps to a distinct lifecycle operation, and the set does not feel bloated for the apparent domain.

Completeness5/5

The surface covers initialization, discovery, context inspection, proposal and decision handling, checks, audit, semantic review, verification, waivers, governance, impact analysis, explanation, and next-action orchestration. No obvious lifecycle gap is apparent; even replacement is handled through init with force.

Maintenance

ActivityActive
ResponsivenessNo recent community issues