Back to skill

Security audit

Virtual Intelligent Dev Team

Security checks across malware telemetry and agentic risk

Overview

This skill is a disclosed software workflow router, but it also includes automation paths that can run shell commands and mutate repository files, so it should be reviewed before installation.

Install only if you want a workflow orchestration skill that can create .vidt state, run local scripts, generate resume plans, and mutate candidate repositories. Treat /auto, iteration plans, release-hold remediation, and any command-bearing JSON as high-impact; review generated commands first and prefer disposable worktrees for automation.

SkillSpector

By NVIDIA
Vulnerability Patterns
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • Behavioral ASTexec() Call, eval() Call, Dynamic Import
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
Findings (43)

subprocess module call

Medium
Category
Dangerous Code Execution
Content
if stripped.startswith("python "):
        prefix_len = len(normalized_command) - len(stripped)
        normalized_command = normalized_command[:prefix_len] + sys.executable + stripped[len("python") :]
    proc = subprocess.run(
        ["/bin/zsh", "-lc", normalized_command],
        cwd=str(cwd),
        text=True,
Confidence
99% confidence
Finding
This code runs a string command through /bin/zsh -lc, which gives shell metacharacters full effect and allows arbitrary command execution in the target repository. Because apply_command, rollback_command, and benchmark_command can be user-supplied, this creates a direct command-injection and arbitrary code execution path with side effects on the local system and repository contents.

Lp3

Medium
Category
MCP Least Privilege
Confidence
84% confidence
Finding
The skill describes and references capabilities that include shell, file read/write, network, environment, and MCP-style tool access, but it does not declare permissions or an explicit least-privilege boundary. In an agent setting, undeclared powerful capabilities make it harder to enforce policy, review risk, and constrain execution, increasing the chance of unsafe file, command, or network actions being performed implicitly.

Tp4

High
Category
MCP Tool Poisoning
Confidence
93% confidence
Finding
The declared purpose is a bounded router, but the content reveals a much broader operational surface: writing persistent state, running health/stress checks, telemetry, breaker management, bootstrap utilities, guarded resume execution, and other execution-heavy behaviors. This mismatch is dangerous because reviewers or runtime policy may trust the skill as a simple router while it can trigger materially different actions with filesystem, process, and possibly network effects.

Description-Behavior Mismatch

Medium
Confidence
90% confidence
Finding
This schema explicitly models autonomous setup/go and resume command orchestration, including command strings, state paths, and execution decisions, which expands the skill from bounded routing into operational automation. In an agent ecosystem, hidden or under-documented automation surfaces can enable unsafe command execution patterns, reduce user awareness, and make it easier for downstream components to treat generated commands as trusted actions.

Description-Behavior Mismatch

Medium
Confidence
89% confidence
Finding
The document materially expands the skill from a bounded router into an autonomous optimization orchestrator that can perform repeated improvement loops. Even though it includes guardrails like round caps and evidence requirements, this broadens operational scope and increases the chance of unreviewed autonomous behavior, especially if other controls rely on the skill remaining a simple dispatcher.

Description-Behavior Mismatch

Medium
Confidence
95% confidence
Finding
Allowing offline optimization runs of 100+ rounds creates a substantially more autonomous execution model than the skill's bounded-router framing suggests. Long-running self-optimization loops can amplify mistakes, consume excessive resources, and drift from original intent unless they are tightly permissioned and externally supervised.

Context-Inappropriate Capability

Medium
Confidence
90% confidence
Finding
The script dynamically imports and executes other Python files using importlib.util.spec_from_file_location and exec_module. Even though the paths are fixed to local repository scripts, this still creates a code-execution trust boundary: if those files are modified by an attacker or come from an untrusted checkout, running this initializer will execute arbitrary code beyond simple data initialization.

Description-Behavior Mismatch

Medium
Confidence
93% confidence
Finding
The router appends persistent entries to `.vidt/metrics/decision-log.jsonl`, which means a component expected to only classify requests also mutates repository state. In a skill-routing context this is dangerous because merely asking for routing can silently create directories and write data, enabling covert telemetry, privacy leakage of prompts, and state pollution across runs.

Description-Behavior Mismatch

Medium
Confidence
90% confidence
Finding
The router builds automation setup/go/resume orchestration, including commands for `run_auto_workflow.py` and `resume_from_automation_state.py`, which expands its role from passive routing into execution planning for autonomous actions. In this skill context that is riskier because routing user text can directly influence whether later automation is considered eligible, resumable, or ready for background execution.

Context-Inappropriate Capability

High
Confidence
99% confidence
Finding
The iteration cycle explicitly supports executing arbitrary shell commands against a candidate repository via run_command, including benchmark, apply, and rollback flows. In a skill that is supposed to route and evaluate software tasks, this materially increases danger because the script can mutate code, exfiltrate secrets, or run destructive host commands if an attacker influences those inputs.

Context-Inappropriate Capability

Medium
Confidence
94% confidence
Finding
Applying and reversing patches modifies the candidate workspace and can change files outside the intended workflow if the patch content is malicious or insufficiently constrained. Although patching is an expected development action, doing it automatically in an orchestration script expands the attack surface and can introduce unintended code changes or data loss.

Context-Inappropriate Capability

Medium
Confidence
91% confidence
Finding
When a hold occurs and an iteration workspace is provided, the script can automatically execute a follow-on iteration loop via iteration_loop.run_loop, which may modify files and produce remediation artifacts. In a security-sensitive or CI context, this couples a gate/checking action with state-changing behavior, increasing the risk of unintended repository mutation, unsafe automation chaining, or abuse if the script is run with attacker-influenced inputs or plans.

Context-Inappropriate Capability

Medium
Confidence
94% confidence
Finding
The script claims to update a routing-rules spec, but it accepts an arbitrary --spec-file path and then writes JSON to that resolved location without constraining it to the intended references directory or expected filename. In an agentic workflow, this broad file-write primitive could be abused to overwrite other repository files or adjacent files if an attacker can influence arguments, causing integrity loss or workflow tampering.

Vague Triggers

Medium
Confidence
88% confidence
Finding
The eval set includes broad natural-language prompts that can match common user phrasing without enough disambiguation context. In a router skill, this increases the risk of unintended activation or misrouting, which can trigger inappropriate workflows such as git, release, or multi-agent orchestration for casual requests.

Vague Triggers

Medium
Confidence
93% confidence
Finding
The prompt example is extremely vague and effectively invites the skill to engage on generic requests with little or no software-task grounding. Because this skill is a bounded workflow router with powerful execution-oriented branches, vague invocation paths make accidental out-of-scope routing and unsafe automation more likely.

Vague Triggers

Medium
Confidence
90% confidence
Finding
The trigger lists use short, generic keywords like 'java', 'spring', and 'gc' that are likely to appear in ordinary discussion, increasing the chance of misrouting a request to the wrong specialist. In a routing skill, over-broad activation is security-relevant because it can bypass intended review paths, attach the wrong guidance, or suppress higher-scrutiny workflows for sensitive tasks.

Vague Triggers

Medium
Confidence
93% confidence
Finding
The general backend agent is keyed on very common engineering terms such as 'backend', 'api', 'service', and language names, making it a likely catch-all that can overshadow more specialized agents. In this catalog, that creates governance risk because sensitive API, security review, or data-pipeline work may be routed to a lower-scrutiny generalist path.

Vague Triggers

Medium
Confidence
89% confidence
Finding
Terms like 'review', 'audit', and 'code review' are broad and can activate on casual conversation rather than a true review request. Because this skill uses routing to determine workflow and evidence requirements, ambiguous review triggers can distort which controls are applied and when blocking findings should be surfaced.

Vague Triggers

Medium
Confidence
91% confidence
Finding
The Git agent trigger list includes common verbs like 'commit', 'push', 'merge', and 'branch', which frequently occur in normal development discussion. That makes accidental activation likely and can steer users into operational Git workflows even when the real request is architectural, review-related, or advisory-only.

Vague Triggers

Medium
Confidence
88% confidence
Finding
The product architect trigger set contains a large number of broad terms spanning product, UI, and frontend work, which can over-match many software discussions. In a bounded work-loop router, this can divert technical or security-relevant tasks into a product-heavy path that may not apply the most appropriate engineering or audit controls.

Vague Triggers

Medium
Confidence
90% confidence
Finding
The data pipeline agent is triggered by generic data terms and well-known platform names such as 'kafka', 'spark', and 'data quality', which may be referenced incidentally. This can cause accidental routing of unrelated infrastructure or application tasks into a pipeline-governance path, weakening accuracy and potentially bypassing the most relevant specialist controls.

Vague Triggers

Medium
Confidence
94% confidence
Finding
The API contract agent relies on highly generic terms like 'API design', 'REST API', and 'API security', which are pervasive across engineering requests. In this skill, that broad matching can misroute implementation, architecture, or review tasks and create policy confusion around contract-signing, compatibility checks, and security obligations.

Vague Triggers

Low
Confidence
85% confidence
Finding
The schema accepts many operationally significant fields such as paths, identifiers, and especially the summary_command_template as arbitrary strings without format, pattern, enum, or structural constraints. In a skill that coordinates multi-step automated workflows, this ambiguity can enable unsafe downstream interpretation, including path misuse, command/template injection, or execution of unintended scenarios if consuming code assumes these values are trustworthy.

Vague Triggers

Medium
Confidence
84% confidence
Finding
The trigger conditions are broad enough that the playbook may activate for many ordinary repository interactions, including concrete Git operations, without tight scoping to user intent or repository state. In an agent skill, broad invocation boundaries increase the chance of unsolicited workflow enforcement or accidental execution of repository-affecting commands in the wrong context.

Vague Triggers

Medium
Confidence
84% confidence
Finding
The schema allows a free-form `recommended_commands` array of arbitrary strings with no validation, restriction, or safety boundary. In an agent skill context, command-like strings are especially sensitive because downstream components may present, trust, or execute them, enabling prompt-to-command injection or unsafe operator guidance if untrusted report data is propagated.

VirusTotal

VirusTotal findings are pending for this skill version.

View on VirusTotal

Static analysis

Detected: suspicious.dynamic_code_execution

Dynamic code execution detected.

Critical
Code
suspicious.dynamic_code_execution
Location
scripts/automation_state.py:24

Dynamic code execution detected.

Critical
Code
suspicious.dynamic_code_execution
Location
scripts/build_release_gate_eval_fixture.py:36

Dynamic code execution detected.

Critical
Code
suspicious.dynamic_code_execution
Location
scripts/build_verify_action_eval_fixture.py:32

Dynamic code execution detected.

Critical
Code
suspicious.dynamic_code_execution
Location
scripts/compare_benchmark_results.py:21

Dynamic code execution detected.

Critical
Code
suspicious.dynamic_code_execution
Location
scripts/compare_beta_simulation_manifests.py:25

Dynamic code execution detected.

Critical
Code
suspicious.dynamic_code_execution
Location
scripts/evaluate_beta_round.py:25

Dynamic code execution detected.

Critical
Code
suspicious.dynamic_code_execution
Location
scripts/evaluate_micro_practices.py:25

Dynamic code execution detected.

Critical
Code
suspicious.dynamic_code_execution
Location
scripts/evaluate_post_release_feedback.py:25

Dynamic code execution detected.

Critical
Code
suspicious.dynamic_code_execution
Location
scripts/generate_response_pack.py:25

Dynamic code execution detected.

Critical
Code
suspicious.dynamic_code_execution
Location
scripts/init_beta_round_report.py:24

Dynamic code execution detected.

Critical
Code
suspicious.dynamic_code_execution
Location
scripts/init_beta_simulation.py:31

Dynamic code execution detected.

Critical
Code
suspicious.dynamic_code_execution
Location
scripts/init_micro_practices.py:27

Dynamic code execution detected.

Critical
Code
suspicious.dynamic_code_execution
Location
scripts/inspect_automation_state.py:22

Dynamic code execution detected.

Critical
Code
suspicious.dynamic_code_execution
Location
scripts/lint_virtual_team_contract.py:69

Dynamic code execution detected.

Critical
Code
suspicious.dynamic_code_execution
Location
scripts/preview_beta_simulation_fixture.py:24

Dynamic code execution detected.

Critical
Code
suspicious.dynamic_code_execution
Location
scripts/promote_iteration_baseline.py:21

Dynamic code execution detected.

Critical
Code
suspicious.dynamic_code_execution
Location
scripts/register_benchmark_baseline.py:25

Dynamic code execution detected.

Critical
Code
suspicious.dynamic_code_execution
Location
scripts/resume_from_automation_state.py:36

Dynamic code execution detected.

Critical
Code
suspicious.dynamic_code_execution
Location
scripts/route_request.py:217

Dynamic code execution detected.

Critical
Code
suspicious.dynamic_code_execution
Location
scripts/run_auto_workflow.py:33

Dynamic code execution detected.

Critical
Code
suspicious.dynamic_code_execution
Location
scripts/run_benchmarks.py:40

Dynamic code execution detected.

Critical
Code
suspicious.dynamic_code_execution
Location
scripts/run_beta_simulation.py:25

Dynamic code execution detected.

Critical
Code
suspicious.dynamic_code_execution
Location
scripts/run_iteration_cycle.py:30

Dynamic code execution detected.

Critical
Code
suspicious.dynamic_code_execution
Location
scripts/run_iteration_loop.py:26

Dynamic code execution detected.

Critical
Code
suspicious.dynamic_code_execution
Location
scripts/run_offline_loop_drill.py:27

Dynamic code execution detected.

Critical
Code
suspicious.dynamic_code_execution
Location
scripts/run_release_gate.py:39

Dynamic code execution detected.

Critical
Code
suspicious.dynamic_code_execution
Location
scripts/run_stress_scenarios.py:45

Dynamic code execution detected.

Critical
Code
suspicious.dynamic_code_execution
Location
scripts/summarize_beta_simulation.py:25

Dynamic code execution detected.

Critical
Code
suspicious.dynamic_code_execution
Location
scripts/update_micro_practices.py:25

Dynamic code execution detected.

Critical
Code
suspicious.dynamic_code_execution
Location
scripts/validate_virtual_team.py:31

Dynamic code execution detected.

Critical
Code
suspicious.dynamic_code_execution
Location
scripts/verify_action.py:37

Dynamic code execution detected.

Critical
Code
suspicious.dynamic_code_execution
Location
scripts/verify_completion_evidence.py:64

Dynamic code execution detected.

Critical
Code
suspicious.dynamic_code_execution
Location
tests/test_routing_and_guardrails.py:74