T01 · Skill Instruction Hijacking
- Location
SKILL.md:2- Finding
Always-On Instructions Override the Agent's Command-Execution Policy
- Content
View full analysis
- Remediation
View remediation
Security audit
Security checks for vulnerabilities and agentic risk
This skill is openly about forcing uv usage for Python work, but its always-on scope and unpinned uvx execution make it broad enough to warrant Review before installation.
Install only if you intentionally want an always-on policy that routes Python commands through uv. Review projects with pinned, offline, hermetic, or non-uv workflows carefully, and prefer project-managed locked tools over unpinned uvx or @latest commands.
SKILL.md:2Always-On Instructions Override the Agent's Command-Execution Policy
SKILL.md:43Unpinned Third-Party Tools Are Downloaded and Executed Through uvx
The skill is marked effectively mandatory and activates on virtually any Python-related mention, forcing command rewrites across a very broad set of tasks. Overbroad always-on behavior can override safer task-specific instructions, trigger unnecessary package/tool execution, and increase the attack surface when combined with dynamic uv/uvx usage.
The 'Use when' section covers nearly every Python-related activity without clear boundaries, making the skill applicable far beyond a narrow package-management helper. In context, this amplifies the risk of unsafe or inappropriate command substitution across unrelated workflows and reduces operator control.
uvx/uv tool run commands without ==version create a rug-pull risk.
The document includes mandatory instructional content in Portuguese such as 'Ferramenta do projeto' and 'precisa importar seus módulos' without offering a language choice. This can violate language policy expectations because users are not given an opt-in or alternative language selection.
The skill instructs use of uvx ruff check . without pinning a version. uvx resolves and executes packages from a registry at runtime, so unpinned usage can lead to supply-chain drift, unexpected behavior changes, or execution of a compromised latest release.
This line recommends unpinned uvx ruff, which fetches and runs the current package version. That creates a supply-chain risk because behavior can change over time or a malicious upstream release could be executed implicitly.
Several example comments are written in Portuguese, including explanations for ruff, black, mypy, and isort usage. Because these examples are part of the core guidance and no language preference is offered, the skill implicitly imposes a locale on users.
The example uses uvx black . without constraining the version. Running unpinned remote CLI packages increases exposure to compromised upstream releases and non-reproducible execution.
The skill directs use of unpinned uvx mypy ., which permits runtime retrieval of whichever version is latest or otherwise resolved. That can introduce supply-chain compromise risk and inconsistent analysis results across environments.
This unpinned uvx isort . example can execute an unreviewed upstream version at runtime. For security-sensitive agent behavior, that creates unnecessary dependence on mutable external state.
uvx/uv tool run commands without ==version create a rug-pull risk.
The examples for pytest, application execution, and dbt include Portuguese-only explanatory text as part of the main operational instructions. This creates a language/locale constraint without documenting user choice or a justified region-specific requirement.
The guidance allows uvx pytest as a one-off without version pinning. That means the agent may fetch and execute whatever pytest release resolves at runtime, creating reproducibility and supply-chain integrity concerns.
This line repeats unpinned uvx pytest tests/ guidance. Executing unpinned external packages increases the chance of malicious or breaking upstream changes affecting agent behavior.
The example recommends unpinned uvx black ., which can pull a mutable version from the package source at execution time. This weakens supply-chain control and reproducibility.
This line promotes unpinned uvx ruff check ., exposing users to mutable upstream package resolution. Even for developer tools, agent instructions should avoid implicit execution of latest remote code.
Using uvx mypy . without a fixed version introduces external mutable dependency execution. That can lead to compromised tool execution or inconsistent output between runs.
The table suggests uvx pytest without version pinning. Because uvx resolves packages dynamically, this opens a supply-chain and reproducibility risk in agent-directed command execution.
The uvx black . example is unpinned and therefore executes a mutable external package version. This is a standard supply-chain hardening issue rather than an overtly malicious instruction.
The unpinned uvx ruff check . guidance can cause the agent to fetch and run a changing upstream release. In an always-on skill, repeated use amplifies the risk surface.
This uvx mypy . example lacks version pinning, allowing arbitrary future versions to be executed. That is dangerous because security and behavior now depend on external package state at runtime.
The skill recommends unpinned uvx flake8, which is a remote package execution path without immutability. This can expose users to malicious or simply incompatible upstream changes.
The unpinned uvx pylint command executes a mutable external dependency. In a mandatory skill, that behavior could be applied widely across sessions, increasing the blast radius of an upstream compromise.
This uvx isort . example is unpinned and therefore subject to supply-chain drift. The risk is not from isort specifically, but from instructing dynamic execution of remote packages without version control.
The line recommends uvx poetry without version pinning. That can result in execution of a mutable upstream tool version, which is unsafe for deterministic and trustworthy agent behavior.
No suspicious patterns detected.