# Virtual Item Market Valuation

> Virtual Item Market Analysis & Valuation (Steam Market, CS:GO Skins) — Professional-grade harness for evidence-backed market analysis. Use this skill whenever the user asks about virtual item pricing, Steam market analysis, CS:GO skin valuation, cross-market arbitrage, virtual economy trends, or needs to assess the value/risk of digital gaming assets. This includes phrases like "analyze this skin…

- **Type:** Skill
- **Install:** `agentstack add skill-dungnotnull-virtual-item-market-valuation-agent-skill-virtual-item-market-valuation-agent-skill`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [dungnotnull](https://agentstack.voostack.com/s/dungnotnull)
- **Installs:** 0
- **Category:** [Agent Skills](https://agentstack.voostack.com/c/agent-skills)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [dungnotnull](https://github.com/dungnotnull)
- **Source:** https://github.com/dungnotnull/virtual-item-market-valuation-agent-skill

## Install

```sh
agentstack add skill-dungnotnull-virtual-item-market-valuation-agent-skill-virtual-item-market-valuation-agent-skill
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# Virtual Item Market Valuation — Skill Registry

## Overview

This skill provides a **6-step harness pipeline** for Virtual-Item Market Economics & Price Valuation, transforming Claude into a domain expert that delivers structured, evidence-backed outputs with risk disclosure and academic grounding.

## Architecture Pattern: Flexible Skill Registry

### Hierarchy Design

```
virtual-item-market-valuation (Main Harness)
├── Chain-of-Thought Router
│   ├── Market Type Detection (Steam/CS:GO/General Virtual)
│   ├── Analysis Type Router (Valuation/Risk Assessment/Market Research)
│   └── Language Detector (Vietnamese/English)
│
├── Specialized Sub-Skills
│   ├── sub-gather-requirements — Intake & Scope Clarification
│   ├── sub-evidence-collector — Multi-Source Data Aggregation
│   ├── sub-core-analysis — Valuation & Manipulation Detection
│   ├── sub-knowledge-updater — Academic Evidence Integration
│   └── sub-advisor — Risk-Disclosed Synthesis
│
├── Quality Gate System
│   ├── Universal Gates (U1-U6)
│   └── Domain Gates (G1-G4)
│
└── Graceful Degradation Protocol
    ├── Level 0: Full Analysis
    ├── Level 1: Secondary Sources
    ├── Level 2: Knowledge Base Only
    ├── Level 3: Missing Data Flagged
    └── Level 4: Unavailable Notice
```

### Skill Registration Schema

Each skill must register with the following schema:

```yaml
skill_id: unique_identifier
name: Display Name
description: When to trigger (60 words max)
input_schema: JSON Schema for inputs
output_schema: JSON Schema for outputs
tools_required: List of required tools
quality_gates: List of gate identifiers
degradation_support: Supported degradation levels
```

## Module: `/scripts`

### Purpose
Automation, database seeding, ingestion, or local setup routines.

### Available Scripts

| Script | Purpose | Usage |
|--------|---------|-------|
| `setup_env.py` | Environment setup and dependency check | `python scripts/setup_env.py` |
| `seed_knowledge.py` | Initial knowledge base seeding | `python scripts/seed_knowledge.py` |
| `crawl_market_data.py` | Market data ingestion pipeline | `python scripts/crawl_market_data.py --market steam --days 30` |
| `validate_skillchain.py` | Skill chain integrity validator | `python scripts/validate_skillchain.py` |

## Module: `/references`

### Purpose
Domain knowledge, prompt base-templates, or raw context guidelines used for RAG/agent grounding.

### Reference Documents

| Document | Purpose | Update Frequency |
|----------|---------|-------------------|
| `market-microstructure.md` | Authoritative market microstructure methods | Quarterly |
| `valuation-methods.md` | Comparables & intrinsic valuation frameworks | Semi-annually |
| `manipulation-patterns.md` | Known manipulation patterns (wash/pump/scarcity) | Monthly |
| `tier-evidence.md` | Evidence hierarchy (Tier 1-4) definitions | As needed |
| `output-templates.md` | Standard output format templates | As needed |

## Module: `/assets`

### Purpose
Static resources, system diagrams, or schemas.

### Assets

| Asset | Type | Purpose |
|-------|------|---------|
| `harness-diagram.svg` | System diagram | Architecture visualization |
| `output-template.md` | Template file | Standard output format |
| `quality-gates-schema.json` | Schema definition | Gate validation rules |

## Module: `/config`

### Purpose
Dedicated, type-safe configuration management.

### Configuration Files

| File | Purpose | Schema |
|------|---------|--------|
| `skill-registry.json` | Skill registration and routing | See schema below |
| `quality-gates.json` | Gate definitions and auto-fix rules | See schema below |
| `degradation-levels.json` | Degradation behavior definitions | See schema below |
| `source-tiers.json` | Evidence tier classifications | See schema below |
| `env.yaml` | Environment-specific configuration | Standard YAML config |

### Configuration Schema: skill-registry.json

```json
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "title": "Skill Registry Configuration",
  "type": "object",
  "properties": {
    "skills": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "skill_id": {"type": "string"},
          "name": {"type": "string"},
          "description": {"type": "string", "maxLength": 400},
          "input_schema": {"type": "object"},
          "output_schema": {"type": "object"},
          "tools_required": {"type": "array", "items": {"type": "string"}},
          "quality_gates": {"type": "array", "items": {"type": "string"}},
          "degradation_support": {"type": "array", "items": {"type": "integer", "minimum": 0, "maximum": 4}}
        },
        "required": ["skill_id", "name", "description"]
      }
    },
    "routing_rules": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "condition": {"type": "string"},
          "target_skill": {"type": "string"}
        }
      }
    }
  }
}
```

## Module: `/hooks`

### Purpose
Lifecycle management, state synchronization, event emission.

### Hook System Architecture

```
Hook Event Flow:
┌─────────────┐
│ User Input  │
└──────┬──────┘
       │
       ▼
┌──────────────────────────────────────────────┐
│ Pre-Hook: on_skill_invocation                 │
│   - Validate input schema                     │
│   - Detect language                            │
│   - Log invocation context                     │
└──────────────────────┬────────────────────────┘
                       │
                       ▼
┌──────────────────────────────────────────────┐
│ Execution Hook: on_skill_execute              │
│   - Monitor token usage                        │
│   - Track execution metrics                    │
│   - Emit progress events                       │
└──────────────────────┬────────────────────────┘
                       │
                       ▼
┌──────────────────────────────────────────────┐
│ Quality Hook: on_quality_gate                 │
│   - Validate gate criteria                    │
│   - Execute auto-fix if enabled                │
│   - Log gate violations                       │
└──────────────────────┬────────────────────────┘
                       │
                       ▼
┌──────────────────────────────────────────────┐
│ Post-Hook: on_skill_complete                  │
│   - Validate output schema                     │
│   - Generate metrics report                    │
│   - Emit completion event                      │
└──────────────────────────────────────────────┘
```

### Available Hooks

| Hook | Event | Parameters | Return |
|------|-------|------------|--------|
| `on_skill_invocation` | Before skill execution | `context: dict`, `input: any` | `validated_input: any` |
| `on_skill_execute` | During execution | `step: str`, `metrics: dict` | `None` |
| `on_quality_gate` | Gate evaluation | `gate_id: str`, `data: dict` | `pass: bool`, `fix_applied: bool` |
| `on_skill_complete` | After execution | `output: any`, `metrics: dict` | `final_output: any` |
| `on_error` | Error handling | `error: Exception`, `context: dict` | `recovery: dict` |

## Tool Definitions

### Core Tool Schema

Each tool must define:

```yaml
tool_id: unique_identifier
name: Display Name
description: When and why to use this tool
input_schema: JSON Schema
output_schema: JSON Schema
execution_handler: Reference to implementation
rate_limit: Requests per minute (optional)
retry_policy: Retry configuration (optional)
```

### Tool Catalog

| Tool ID | Purpose | Input Schema | Handler |
|---------|---------|-------------|---------|
| `web_search_domain` | Domain-specific web search | `{query: str, sources: list}` | `tools/web_handler.py::search_domain` |
| `fetch_market_data` | Fetch real-time market data | `{item_id: str, source: str}` | `tools/market_fetcher.py::fetch` |
| `query_knowledge_base` | Query SECOND-KNOWLEDGE-BRAIN.md | `{keywords: list, tier_min: int}` | `tools/knowledge_query.py::query` |
| `calculate_valuation` | Valuation calculation | `{item_data: dict, method: str}` | `tools/valuation.py::calculate` |
| `detect_manipulation` | Manipulation pattern detection | `{price_history: list, volume: list}` | `tools/manipulation_detector.py::detect` |

## Execution Flow

### 1. Input Processing
```
User Input → Language Detection → Domain Classification → Routing
```

### 2. Skill Chain Execution
```
sub-gather-requirements → [Gate G0]
    → sub-evidence-collector → [Gate G1]
    → sub-core-analysis → [Gate G2]
    → sub-knowledge-updater → [Gate G3]
    → sub-advisor → [Gate G4]
```

### 3. Quality Gate Validation
```
For each gate in sequence:
    1. Evaluate gate condition
    2. If fail: execute auto-fix
    3. Retry (max 2 attempts)
    4. If still fail: emit limitation notice and continue
```

### 4. Output Generation
```
Apply output template → Translate to detected language → Validate schema → Deliver
```

## Error Recovery Matrix

| Error Type | Detection | Recovery | Retry Limit |
|------------|-----------|----------|-------------|
| Source Timeout | No response in 30s | Retry alternate source | 3 |
| Invalid Input | Schema validation fail | Request clarification | 2 |
| Missing Input | Required field absent | Proceed with available + flag | N/A |
| Stale Data | Timestamp beyond threshold | Flag, request refresh | 1 |
| Knowledge Gap | No KB matches | WebSearch gap-fill + queue crawl | 2 |
| Conflict Detection | Mutually exclusive actions | Apply precedence rule | N/A |
| Gate Failure | Quality gate not met | Execute auto-fix protocol | 2 |

## Version History

| Version | Date | Changes |
|---------|------|---------|
| 1.0.0 | 2026-07-20 | Initial flexible architecture implementation |

## Contributing

When adding new skills or tools:

1. Follow the registration schema in `config/skill-registry.json`
2. Implement the tool handler in `tools/` directory
3. Add quality gate definitions to `config/quality-gates.json`
4. Update this SKILL.md with the new registration
5. Run `python scripts/validate_skillchain.py` to verify integrity

## References

- Main harness: `skills/main.md`
- Quality gates: `skills/main.md` → Quality Gates section
- Degradation protocol: `skills/main.md` → Graceful Degradation section
- Tool implementations: `tools/` directory
- Configuration schemas: `config/*.json` files

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [dungnotnull](https://github.com/dungnotnull)
- **Source:** [dungnotnull/virtual-item-market-valuation-agent-skill](https://github.com/dungnotnull/virtual-item-market-valuation-agent-skill)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-dungnotnull-virtual-item-market-valuation-agent-skill-virtual-item-market-valuation-agent-skill
- Seller: https://agentstack.voostack.com/s/dungnotnull
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.