RALSTP Consultant

Analyze problems using RALSTP (Recursive Agents and Landmarks Strategic-Tactical Planning). Based on PhD thesis by Dorian Buksz (RALSTP). Identifies agents,...

Security Scan

The skill's files and runtime instructions are coherent with its stated purpose (RALSTP analysis); it requests no credentials, has no install step, and the included script only reads user-provided PDDL files and prints heuristic analysis.

Purpose & Capability

The name/description (RALSTP analysis, conceptual + optional formal mode) matches the provided SKILL.md and the included scripts. The provided scripts implement a lightweight PDDL parser and RALSTP heuristics — which is exactly what a formal-mode helper would need. There are no unrelated dependencies, binaries, or credentials requested.

Instruction Scope

The SKILL.md stays within the declared purpose: it describes conceptual use with LLMs and an optional formal mode that requires user-provided domain/problem PDDL files. The runtime instructions do not request system-wide data or secrets. Note: the included analyze.py reads local files you pass to it and uses heuristic/regex parsing (not a full secure parser). This is an accuracy/robustness concern rather than a security incoherence — validate untrusted PDDL inputs if you care about correctness.

Install Mechanism

There is no install specification (instruction-only except for an included script). Nothing is downloaded or written by an installer. This is the lowest-risk class for installation.

Credentials

The skill declares no required environment variables, no credentials, and no config paths. The script only opens the domain/problem paths supplied by the user; that is proportional to the claimed formal-mode functionality.

Persistence & Privilege

The skill is not forced-always, is user-invocable, and does not request any persistent/system privileges or attempt to modify other skills or system configuration. Autonomous invocation is permitted by platform default but is not combined with other red flags here.

Assessment

This skill appears to do what it says: conceptual analysis via LLM and an optional formal mode that parses PDDL files with the included script. Before using: (1) Only run the analyze.py on PDDL files you trust or run it in a sandbox — it will read any local files you point it at but does not perform network access or execute code from those files. (2) Expect the script to be heuristic and approximate (regex-based parsing); results may be incorrect on complex PDDL. (3) No credentials or external endpoints are requested, so installing it does not expose secrets. If you want extra safety, inspect the script (it's short) or run it in an isolated environment.

Based on "Recursive Agents and Landmarks Strategic-Tactical Planning (RALSTP)" by Dorian Buksz, King's College London, 2024.

Core Concepts (from the thesis)

1. Agents Identification

Definition: Agents are objects with dynamic types that are active during goal state search.

How to identify:

• Dynamic type = appears as first argument of a predicate in any action's effects
• Static type = never appears in action effects
• Example: In Driverlog, truck and driver are dynamic (they're in drive action effects), but location is static

Real PDDL Example (RTAM Domain):

(:types  
   ambulance police_car tow_truck fire_brigade - vehicle
   acc_victim vehicle car - subject
   ...
)

• Agents: ambulance, police_car, tow_truck, fire_brigade (appear in action effects like at, available, busy)
• Passive: acc_victim, car (acted upon but don't act)

2. Passive Objects

Objects that are NOT agents — things being acted upon but don't act themselves.

• Packages, cargo, data, files, victims in RTAM

3. Agent Dependencies

Definition: Relationships between agents based on what preconditions they satisfy for other agents.

Types:

• Independent — agents that don't depend on each other
• Dependent — agents that need other agents' preconditions satisfied
• Conflicting — agents that interfere with each other

4. Entanglement

Definition: When agents fight for shared resources (time, space, locations, etc.)

Measurement:

• Count of shared predicates
• Conflict frequency in goal states

Real PDDL Example (RTAM - Road Traffic Accident):

(:durative-action confirm_accident
   :parameters (?V - police_car ?P - subject ?A - accident_location)
   :condition (and (at start (at ?V ?A)) (at start (at ?P ?A)) ...)
   :effect (and (at end (certified ?P)) ...)
)

(:durative-action untrap
   :parameters (?V - fire_brigade ?P - acc_victim ?A - accident_location)
   :condition (and (at start (certified ?P)) (at start (available ?V)) ...)
)

• Entanglement: police_car must certify BEFORE fire_brigade can untrap
• Resource conflict: Both need to be at same accident_location
• Availability: fire_brigade busy during untrap → others must wait

5. Landmarks

Definition: Facts that must be true in any valid plan (from goals back to initial state).

Types:

• Fact landmarks — propositions that must hold
• Action landmarks — actions that must be executed
• Relaxed landmarks — landmarks considering only positive effects (ignoring deletes)

Real PDDL Example (RTAM - sequential dependencies):

Goal: (delivered victim1) ∧ (delivered car1)

Required sequence of fact landmarks:
1. (certified victim1)     ← police must confirm
2. (untrapped victim1)     ← fire must free them
3. (aided victim1)         ← ambulance must treat
4. (loaded victim1 ambulance) ← ambulance must load
5. (at victim1 hospital)   ← deliver to hospital
6. (delivered victim1)     ← FINAL

Action landmarks:
- confirm_accident → untrap → first_aid → load_victim → unload_victim → deliver_victim

6. Strategic vs Tactical

• Strategic: Abstract planning level. Solve "what needs to happen first" ignoring details.
• Tactical: Detailed execution level. Solve "exactly how to do it".

7. Difficulty Metrics

From the thesis, difficulty increases with:

• More agents in goal state
• More entangled agents (conflicting dependencies)
• More inactive dynamic objects not in goal

Buksz Complexity Score ≈ Agent Count × Entanglement Factor

Implementation Note (Natural Language vs PDDL)

This skill operates in two modes:

1. Conceptual Mode (Default): Uses the LLM to apply RALSTP methodology to natural language problems (e.g., "Plan a marketing launch"). No PDDL files are required. The agent identifies Agents/Landmarks conceptually.
2. Formal Mode (Optional): If you provide PDDL domain/problem files, the included scripts/analyze.py can be run to mathematically extract agents and landmarks.

The instructions below apply to both modes, but "Real PDDL Examples" are provided for technical context.

Usage

For any complex problem, just describe it and I'll apply RALSTP:

RALSTP analyze: I need to migrate 1000 VMs from datacentre A to B with minimal downtime

Output Format

## RALSTP Analysis

### Agents Identified
- [list agents and their types]

### Passive Objects  
- [list objects being acted upon]

### Dependency Graph
- [which agents depend on which]

### Difficulty Assessment
- Agent Count: X
- Entanglement: Low/Medium/High
- Estimated Complexity: [score]

### Strategic Phase
- [high-level plan ignoring details]

### Tactical Phase
- [detailed execution]

### Decomposition Suggestion
- Split by: [agent type / landmark / location]
- Parallelize: [what can run concurrently]
- Risks: [potential conflicts/entanglements]

When to Use

USE for:

• Multi-step workflows with multiple actors
• Migration/tasks with dependencies
• Resource contention problems
• Complex orchestrations

SKIP for:

• Simple Q&A
• Single-task problems

Reference

PhD Thesis: "Recursive Agents and Landmarks Strategic-Tactical Planning (RALSTP)" — Dorian Buksz, King's College London, 2024.

Example: RTAM Domain (IPC-2014)

Domain: Road Traffic Accident Management

Source: https://github.com/potassco/pddl-instances/tree/master/ipc-2014/domains/road-traffic-accident-management-temporal-satisficing

Full Analysis

Agents (4):

• ambulance — transports victims to hospital
• police_car — certifies accident/victims
• tow_truck — recovers vehicles
• fire_brigade — untraps victims, extinguishes fires

Passive Objects:

• acc_victim — people needing help
• car — vehicles involved in accident
• accident_location, hospital, garage

Dependencies (Critical Path):

police_car → fire_brigade → ambulance → hospital
     ↓            ↓           ↓
  certify      untrap       deliver

Landmarks Chain (must execute in order):

1. confirm_accident (police at scene)
2. untrap (fire frees victim)
3. first_aid (ambulance treats)
4. load_victim → unload_victim → deliver_victim
5. load_car → unload_car → deliver_vehicle

Entanglement:

• Multiple vehicles must be at same location (accident scene)
• Vehicles have limited availability (busy during actions)
• Sequence constraints: can't deliver before certify

Difficulty: High — 4 agents, tight dependencies, shared locations