# Iot Satellite Forest Fire Early Warning

> IoT + Satellite Forest-Fire Early-Warning System — Comprehensive evidence-backed analysis harness for forest fire early warning using IoT sensors, satellite data, and academic research. Use for forest fire risk assessment, early warning system design, vegetation monitoring, fire-danger index computation, IoT sensor deployment, satellite active-fire detection, UAV confirmation, and evidence-based…

- **Type:** Skill
- **Install:** `agentstack add skill-dungnotnull-iot-satellite-forest-fire-early-warning-agent-skill-iot-satellite-forest-fire-early-warning-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/iot-satellite-forest-fire-early-warning-agent-skill

## Install

```sh
agentstack add skill-dungnotnull-iot-satellite-forest-fire-early-warning-agent-skill-iot-satellite-forest-fire-early-warning-agent-skill
```

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

## About

# SKILL.md — IoT Satellite Forest Fire Early Warning Registry

## Overview

This document serves as the comprehensive skill registry for the `iot-satellite-forest-fire-early-warning` system. It defines how skills are registered, resolved, executed, and validated, including complete input/output JSON schemas.

## System Architecture

```
┌─────────────────────────────────────────────────────────────────┐
│                    Skill Orchestrator                            │
│                                                               │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐           │
│  │  Registry   │  │    Hooks    │  │    Tools    │           │
│  └──────┬──────┘  └──────┬──────┘  └──────┬──────┘           │
│         │                │                │                   │
│         └────────────────┼────────────────┘                   │
│                          │                                     │
┌──────────────────────────┼─────────────────────────────────────┐
│                          │                                     │
│                   ┌──────▼──────┐                               │
│                   │  Main Skill │                               │
│                   └──────┬──────┘                               │
│                          │                                     │
│    ┌─────────────────────┼─────────────────────┐              │
│    │                     │                     │               │
┌────▼──────┐  ┌──────────▼──────┐  ┌──────────▼────────┐      │
│ Sub-Skill │  │  Sub-Skill 2   │  │  Sub-Skill N      │      │
│    1      │  │                 │  │                  │      │
└───────────┘  └─────────────────┘  └──────────────────┘      │
│                                                              │
└──────────────────────────────────────────────────────────────┘
```

## Skill Registration

### Registration Process

Skills are registered through a multi-step process:

1. **Manifest Declaration**: Each skill declares itself in `SKILL.md` frontmatter
2. **Schema Validation**: Input/output schemas are validated against the registry
3. **Hook Binding**: Lifecycle hooks are bound to skill events
4. **Tool Association**: Required tools are associated and validated
5. **Quality Gate Assignment**: Quality gates are assigned based on skill category

### Skill Manifest Schema

```json
{
  "type": "object",
  "required": ["name", "description", "version", "category"],
  "properties": {
    "name": {
      "type": "string",
      "pattern": "^[a-z0-9-]+$",
      "description": "Unique skill identifier in kebab-case"
    },
    "description": {
      "type": "string",
      "minLength": 50,
      "maxLength": 500,
      "description": "Detailed description of when and how to trigger the skill"
    },
    "version": {
      "type": "string",
      "pattern": "^\d+\.\d+\.\d+$",
      "description": "Semantic version"
    },
    "category": {
      "type": "string",
      "enum": ["domain-analysis", "data-processing", "code-generation", "validation"],
      "description": "Skill category for routing"
    },
    "tags": {
      "type": "array",
      "items": {"type": "string"},
      "description": "Tags for skill discovery"
    },
    "compatibility": {
      "type": "object",
      "properties": {
        "required_tools": {"type": "array", "items": {"type": "string"}},
        "python_version": {"type": "string"},
        "dependencies": {"type": "array", "items": {"type": "string"}}
      }
    }
  }
}
```

## Sub-Skill Registry

### Available Sub-Skills

| Sub-Skill | Purpose | Input Schema | Output Schema |
|-----------|---------|--------------|---------------|
| `sub-gather-requirements` | Intake and requirements clarification | RequirementsInput | RequirementsOutput |
| `sub-evidence-collector` | Data fetching and evidence collection | EvidenceInput | EvidenceOutput |
| `sub-core-analysis` | Domain analysis and computation | AnalysisInput | AnalysisOutput |
| `sub-knowledge-updater` | Knowledge base querying | KnowledgeQueryInput | KnowledgeQueryOutput |
| `sub-advisor` | Synthesis and recommendation | AdvisorInput | AdvisorOutput |

### Input/Output Schemas

#### RequirementsInput
```json
{
  "type": "object",
  "properties": {
    "user_message": {
      "type": "string",
      "description": "Raw user input message"
    },
    "language": {
      "type": "string",
      "enum": ["en", "vi"],
      "description": "User's preferred language"
    },
    "context": {
      "type": "object",
      "description": "Additional context from previous interactions"
    }
  },
  "required": ["user_message"]
}
```

#### RequirementsOutput
```json
{
  "type": "object",
  "properties": {
    "object_of_analysis": {
      "type": "string",
      "description": "What is being analyzed"
    },
    "scope": {
      "type": "string",
      "description": "Analysis scope and boundaries"
    },
    "timeframe": {
      "type": "string",
      "description": "Analysis timeframe"
    },
    "available_inputs": {
      "type": "array",
      "items": {"type": "string"},
      "description": "Available data inputs"
    },
    "target_audience": {
      "type": "string",
      "description": "Target audience for output"
    },
    "language": {
      "type": "string",
      "enum": ["en", "vi"]
    },
    "analysis_type": {
      "type": "string",
      "description": "Type of analysis required"
    },
    "valid": {
      "type": "boolean",
      "description": "Whether requirements are valid"
    }
  },
  "required": ["object_of_analysis", "language", "valid"]
}
```

#### EvidenceInput
```json
{
  "type": "object",
  "properties": {
    "requirements": {"$ref": "#/definitions/RequirementsOutput"},
    "data_sources": {
      "type": "array",
      "items": {"type": "string"},
      "description": "Preferred data sources"
    }
  },
  "required": ["requirements"]
}
```

#### EvidenceOutput
```json
{
  "type": "object",
  "properties": {
    "current_data": {
      "type": "object",
      "description": "Current real-time data with source and timestamp"
    },
    "authoritative_docs": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "title": {"type": "string"},
          "source": {"type": "string"},
          "url": {"type": "string"},
          "date": {"type": "string"},
          "tier": {"type": "string", "enum": ["Tier 1", "Tier 2", "Tier 3", "Tier 4"]}
        }
      },
      "description": "Authoritative documents and standards"
    },
    "recent_news": {
      "type": "array",
      "items": {"type": "object"},
      "description": "Recent developments from domain sources"
    },
    "reference_benchmarks": {
      "type": "object",
      "description": "Reference benchmark data"
    },
    "degradation_level": {
      "type": "integer",
      "minimum": 0,
      "maximum": 4,
      "description": "Data availability degradation level"
    }
  },
  "required": ["current_data", "degradation_level"]
}
```

#### AnalysisInput
```json
{
  "type": "object",
  "properties": {
    "requirements": {"$ref": "#/definitions/RequirementsOutput"},
    "evidence": {"$ref": "#/definitions/EvidenceOutput"},
    "parameters": {
      "type": "object",
      "properties": {
        "forest_region": {"type": "string"},
        "weather_data": {
          "type": "object",
          "properties": {
            "temperature": {"type": "number"},
            "humidity": {"type": "number"},
            "wind_speed": {"type": "number"},
            "rainfall": {"type": "number"}
          }
        },
        "sensor_config": {
          "type": "object",
          "description": "IoT sensor configuration"
        },
        "satellite_coverage": {
          "type": "boolean",
          "description": "Satellite data availability"
        }
      }
    }
  },
  "required": ["requirements", "evidence"]
}
```

#### AnalysisOutput
```json
{
  "type": "object",
  "properties": {
    "fire_danger_index": {
      "type": "object",
      "properties": {
        "name": {"type": "string", "enum": ["FWI", "NFDRS"]},
        "value": {"type": "number"},
        "components": {"type": "object"},
        "danger_class": {"type": "string"}
      }
    },
    "iot_deployment": {
      "type": "object",
      "properties": {
        "sensors": {"type": "array", "items": {"type": "object"}},
        "coverage_area": {"type": "string"},
        "data_frequency": {"type": "string"}
      }
    },
    "satellite_monitoring": {
      "type": "object",
      "properties": {
        "active_fires": {"type": "array", "items": {"type": "object"}},
        "vegetation_dryness": {"type": "object"},
        "refresh_interval": {"type": "string"}
      }
    },
    "alerts": {
      "type": "object",
      "properties": {
        "thresholds": {"type": "object"},
        "notification_channels": {"type": "array"}
      }
    },
    "uav_confirmation": {
      "type": "object",
      "properties": {
        "deployment_criteria": {"type": "object"},
        "confirmation_protocol": {"type": "string"}
      }
    },
    "scenarios": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "name": {"type": "string"},
          "probability": {"type": "number"},
          "impact": {"type": "string"},
          "actions": {"type": "array"}
        }
      }
    }
  },
  "required": ["fire_danger_index", "scenarios"]
}
```

#### KnowledgeQueryInput
```json
{
  "type": "object",
  "properties": {
    "keywords": {
      "type": "array",
      "items": {"type": "string"},
      "minItems": 1
    },
    "max_results": {
      "type": "integer",
      "default": 5,
      "minimum": 1,
      "maximum": 20
    },
    "required_tiers": {
      "type": "array",
      "items": {"type": "string", "enum": ["Tier 1", "Tier 2", "Tier 3", "Tier 4"]}
    }
  },
  "required": ["keywords"]
}
```

#### KnowledgeQueryOutput
```json
{
  "type": "object",
  "properties": {
    "evidence": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "title": {"type": "string"},
          "authors": {"type": "array", "items": {"type": "string"}},
          "year": {"type": "integer"},
          "doi": {"type": "string"},
          "journal": {"type": "string"},
          "tier": {"type": "string", "enum": ["Tier 1", "Tier 2", "Tier 3", "Tier 4"]},
          "relevance_score": {"type": "number"},
          "citation_count": {"type": "integer"}
        }
      }
    },
    "coverage_rating": {
      "type": "string",
      "enum": ["comprehensive", "adequate", "limited", "insufficient"]
    },
    "gaps": {
      "type": "array",
      "items": {"type": "string"},
      "description": "Identified knowledge gaps for crawl pipeline"
    }
  },
  "required": ["evidence", "coverage_rating"]
}
```

#### AdvisorInput
```json
{
  "type": "object",
  "properties": {
    "requirements": {"$ref": "#/definitions/RequirementsOutput"},
    "evidence": {"$ref": "#/definitions/EvidenceOutput"},
    "analysis": {"$ref": "#/definitions/AnalysisOutput"},
    "knowledge": {"$ref": "#/definitions/KnowledgeQueryOutput"}
  },
  "required": ["requirements", "analysis"]
}
```

#### AdvisorOutput
```json
{
  "type": "object",
  "properties": {
    "verdict": {
      "type": "string",
      "enum": ["Low Fire Risk", "Monitor (elevated)", "Critical Alert", "Dispatch", "Inconclusive"]
    },
    "confidence": {
      "type": "string",
      "enum": ["high", "medium", "low"]
    },
    "scenarios": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "name": {"type": "string"},
          "probability": {"type": "number"},
          "impact": {"type": "string"},
          "actions": {"type": "array"}
        }
      }
    },
    "key_risks": {
      "type": "array",
      "items": {"type": "string"}
    },
    "evidence_chain": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "claim": {"type": "string"},
          "source": {"type": "string"},
          "tier": {"type": "string"}
        }
      }
    },
    "remediation": {
      "type": "array",
      "items": {"type": "object"}
    },
    "disclosure": {
      "type": "string",
      "description": "Mandatory disclosure before recommendation"
    }
  },
  "required": ["verdict", "disclosure"]
}
```

## Skill Resolution

### Resolution Algorithm

Skills are resolved through a multi-stage process:

1. **Trigger Detection**: User input is analyzed for skill trigger patterns
2. **Candidate Matching**: Skills are scored based on description similarity
3. **Compatibility Check**: Required tools and dependencies are verified
4. **Context Validation**: Input context is validated against skill schemas
5. **Skill Selection**: Highest scoring compatible skill is selected

### Trigger Patterns

| Pattern Type | Example | Weight |
|--------------|---------|--------|
| Direct invocation | `/iot-satellite-forest-fire-early-warning` | 1.0 |
| Domain keywords | "forest fire risk", "fire danger index" | 0.8 |
| Task description | "design early warning system" | 0.7 |
| Contextual | analyze vegetation, IoT sensors | 0.6 |

## Skill Execution

### Execution Protocol

```
1. PRE-FLIGHT CHECKS
   ├─ Validate configuration
   ├─ Check tool availability
   ├─ Load skill metadata
   └─ Initialize execution context

2. STEP EXECUTION
   For each step in harness:
   ├─ Emit BEFORE_STEP_EXECUTE hook
   ├─ Validate step input against schema
   ├─ Execute step logic
   ├─ Validate step output against schema
   ├─ Emit AFTER_STEP_EXECUTE hook
   └─ Handle errors with graceful degradation

3. QUALITY GATE VALIDATION
   For each quality gate:
   ├─ Emit BEFORE_QUALITY_GATE hook
   ├─ Validate against gate criteria
   ├─ Attempt auto-fix if failed
   ├─ Retry up to max_attempts
   ├─ Emit AFTER_QUALITY_GATE hook
   └─ Flag limitation if still failed

4. OUTPUT FORMATTING
   ├─ Format according to output template
   ├─ Apply language translation
   ├─ Validate all sections present
   └─ Emit AFTER_SKILL_EXECUTE hook
```

### Error Handling

Errors are handled through a structured recovery system:

| Error Level | Behavior | Recovery |
|-------------|----------|----------|
| WARNING | Log and continue | Use fallback value |
| ERROR | Retry with backoff | Alternate source/method |
| CRITICAL | Flag and continue | Graceful degradation |
| FATAL | Abort execution | Emit error output |

## Quality Gates

### Universal Gates (U1-U6)

| Gate | Criteria | Auto-Fix |
|------|----------|----------|
| U1 | ≥3 sources, ≥1 academic/authoritative | Fetch from knowledge base |
| U2 | Disclosure before recommendation | Prepend disclosure |
| U3 | Evidence hierarchy per source | Annotate tiers |
| U4 | Language matches preference | Translate |
| U5 | Output template complete | Reformat |
| U6 | Claims traceable to sources | Flag or annotate |

### Domain Gates (G1-G4)

| Gate | Criteria | Auto-Fix |
|------|----------|----------|
| G1 | Fire-danger index computed | Compute index |
| G2 | IoT sensors deployed | Add deployment plan |
| G3 | Satellite monitoring | Add monitoring config |
| G4 | Alert thresholds & UAV | Add alert/UAV config |

## Lifecycle Hooks

### Hook Execution Order

Hooks are executed in priority order:

1. **CRITICAL (0)**: Security, validation, critical checks
2. **HIGH (50)**: Core functionality
3. **NORMAL (100)**: Standard hooks
4. **LOW (150)**: Optional enhancements
5. **MONITORING (200)**: Logging, metrics, analytics

### Available Hooks

See `hooks/lifecycle.py` for complete hook definitions and registration API.

## Tool Invocation

### Tool Registration

Tools are registered through the `@tool` decorator:

```python
@tool(
    name="compute_fwi",
    description="Compute Fire Weather Index",
    category=ToolCategory.ANALYSIS,
)
def compute_fwi(temperature: float, humidity: float, wind_sp

…

## 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/iot-satellite-forest-fire-early-warning-agent-skill](https://github.com/dungnotnull/iot-satellite-forest-fire-early-warning-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-iot-satellite-forest-fire-early-warning-agent-skill-iot-satellite-forest-fire-early-warning-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%.