Virtual Item Market Valuation

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:

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

{
  "$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:

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
• Source: dungnotnull/virtual-item-market-valuation-agent-skill
• License: MIT

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