phases-agents
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., "@phases-agentsPlan the skills needed for my Python project using the demo root."
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.
phases-agents
English · Français

A local MCP server that discovers, validates and selects skills deterministically. Python standard library only, no runtime dependencies.
One server. Five tools. Nothing executed behind your back.
Why
AI agents improvise. Ask the same question twice and you get two different plans. That is fine for brainstorming, and unacceptable for audit and compliance work.
phases-agents removes the improvisation. It profiles a local project, validates a catalogue of skills against a strict contract, and returns a plan that can be replayed. Same target, same catalogue, same parameters, same decision.
Related MCP server: skills-over-mcp
Principle

configured root identifiers
→ bounded discovery
→ official validation
→ immutable registry
→ verified cache
→ detector profile
→ deterministic selection
→ MCP planThe server selects and exposes. The calling model reads the selected skills and decides what to do with them, using its own tools. The server never executes a skill.
Architecture
The modules live in src/phases_agents/.
File | Role |
| official contracts and validated snapshots |
| bounded local discovery |
| trusted roots and verified cache |
| immutable types and limits |
| validated, immutable registry |
| local profile of the target |
| deterministic selection and ordering |
| JSON-RPC/MCP transport |
| client capability vocabulary |
| versioned profile-fact vocabulary |
| gap rules ( |
The normative contract lives in src/phases_agents/core/SKILLS_CONTRACT.md
(French).
Quick start
An example package ships in examples/skills/. Three steps produce a real
plan.
git clone https://github.com/Cherridsaid/phases-agents && cd phases-agentsCreate skills-roots.json pointing at the example root:
{
"config_version": "1.0",
"roots": [
{ "id": "demo", "path": "/absolute/path/to/phases-agents/examples/skills" }
]
}pip install -e .
phases-agents --skills-config /absolute/path/to/skills-roots.jsonpip install -e . installs the phases-agents command. Without installing,
the same server starts with PYTHONPATH=src python -m phases_agents.server.
The server reads JSON-RPC line by line on standard input. A
phases_agents_plan call against a Python project then selects
hello-python:
{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"phases_agents_plan",
"arguments":{"root_ids":["demo"],"target":"/absolute/path/to/a/project",
"today":"2026-08-27","plan_version":"B3",
"client_capabilities":["filesystem_read","filesystem_search"]}}}Two plan formats coexist. "B3" names the versioned format, not a server
version; its official schema is
src/phases_agents/core/PLAN_B3_SCHEMA.json. Use it for new
work. Without plan_version, the legacy format returns a flat list of steps;
it is kept so existing callers do not break, and will be deprecated before
removal. client_capabilities is only accepted in B3, since declaring what
the client can do only makes sense in that format.
Connecting an MCP client
Claude Code (.mcp.json at the root of your project):
{
"mcpServers": {
"phases-agents": {
"command": "phases-agents",
"args": [
"--skills-config",
"/absolute/path/to/skills-roots.json"
]
}
}
}Codex uses the same command/arguments pair in its own configuration file. No token and no environment variable is required.
MCP tools
detect(target)
list_skills(root_ids, today)
get_skill(root_ids, today, skill_id)
plan(root_ids, target, today, constraints?)
plan(root_ids, target, today, plan_version, client_capabilities?)
refresh_skills(root_ids, today)today is injected rather than read from a clock, so every call is
replayable. get_skill takes an identifier, never a path, and its content
comes from the validated snapshot. Absolute paths and detected secrets are
masked in public output. Any encoded JSON-RPC response stays under 1 MiB.
The first call builds the validated registry. Warm calls verify metadata
without re-reading contents. refresh_skills forces a rebuild.
Writing a skill package
Each package is a direct child of a root and contains at least:
<root>/<skill-id>/SKILL.md
<root>/<skill-id>/phases.jsonThe fastest way to start is to copy examples/skills/hello-python/ and rename
the identifier.
SKILL.md frontmatter
Five keys are allowed. All optional, all checked when present.
Key | Constraint |
| must equal |
| bounded free text |
| must equal |
| free author identity, no invisible characters |
|
|
The fourteen required sections
Each is a Markdown heading (##), in any order. Section titles are French,
because they belong to the contract; the body is yours to write in any
language.
Loi centrale · Ce que ce skill fait · Ce que ce skill ne fait pas ·
Conditions d'activation · Conditions d'exclusion ·
Capacites necessaires · Interdictions · Methode d'audit ·
Contrat de preuve · Format de sortie · Conditions de blocage ·
Limites connues · Exemples d'entree · Exemple de sortie attendue
phases.json fields
All required: schema_version, id, version, title, description,
domain, project_types, platforms, activation, exclusions,
requires_capabilities, optional_capabilities, forbidden_capabilities,
execution_mode, human_approval, output_schema, rules_path,
references_path, scripts_path, tests_path, files.
output_schema uses the symbolic form core:SCHEMA_NAME.json.
Closed vocabularies
project_types must intersect what the detector can emit: apk, python,
skill_package, solana, web.
activation.any uses profile facts: collects_personal_data, has_api,
has_apk, has_authentication, has_database, has_ecommerce,
has_eu_context, has_file_upload, has_javascript, has_python,
has_rust, has_skill_packages, has_solana, has_source_code,
has_typescript, has_web, uses_ai, uses_payments.
requires_capabilities, optional_capabilities and
forbidden_capabilities use: browser, dependency_installation,
filesystem_read, filesystem_search, filesystem_write, human_question,
shell, target_code_execution, web.
Provided capabilities are an open vocabulary: each catalogue names what
it brings, and only the shape is enforced (^[a-z][a-z0-9_]{0,63}$). Only
client capabilities are closed, because they describe the protocol rather
than your domain.
A domain of legal, juridique, regulatory or compliance triggers an
extra regime: every rule cited must carry an official source, a jurisdiction
and a verification date.
What the schema does and does not say
SKILL_MANIFEST_SCHEMA.json describes the shape of phases.json:
required fields, types, closed vocabularies.
The schema engine is deliberately minimal. It applies enum, minLength and
minItems, and nothing else: no pattern, no if/then, no oneOf. A
schema using those keywords would itself be rejected.
The consequence matters: conditional rules live in validator.py, which
remains the source of truth. The version rule is the example:
provides_capabilities is forbidden in a 1.0 manifest and required in a
1.1 one. That rule is enforced and tested, but it is not expressible in the
schema. Do not read required as the whole contract.
A package with only SKILL.md fails. An invalid package blocks the registry
rather than degrading silently.
Identity
phases.json.id is the identity, and SKILL.md.name must match it. The
directory must carry the same key. Keys are normalised with NFKC then
casefold, so homoglyphs cannot smuggle in a second identity. Any collision
blocks the whole build; no package is elected arbitrarily.
Selection

Every valid skill in the registry lands in exactly one category, with its reason. Nothing is discarded silently.
The only proven automatic signal is:
project_types ∩ profile.typesPlatform, domain and capabilities filter only when the caller supplies those constraints. A forbidden capability rejects the skill. No semantic score is invented, and the plan is sorted by identifier.
An empty plan is explicitly valid: it carries NO_COMPATIBLE_SKILL.
The B3 plan classifies every installed skill across skills_selected,
skills_not_applicable and skills_blocked; each skill appears exactly once.
skills_missing lists capabilities with no executable provider, derived from
confirmed facts only. A gap never proves non-compliance: it says an audit
deemed necessary is not covered.
Limits
16 roots maximum
direct depth only
1,000 packages maximum
10,000 entries per root
SKILL.mdcapped at 256 KiBa single reference capped at 256 KiB, 1 MiB in total
snapshots capped at 16 MiB
public result capped at 1 MiB
100 issues per package
fingerprint capped at 100,000 nodes
Callers may only lower these limits, never raise them.
Runtime constraints
Python
>=3.11no third-party runtime dependency
no implicit network
no runtime shell
no target code executed
no implicit clock
no telemetry
no skill downloaded
pytest is a development dependency only.
Tests
python -m pytest -qExpected result, 778 collected, 0 failed on every platform:
Linux : 771 passed, 7 skipped
Windows (CI) : 778 passed, 0 skipped
Windows (local) : 776 passed, 2 skippedThe skips are platform capabilities, not failures. Linux skips the Windows-junction tests, which have no POSIX equivalent. Windows skips the two symlink tests only when the local privilege to create symlinks is missing, so a runner that holds it reports no skip at all. Every count above comes from a real run: the two Windows lines are the GitHub Actions runner and a local machine.
Normative texts are checked out with LF endings, enforced by .gitattributes.
A couple of Windows symlink tests are skipped: they need a local Windows
privilege. Windows junctions are genuinely tested.
Level of proof
The validator confirms one thing only:
STRUCTURALLY_VALIDATEDIt does not verify the real target. TARGET_VERIFIED stays forbidden in V1.
Security
The loader refuses reparse points. Reads are bounded and confined. Output is sorted and deterministic.
One design decision deserves your attention: detect and plan take a
target path that is not confined to the configured roots, because the
point is to profile an arbitrary project. Run this server under an account
whose reach you accept, and connect it only to a trusted client. The full
threat model is in SECURITY.md.
Non-guarantees
no universal semantic relevance
no external skill approved automatically
no audit of script contents
no genuinely mounted target proof
no total Windows atomicity
no universal HTML recognition
no universal secret detection
no guaranteed legal compliance
no marketplace, no remote source
Licence
Apache-2.0. See LICENSE and NOTICE.
Available Tools
5 toolsphases_agents_detectC
Detecte localement le profil borne d'une cible. N'execute aucun fichier.
| Name | Required | Description | Default |
|---|---|---|---|
| target | Yes | Chemin absolu local du projet. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full behavioral burden, and it does add one meaningful trait: the operation is local and executes nothing, implying a safe non-executing read. It says nothing about permissions, whether any state is written, rate limits, or what the detection result contains, so it falls short of the disclosure a no-annotation tool warrants.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences, front-loaded with the action and followed by the key constraint, with no filler. It is efficient, though the terse phrasing comes at the cost of the clarity noted elsewhere.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter detection tool with no output schema and no annotations, the description is minimally viable but leaves gaps: it never defines what a "profil borne" comprises, what the caller receives, or how the result should be used. The absence of an output schema means more, not less, explanation was needed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There is a single parameter with 100% schema description coverage ("Chemin absolu local du projet"), so the schema already fully documents its meaning and the baseline is 3. The description adds no syntax, format, or path-constraint detail beyond what the schema supplies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a verb ("Detecte") and an object ("le profil borne d'une cible"), so its basic function is identifiable. However, "profil borne" is undefined jargon and the scoping term "localement" is the only differentiator, leaving ambiguity about what is actually detected. It does not explicitly contrast with siblings like phases_agents_plan or phases_agents_list_skills.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to reach for this tool versus the other phases_agents_* siblings, nor any stated prerequisites beyond the required absolute path. The only usage-adjacent statement is a safety constraint ("N'execute aucun fichier"), which is behavioral rather than routing guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
phases_agents_get_skillC
Retourne le contenu borne d'un skill valide par identifiant. Aucun chemin libre n'est accepte.
| Name | Required | Description | Default |
|---|---|---|---|
| today | Yes | Date ISO YYYY-MM-DD injectee. | |
| root_ids | Yes | ||
| skill_id | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It hints at two behaviors — content is 'borne' (bounded) and only identifiers (no free paths) are accepted — but never explains the bound, what happens on an invalid/unknown skill_id, permission requirements, or the return shape.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two tight sentences with the core purpose front-loaded and no padding. It is efficient, though extremely sparse for a three-required-parameter tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With three required parameters, no annotations, no output schema, and no explanation of root_ids or today, the description is too thin for an agent to call this tool confidently. The one behavioral constraint it does give ('aucun chemin libre') is not enough to cover the gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 33%: 'today' is documented in the schema while 'root_ids' and 'skill_id' are not. The description says lookup is 'par identifiant' but never explains what root_ids (1–16 ids) is for or why an injected 'today' is required, so it fails to compensate for the coverage gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('Retourne le contenu ... d'un skill') and scopes it by 'identifiant', which separates it from the sibling phases_agents_list_skills (listing) without naming it. The qualifier 'valide' adds a validity condition, but no explicit sibling differentiation is given.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no statement of when to use this tool versus phases_agents_list_skills, phases_agents_refresh_skills, or phases_agents_plan. 'Aucun chemin libre n'est accepte' is an input constraint, not usage guidance. The agent must infer the use case from the name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
phases_agents_list_skillsC
Decouvre et liste uniquement les packages de skills valides.
| Name | Required | Description | Default |
|---|---|---|---|
| today | Yes | Date ISO YYYY-MM-DD injectee. | |
| root_ids | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full behavioral burden. It does not explain what makes a package 'valide', whether discovery scans the filesystem or a cache, whether it is read-only, or how it relates to refresh_skills; only a vague 'découvre' hint is offered.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single compact sentence with no filler, and the filtering constraint is included. It is terse to the point of being under-specified rather than bloated.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no annotations, no output schema, and half the parameters undocumented, the description does not provide enough for an agent to call this correctly or interpret results — notably it never says whether 'valides' filtering has side effects or what is returned.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 50% and the description adds no parameter information at all. In particular 'root_ids' is undocumented in both the schema and the description, leaving the agent to guess what roots to search and what identifier format they take.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb+resource: 'Découvre et liste ... les packages de skills valides', with a scope qualifier ('uniquement ... valides') that hints at filtering. It does not name or contrast with the sibling get_skill or refresh_skills, so sibling differentiation is left to inference.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no when-to-use guidance, no prerequisites, and no mention of the alternatives among siblings (detect, get_skill, plan, refresh_skills). The agent must guess whether listing is a discovery step or a cached read.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
phases_agents_planB
Detecte une cible, charge le registre valide et rend un plan deterministe. N'execute aucun skill.
| Name | Required | Description | Default |
|---|---|---|---|
| today | Yes | Date ISO YYYY-MM-DD injectee. | |
| target | Yes | Chemin absolu local du projet. | |
| root_ids | Yes | ||
| constraints | No | ||
| plan_version | No | ||
| client_capabilities | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It usefully discloses two behavioral traits: it loads a valid registry and it causes no side effects because it executes no skills. Beyond that it says nothing about failure modes, preconditions, or the determinism guarantees referenced around 'plan_version'.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short, front-loaded sentences with zero filler. Purpose and the no-execution constraint come first. It is efficiently written, though arguably too terse given the tool's parameter complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 6 parameters, a nested object, no annotations, and no output schema, the description is far too thin. It does not explain how constraints, plan_version, or client_capabilities shape the plan, nor what the returned plan contains, leaving an agent without enough context to invoke it confidently.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 33% across 6 parameters, including a nested 'constraints' object, yet the description adds no meaning to any parameter. Words like 'cible' and 'registre valide' loosely map to target/root_ids, but no parameter is actually explained, so the coverage gap is not compensated.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action sequence ('Detecte une cible, charge le registre valide et rend un plan deterministe') with a clear deliverable: a deterministic plan. The negation 'N'execute aucun skill' clarifies its scope versus execution-oriented siblings, but it does not name an alternative tool explicitly, so sibling differentiation is only implicit.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The clause 'N'execute aucun skill' implies the tool is for planning rather than execution, giving an implied when-to-use signal. However, it never states when to prefer this over phases_agents_detect or the registry/skill tools, so usage is left largely to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
phases_agents_refresh_skillsC
Reconstruit explicitement un registre depuis les racines autorisees.
| Name | Required | Description | Default |
|---|---|---|---|
| today | Yes | Date ISO YYYY-MM-DD injectee. | |
| root_ids | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It implies a rebuild (likely a mutation that overwrites existing state) and hints at authorization via "racines autorisees", but never states whether existing data is destroyed, whether permissions are required, or if the operation is idempotent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded sentence with no filler or repetition. It is efficiently written, though the terseness comes at the cost of the missing details scored elsewhere.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a mutating, no-annotation, no-output-schema tool, the definition leaves too much unsaid: what the rebuilt registry contains, the effect on existing skills, and what is returned. An agent cannot safely decide whether to call this.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 50%: "today" is documented in the schema, but "root_ids" has no description. The phrase "racines autorisees" loosely signals that root_ids must be authorized roots, but adds no format, cardinality (max 16), or relationship detail beyond what the schema already enforces.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description has a concrete verb ("Reconstruit") and object ("un registre"), but the object does not match the tool name: it says "registre" while the tool is about skills. Nothing distinguishes it from siblings like phases_agents_detect or phases_agents_list_skills, leaving the agent to guess what is actually being rebuilt.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no when-to-use guidance, no prerequisites, and no mention of the sibling tools (detect/get_skill/list_skills/plan) that could be alternatives. The adverb "explicitement" hints the operation is deliberate but does not tell the agent when that is warranted.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
5 tool updates
v0.5.0- First observed
phases_agents_detect - First observed
phases_agents_get_skill - First observed
phases_agents_list_skills - First observed
phases_agents_plan - First observed
phases_agents_refresh_skills
TDQS
Scored across 5 tools
Each tool targets a distinct operation: detect (profile), get_skill (read one), list_skills (enumerate), refresh_skills (rebuild registry), plan (produce a plan). The one soft overlap is that plan already performs detection, so an agent might wonder when to call detect versus plan directly.
All tools share the consistent phases_agents_ prefix followed by clear snake_case verbs/verb_noun forms (detect, get_skill, list_skills, plan, refresh_skills). No mixing of conventions.
Five tools is well-scoped for a skill-registry/planning domain, covering discovery, retrieval, detection, planning, and registry refresh without redundancy.
The surface covers the full read-side lifecycle: enumerate skills, read a skill, refresh the registry, detect a target, and produce a plan. It is read-only by design (no skill authoring/editing), which is a minor gap but consistent with the stated bounded-execution purpose.
Maintenance
Related MCP Connectors
Governed AI agent skills — one library, distributed to devs and exposed to remote agents over MCP.
Control plane for autonomous software labor. Agents claim objectives over MCP with audit trail.
A registry of 5,900+ peer-authored skills any MCP agent can search and load on demand.
AI workflow/MCP implementation package planner.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceEnables coding agents to search, recommend, and validate a stack of reusable skills from a local catalog, producing deterministic plans without modifying the project.6,708 npm1MIT
- FlicenseNot gradedqualityBmaintenanceEnables multi-step, opinionated workflows (skills) as MCP resources with lazy loading, encoding team knowledge like branch naming and test procedures alongside tool execution.2-
- FlicenseNot gradedqualityBmaintenanceEnables AI agents to search, browse, install, and manage a large library of skills via only 7 MCP tools, with skills stored locally and loaded on demand to minimize context overhead.4-
- AlicenseNot gradedqualityCmaintenanceA local, read-only MCP server that lets coding agents search the complete AAS skill catalog, compose and validate agent-chosen skill stacks, and generate reproducible, reviewable plans without uploading project code.6,708 npm1MIT