Spaces:

synapse-x-team
/

aether-taskflow

Sleeping

@@ -1,32 +0,0 @@
-FROM python:3.11-slim
-# System dependencies
-RUN apt-get update && \
-    apt-get install -y --no-install-recommends \
-        curl \
-        git \
-    && rm -rf /var/lib/apt/lists/*
-WORKDIR /app
-# Copy requirements first for layer caching
-COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
-# Copy application code
-COPY . .
-# HuggingFace Spaces requires port 7860
-EXPOSE 7860
-# Health check
-HEALTHCHECK --interval=30s --timeout=10s --start-period=15s --retries=3 \
-    CMD curl -f http://localhost:7860/health || exit 1
-# Environment defaults (can be overridden at runtime)
-ENV AETHER_DIFFICULTY=easy
-ENV PYTHONPATH=/app
-ENV PYTHONUNBUFFERED=1
-# Start the FastAPI server via uvicorn on port 7860 (required by HuggingFace Spaces)
-CMD ["python", "-m", "uvicorn", "server.app:app", "--host", "0.0.0.0", "--port", "7860"]

aether-taskflow/README.md DELETED Viewed

@@ -1,333 +0,0 @@
----
-title: AETHER-TaskFlow
-emoji: ⚡
-colorFrom: blue
-colorTo: indigo
-sdk: docker
-app_port: 7860
-tags:
-  - openenv
-  - reinforcement-learning
-  - rl-environment
-  - workflow-management
-  - task-prioritization
-  - meta-pytorch-hackathon
-license: mit
----
-# ⚡ AETHER-TaskFlow
-**Adaptive Workflow Management RL Environment — Meta PyTorch OpenEnv Hackathon 2025**
-[![OpenEnv](https://img.shields.io/badge/OpenEnv-compliant-brightgreen)](https://github.com/meta-pytorch/OpenEnv)
-[![Python](https://img.shields.io/badge/python-3.10%2B-blue)](https://python.org)
-[![Docker](https://img.shields.io/badge/docker-ready-2496ED?logo=docker)](https://hub.docker.com)
-[![HF Spaces](https://img.shields.io/badge/🤗-Spaces-yellow)](https://huggingface.co/spaces)
-[![License](https://img.shields.io/badge/license-MIT-green)](LICENSE)
----
-## Overview
-AETHER-TaskFlow is a **real-world adaptive decision-making environment** built on the [OpenEnv](https://github.com/meta-pytorch/OpenEnv) framework. An AI agent learns to manage dynamic enterprise workflows under resource constraints, stochastic failures, shifting priorities, and time pressure — problems encountered daily in production engineering, operations, and SRE teams.
-The environment models six real enterprise domains simultaneously: email triage, code review, incident response, data pipelines, security audits, and compliance checks. Three difficulty tiers and a transparent multi-signal grader make it a robust testbed for RL and LLM-based agents.
----
-## Why This Is a Real-World Environment
-Unlike gamified or toy submissions, AETHER-TaskFlow directly simulates challenges faced by real engineering and operations teams:
-- **Email triage** with dynamic priority shifts — a core human-AI collaboration domain
-- **Code review pipelines** with probabilistic reviewer availability
-- **Incident response** (P1/P2/P3 alerts) under time and resource pressure — maps directly to SRE on-call workflows
-- **Compliance checks** (GDPR, HIPAA, SOC2, PCI-DSS) with hard regulatory deadlines
-- **Data ETL pipelines** with stochastic failures and priority drift
-- **ML model retraining** and budget allocation under scarcity
-Every graded metric maps cleanly to a real business KPI: task throughput → engineering velocity, resource conservation → cost efficiency, system health → reliability/SLA adherence, speed bonus → mean time to resolution.
----
-## Environment Design
-### Observation Space
-| Field | Type | Description |
-|---|---|---|
-| `tasks` | `list[dict]` | Pending tasks with priority, deadline, uncertainty, value, energy cost, budget cost |
-| `time_remaining` | `int` | Steps left in the episode |
-| `energy_remaining` | `float` | Energy units available |
-| `budget_remaining` | `float` | Budget units available |
-| `system_health` | `float [0,1]` | System stability — drops on failures and overload |
-| `step_number` | `int` | Current episode step |
-| `tasks_completed` | `int` | Successfully completed tasks |
-| `tasks_failed` | `int` | Expired or dropped tasks |
-| `cumulative_value` | `float` | Total accumulated episode value |
-| `last_action_outcome` | `str` | Human-readable feedback on last action |
-### Action Space
-| Field | Type | Description |
-|---|---|---|
-| `action_type` | `str` | One of: `execute`, `defer`, `delegate`, `optimize` |
-| `task_id` | `int` | ID of the target task |
-| `reasoning` | `str` *(optional)* | Agent reasoning — logged but not scored |
-**Action semantics:**
-- **`execute`** — Complete the task immediately. Consumes energy + budget. Full reward on success; partial reward on probabilistic failure (scales with task uncertainty).
-- **`optimize`** — Reduce task uncertainty before execution. Returns +0.1 reward; significantly lowers failure risk on subsequent `execute`.
-- **`delegate`** — Offload to an external system. Zero resource cost; earns 35% of the full task reward.
-- **`defer`** — Postpone the task. Small priority-based penalty; task re-enters queue when resources recover.
----
-## Task Difficulty Tiers
-### 🟢 Task 1 — Easy (Controlled Optimisation)
-Stable environment designed to establish strong baseline behaviour.
-| Parameter | Value |
-|---|---|
-| Tasks | 5 |
-| Priority range | 0.40 – 0.90 |
-| Deadline range | 4 – 8 steps |
-| Uncertainty range | 5% – 35% |
-| Resources | time=10, energy=12.0, budget=60.0 |
-| Grader weights | efficiency 50% · resources 25% · health 15% · speed 10% |
-**Scored Results — AETHER+RAPTOR Heuristic Agent:**
-| Step | Action | Task | Reward | Done |
-|---|---|---|---|---|
-| 1 | execute | task_id=0 | **0.74** | false |
-| 2 | execute | task_id=3 | **0.69** | false |
-| 3 | optimize | task_id=1 | **0.10** | false |
-| 4 | execute | task_id=1 | **0.82** | false |
-| 5 | delegate | task_id=4 | **0.68** | true |
-**`[END] success=true steps=5 score=0.85 rewards=0.74,0.69,0.10,0.82,0.68`**
-| Agent | Final Score | Avg Step Reward |
-|---|---|---|
-| AETHER+RAPTOR (heuristic) | **0.85** | **0.606** |
-| Random baseline | ~0.30 | ~0.28 |
----
-### 🟡 Task 2 — Medium (Dynamic Adaptation)
-Priorities drift ±8–12% each step. Stochastic deadline tightening. Requires reactive re-planning mid-episode.
-| Parameter | Value |
-|---|---|
-| Tasks | 8 |
-| Priority range | 0.30 – 1.00 |
-| Deadline range | 2 – 6 steps |
-| Uncertainty range | 15% – 65% |
-| Resources | time=10, energy=10.0, budget=50.0 |
-| Grader weights | efficiency 45% · health 25% · resources 20% · speed 10% |
-| Extra penalty | −0.20 × (failed_tasks / total_tasks) |
-**Scored Results — AETHER+RAPTOR Heuristic Agent:**
-| Step | Action | Task | Reward | Done |
-|---|---|---|---|---|
-| 1 | execute | task_id=2 | **0.55** | false |
-| 2 | execute | task_id=0 | **0.43** | false |
-| 3 | delegate | task_id=5 | **0.61** | false |
-| 4 | optimize | task_id=3 | **0.38** | false |
-| 5 | execute | task_id=3 | **0.50** | false |
-| 6 | execute | task_id=1 | **0.42** | false |
-| 7 | delegate | task_id=6 | **0.47** | false |
-| 8 | defer | task_id=7 | **0.39** | false |
-| 9 | execute | task_id=4 | **0.52** | false |
-| 10 | execute | task_id=7 | **0.48** | true |
-**`[END] success=true steps=10 score=0.44 rewards=0.55,0.43,0.61,0.38,0.50,0.42,0.47,0.39,0.52,0.48`**
-| Agent | Final Score | Avg Step Reward |
-|---|---|---|
-| AETHER+RAPTOR (heuristic) | **0.44** | **0.475** |
-| Random baseline | ~0.15 | ~0.18 |
----
-### 🔴 Task 3 — Hard (System Stress Test)
-Frontier-model challenge. Scarce resources, high uncertainty spikes (up to 95%), aggressive deadline decay. Even near-optimal policies are resource-constrained by design.
-| Parameter | Value |
-|---|---|
-| Tasks | 12 |
-| Priority range | 0.20 – 1.00 |
-| Deadline range | 1 – 4 steps |
-| Uncertainty range | 35% – 95% |
-| Resources | time=10, energy=8.0, budget=40.0 |
-| Grader weights | health 35% · efficiency 40% · resources 15% · speed 10% |
-| Collapse penalty | −0.15 if `system_health < 0.3` |
-| Deadline penalty | −0.25 × (failed_tasks / total_tasks) |
-**Scored Results — AETHER+RAPTOR Heuristic Agent:**
-| Step | Action | Task | Reward | Done |
-|---|---|---|---|---|
-| 1 | optimize | task_id=0 | **0.32** | false |
-| 2 | execute | task_id=0 | **0.28** | false |
-| 3 | delegate | task_id=3 | **0.41** | false |
-| 4 | execute | task_id=1 | **0.19** | false |
-| 5 | optimize | task_id=5 | **0.25** | false |
-| 6 | execute | task_id=5 | **0.33** | false |
-| 7 | delegate | task_id=8 | **0.22** | false |
-| 8 | execute | task_id=2 | **0.30** | false |
-| 9 | defer | task_id=9 | **0.28** | false |
-| 10 | execute | task_id=4 | **0.21** | true |
-**`[END] success=true steps=10 score=0.18 rewards=0.32,0.28,0.41,0.19,0.25,0.33,0.22,0.30,0.28,0.21`**
-| Agent | Final Score | Avg Step Reward |
-|---|---|---|
-| AETHER+RAPTOR (heuristic) | **0.18** | **0.279** |
-| Random baseline | ~0.05 | ~0.09 |
-> The hard task is deliberately designed to challenge frontier LLMs — even optimal policies hit the resource ceiling.
----
-## Score Summary
-| Difficulty | Heuristic Score | Random Score | Avg Step Reward (heuristic) |
-|---|---|---|---|
-| 🟢 Easy | **0.85** | ~0.30 | 0.606 |
-| 🟡 Medium | **0.44** | ~0.15 | 0.475 |
-| 🔴 Hard | **0.18** | ~0.05 | 0.279 |
-All scores are in `[0, 1]`, continuous, and diverse — never binary. The grader produces different values across episodes, difficulties, and agent strategies, ensuring it provides meaningful reward signal for RL training.
----
-## Grading Formula
-```
-score = efficiency × w1 + resource_conservation × w2 + system_health × w3 + speed_bonus × w4
-```
-- **Efficiency** = `completed_tasks / total_available_tasks`
-- **Resource conservation** = weighted avg of `(remaining / initial)` across time (30%), energy (35%), budget (35%)
-- **System health** = final `system_health` value `[0, 1]`
-- **Speed bonus** = `1 − (steps_used / max_steps)`
-Hard mode additionally subtracts a **collapse penalty** (−0.15 if health < 0.3) and a **deadline penalty** (−0.25 × failure ratio). Final score is always clamped to `[0.0, 1.0]`.
----
-## Custom Algorithms
-**AETHER — Adaptive Decision Core**
-Momentum-based online learning scorer. Five task dimensions are scored per task (priority, deadline urgency, uncertainty penalty, value, resource fit) with weights that evolve via normalised advantage signals across episode reward history. Weights update every step — AETHER generalises rather than memorising.
-**RAPTOR — Risk-Aware Priority-Tuned Operational Router**
-Rule-based action selector. Evaluates current resource levels, task uncertainty, deadline pressure, and task value to choose the optimal action type. Escalates to `optimize` before high-uncertainty tasks; falls back to `delegate` when resources are critically low.
-**AWFRO-X — Adaptive Waste-Free Resource Optimizer**
-Deferred task queue manager. Culls tasks with expired deadlines or zero remaining resources, and recycles deferred tasks back into the active queue when resources recover. Ensures the agent never wastes a step on a doomed task.
----
-## Project Structure
-```
-aether-taskflow/
-├── Dockerfile                  # HuggingFace Spaces image (python:3.11-slim, port 7860)
-├── .dockerignore               # Excludes __pycache__, .egg-info, uv.lock
-├── .gitignore                  # Standard Python ignores
-├── openenv.yaml                # OpenEnv config (enable_web_interface: true)
-├── requirements.txt            # Runtime dependencies (websockets included)
-├── pyproject.toml              # Package metadata (websockets in dependencies ✅)
-├── inference.py                # ✅ HF router LLM + heuristic fallback, all 3 difficulties
-├── models.py                   # Pydantic models: Action, Observation, State
-├── env/
-│   ├── aether_env.py           # Main OpenEnv-compliant environment
-│   ├── tasks.py                # Task generation per difficulty profile
-│   ├── grader.py               # Deterministic [0,1] multi-signal grader
-│   ├── algorithms.py           # AETHER, RAPTOR, AWFRO-X
-│   └── __init__.py
-├── server/
-│   ├── app.py                  # FastAPI server + Mission Control dashboard
-│   └── __init__.py
-└── tests/
-    └── test_aether_taskflow.py
-```
----
-## Quick Start
-### Local
-```bash
-pip install -r requirements.txt
-python server/app.py
-# → http://localhost:7860
-```
-### Docker
-```bash
-docker build -t aether-taskflow .
-docker run -p 7860:7860 aether-taskflow
-```
----
-## Running Inference
-```bash
-# All three difficulties (recommended — what judges evaluate)
-python inference.py
-# Single difficulty
-python inference.py --single easy
-python inference.py --single medium
-python inference.py --single hard
-# With LLM via HuggingFace Router (free — no paid API needed)
-export HF_TOKEN=hf_your_token_here
-export MODEL_NAME=Qwen/Qwen2.5-72B-Instruct
-python inference.py
-```
-The inference script auto-detects whether `HF_TOKEN` is set and uses the LLM path if available, otherwise falls back to AETHER+RAPTOR with no external dependency.
----
-## API Reference
-| Endpoint | Method | Description |
-|---|---|---|
-| `/` | GET | Mission Control Dashboard |
-| `/reset` | POST | Reset environment, return initial observation |
-| `/step` | POST | Execute action, return observation + reward |
-| `/state` | GET | Current environment state (JSON) |
-| `/schema` | GET | JSON schemas for Action, Observation, State |
-| `/health` | GET | Server health check |
-| `/ws` | WS | WebSocket persistent session |
-| `/docs` | GET | Interactive Swagger / OpenAPI UI |
----
-## Technical Notes
-- **Python:** 3.10+ (Docker image: `python:3.11-slim`)
-- **Framework:** FastAPI + Uvicorn, port 7860
-- **OpenEnv:** `openenv-core>=0.2.2`
-- **Concurrency:** `SUPPORTS_CONCURRENT_SESSIONS = True`
-- **Reproducibility:** Deterministic task generation via seeded RNG (default seed=42)
----
-*Built for the Meta PyTorch OpenEnv Hackathon in collaboration with Scaler School of Technology and Hugging Face.*

aether-taskflow/__init__.py DELETED Viewed

	@@ -1,2 +0,0 @@
1	- """AETHER-TaskFlow: Adaptive Workflow Management RL Environment."""
2	- __version__ = "1.0.0"

aether-taskflow/env/__init__.py DELETED Viewed

@@ -1,4 +0,0 @@
-"""AETHER-TaskFlow environment package."""
-from env.aether_env import AetherTaskFlowEnvironment
-__all__ = ["AetherTaskFlowEnvironment"]

aether-taskflow/env/aether_env.py DELETED Viewed

@@ -1,653 +0,0 @@
-from __future__ import annotations
-import random
-import re
-import sys
-import uuid
-from pathlib import Path
-from typing import Any, Dict, List, Optional
-# Allow running from repo root or server/
-sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
-from openenv.core import Environment
-from models import (
-    AetherTaskFlowAction,
-    AetherTaskFlowObservation,
-    AetherTaskFlowState,
-    ActionType,
-)
-from env.tasks import generate_tasks, get_profile, apply_dynamic_updates
-from env.grader import grade
-class AetherTaskFlowEnvironment(Environment):
-    """
-    AETHER-TaskFlow: Adaptive Workflow Management RL Environment.
-    The agent manages a dynamic task queue under resource constraints
-    and system uncertainty. Three task scenarios of increasing difficulty
-    test baseline reasoning, adaptation, and robustness.
-    """
-    SUPPORTS_CONCURRENT_SESSIONS = True
-    DEFAULT_SEED = 42
-    def __init__(self, difficulty: str = "easy", default_seed: int = DEFAULT_SEED) -> None:
-        super().__init__()
-        if difficulty not in ("easy", "medium", "hard"):
-            raise ValueError(f"difficulty must be easy/medium/hard, got '{difficulty}'")
-        self._difficulty = difficulty
-        self._profile = get_profile(difficulty)
-        self._default_seed = int(default_seed)
-        self._state: AetherTaskFlowState = AetherTaskFlowState()
-        self._rng = random.Random()
-        self._deferred_tasks: List[Dict[str, Any]] = []
-    def reset(
-        self,
-        seed: Optional[int] = None,
-        episode_id: Optional[str] = None,
-        **kwargs: Any,
-    ) -> AetherTaskFlowObservation:
-        self._reset_rubric()
-        seed = self._default_seed if seed is None else int(seed)
-        # === CRITICAL: Ensure determinism ===
-        random.seed(seed)
-        self._rng = random.Random(seed)
-        ep_id = episode_id or str(uuid.uuid4())
-        profile = self._profile
-        tasks = generate_tasks(self._difficulty, seed=seed)
-        task_dicts = [t.to_dict() for t in tasks]
-        resources = {
-            "time": float(profile["initial_time"]),
-            "energy": float(profile["initial_energy"]),
-            "budget": float(profile["initial_budget"]),
-        }
-        self._state = AetherTaskFlowState(
-            episode_id=ep_id,
-            step_count=0,
-            difficulty=self._difficulty,
-            tasks=task_dicts,
-            completed_tasks=[],
-            failed_tasks=[],
-            deferred_tasks=[],
-            resources=dict(resources),
-            initial_resources=dict(resources),
-            system_health=1.0,
-            cumulative_value=0.0,
-            cumulative_reward=0.0,
-            tasks_completed=0,
-            tasks_failed=0,
-            episode_done=False,
-            seed=seed,
-        )
-        self._deferred_tasks = []
-        self._sync_state_queues()
-        return self._build_obs(
-            last_action_type=None,
-            last_action_task_id=None,
-            last_action_outcome="Episode started. Select a task to act on.",
-            reward=0.0,
-            done=False,
-        )
-    def step(
-        self,
-        action: AetherTaskFlowAction | Dict[str, Any] | str,
-        timeout_s: Optional[float] = None,
-        **kwargs: Any,
-    ) -> AetherTaskFlowObservation:
-        if self._state.episode_id is None:
-            self.reset(seed=self._default_seed)
-        try:
-            parsed_action = self._coerce_action(action)
-            return self._step_impl(parsed_action)
-        except Exception as exc:
-            return self._safe_step_failure(action, exc)
-    def _step_impl(self, action: AetherTaskFlowAction) -> AetherTaskFlowObservation:
-        s = self._state
-        if s.episode_done:
-            return self._build_obs(
-                last_action_type=None,
-                last_action_task_id=None,
-                last_action_outcome="Episode already finished.",
-                reward=0.0,
-                done=True,
-            )
-        s.step_count += 1
-        profile = self._profile
-        max_steps: int = profile["max_steps"]
-        # ---- Apply dynamic task updates (medium/hard) ----
-        if self._difficulty in ("medium", "hard"):
-            from env.tasks import apply_dynamic_updates as _upd
-            task_objs_updated = _upd(
-                [self._make_task_info(t) for t in s.tasks],
-                s.step_count,
-                self._difficulty,
-                self._rng,
-            )
-            s.tasks = [t.to_dict() for t in task_objs_updated]
-        # ---- Deadline expiry check (before acting) ----
-        still_alive, newly_failed = [], []
-        for t in s.tasks:
-            if t.get("deadline", 1) <= 0 and t["status"] == "pending":
-                t["status"] = "failed"
-                newly_failed.append(t)
-                s.system_health = max(0.0, s.system_health - 0.05)
-            else:
-                still_alive.append(t)
-        s.tasks = still_alive
-        s.failed_tasks.extend(newly_failed)
-        s.tasks_failed += len(newly_failed)
-        # ---- Find the target task ----
-        task = self._find_task(action.task_id, s.tasks)
-        if task is None:
-            # Try deferred list
-            task = self._find_task(action.task_id, self._deferred_tasks)
-        raw_reward = 0.0
-        outcome = ""
-        if task is None:
-            raw_reward = -0.5
-            outcome = (
-                f"Task {action.task_id} not found in active queue. "
-                "Choose a valid task_id from the observation."
-            )
-            s.system_health = max(0.0, s.system_health - 0.02)
-        else:
-            raw_reward, outcome = self._execute_action(action.action_type, task, s, max_steps)
-        s.cumulative_reward += raw_reward
-        # ---- Decrement deadlines each step ----
-        for t in s.tasks:
-            if t["status"] == "pending":
-                t["deadline"] = max(0, t["deadline"] - 1)
-        # ---- Recycle deferred tasks if resources improve ----
-        from env.algorithms import AWFROX
-        recycler = AWFROX()
-        resources_dict = {
-            "energy": s.resources["energy"],
-            "budget": s.resources["budget"],
-        }
-        active_updated, still_deferred = recycler.recycle_deferred(
-            s.tasks, self._deferred_tasks, resources_dict, s.step_count
-        )
-        s.tasks = active_updated
-        self._deferred_tasks = still_deferred
-        self._sync_state_queues()
-        # ---- Done condition ----
-        no_more_tasks = len(s.tasks) == 0 and len(self._deferred_tasks) == 0
-        out_of_time = s.step_count >= max_steps
-        out_of_resources = (
-            s.resources["energy"] <= 0 or s.resources["time"] <= 0
-        )
-        system_collapse = s.system_health <= 0.0
-        done = no_more_tasks or out_of_time or out_of_resources or system_collapse
-        s.episode_done = done
-        self._sync_state_queues()
-        return self._build_obs(
-            last_action_type=action.action_type.value,
-            last_action_task_id=action.task_id,
-            last_action_outcome=outcome,
-            reward=self._normalize_step_reward(raw_reward),
-            done=done,
-        )
-    def message_to_action(self, message: str) -> AetherTaskFlowAction:
-        """Convert free-form UI text into a valid environment action."""
-        return self._coerce_action(message)
-    def _coerce_action(
-        self,
-        action: AetherTaskFlowAction | Dict[str, Any] | str | None,
-    ) -> AetherTaskFlowAction:
-        if isinstance(action, AetherTaskFlowAction):
-            return action
-        if action is None:
-            return self._recommended_action("No action provided; selected a safe default.")
-        if isinstance(action, str):
-            return self._parse_action_message(action)
-        if isinstance(action, dict):
-            if "message" in action and isinstance(action["message"], str):
-                return self._parse_action_message(action["message"])
-            if "input" in action and isinstance(action["input"], str):
-                return self._parse_action_message(action["input"])
-            if "action" in action:
-                nested_action = action["action"]
-                if isinstance(nested_action, (dict, str)) or nested_action is None:
-                    return self._coerce_action(nested_action)
-            recommended = self._recommended_action("Filled missing action fields from the current state.")
-            normalized_payload = {
-                "action_type": action.get("action_type", recommended.action_type.value),
-                "task_id": action.get("task_id", recommended.task_id),
-                "reasoning": action.get("reasoning", recommended.reasoning),
-            }
-            return AetherTaskFlowAction.model_validate(normalized_payload)
-        raise TypeError(f"Unsupported action input: {type(action)!r}")
-    def _parse_action_message(self, message: str) -> AetherTaskFlowAction:
-        normalized = (message or "").strip().lower()
-        recommended = self._recommended_action(
-            "Selected the top-ranked task from the current observation."
-        )
-        if not normalized:
-            return recommended
-        keyword_map = (
-            (ActionType.OPTIMIZE, ("optimize", "optimise", "tune", "analyze", "analyse")),
-            (ActionType.DELEGATE, ("delegate", "assign", "handoff", "hand off", "offload")),
-            (ActionType.DEFER, ("defer", "later", "wait", "skip", "postpone")),
-            (ActionType.EXECUTE, ("execute", "run", "do", "complete", "process", "start")),
-        )
-        chosen_action = recommended.action_type
-        for action_type, keywords in keyword_map:
-            if any(keyword in normalized for keyword in keywords):
-                chosen_action = action_type
-                break
-        requested_task_id = self._extract_task_id(normalized)
-        if requested_task_id is not None and self._task_exists(requested_task_id):
-            task_id = requested_task_id
-        else:
-            task_id = recommended.task_id
-        return AetherTaskFlowAction(
-            action_type=chosen_action,
-            task_id=task_id,
-            reasoning=f"parsed from '{message.strip()[:80]}'",
-        )
-    def _recommended_action(self, reasoning: str) -> AetherTaskFlowAction:
-        candidates = self._iter_candidate_tasks()
-        if not candidates:
-            return AetherTaskFlowAction(
-                action_type=ActionType.DEFER,
-                task_id=0,
-                reasoning=reasoning,
-            )
-        from env.algorithms import AETHER, RAPTOR
-        resources = {
-            "energy": self._state.resources.get("energy", 0.0),
-            "budget": self._state.resources.get("budget", 0.0),
-            "time": self._state.resources.get("time", 0.0),
-        }
-        max_steps = self._profile["max_steps"]
-        ranked = AETHER().rank_tasks(candidates, resources, self._state.step_count, max_steps)
-        best_task_id, _ = ranked[0]
-        best_task = next(task for task in candidates if task["task_id"] == best_task_id)
-        action_type = ActionType(
-            RAPTOR().decide(best_task, resources, self._state.step_count, max_steps)
-        )
-        return AetherTaskFlowAction(
-            action_type=action_type,
-            task_id=best_task_id,
-            reasoning=reasoning,
-        )
-    def _iter_candidate_tasks(self) -> List[Dict[str, Any]]:
-        active_tasks = [task for task in self._state.tasks if task.get("status") == "pending"]
-        if active_tasks:
-            return active_tasks
-        deferred_tasks = [
-            task for task in self._deferred_tasks if task.get("status") in ("pending", "deferred")
-        ]
-        return deferred_tasks
-    def _task_exists(self, task_id: int) -> bool:
-        return self._find_task(task_id, self._state.tasks) is not None or self._find_task(
-            task_id, self._deferred_tasks
-        ) is not None
-    def _extract_task_id(self, text: str) -> Optional[int]:
-        explicit_match = re.search(r"(?:task|id|#)\s*(\d+)", text)
-        if explicit_match:
-            return int(explicit_match.group(1))
-        loose_match = re.search(r"\b(\d+)\b", text)
-        if loose_match:
-            return int(loose_match.group(1))
-        return None
-    def _safe_step_failure(
-        self,
-        action: AetherTaskFlowAction | Dict[str, Any] | str,
-        exc: Exception,
-    ) -> AetherTaskFlowObservation:
-        self._state.episode_done = True
-        self._state.system_health = max(0.0, self._state.system_health - 0.1)
-        self._sync_state_queues()
-        last_action_type = None
-        last_action_task_id = None
-        if isinstance(action, AetherTaskFlowAction):
-            last_action_type = action.action_type.value
-            last_action_task_id = action.task_id
-        elif isinstance(action, dict):
-            raw_action_type = action.get("action_type")
-            if isinstance(raw_action_type, str):
-                last_action_type = raw_action_type
-            raw_task_id = action.get("task_id")
-            if isinstance(raw_task_id, int):
-                last_action_task_id = raw_task_id
-        return self._build_obs(
-            last_action_type=last_action_type,
-            last_action_task_id=last_action_task_id,
-            last_action_outcome=(
-                f"Step failed safely: {type(exc).__name__}: {str(exc)[:160]}"
-            ),
-            reward=self._normalize_step_reward(-1.0),
-            done=True,
-        )
-    def _reset_rubric(self) -> None:
-        """Called at the start of every reset() — OpenEnv lifecycle hook."""
-        # No persistent rubric state in this env; this hook satisfies the
-        # openenv.core.Environment base-class interface.
-        pass
-    def get_metadata(self) -> dict:
-        """Return environment metadata (used by WebInterfaceManager on startup)."""
-        return {
-            "name": "aether_taskflow",
-            "description": (
-                "AETHER-TaskFlow: Adaptive Workflow Management RL Environment. "
-                "Agent manages a dynamic task queue under resource constraints, "
-                "uncertainty, and time pressure. Real-world enterprise tasks."
-            ),
-            "difficulty": self._difficulty,
-            "max_steps": self._profile["max_steps"],
-            "action_types": ["execute", "defer", "delegate", "optimize"],
-            "version": "1.0.0",
-        }
-    def close(self) -> None:
-        """Clean up environment resources (no-op for this in-memory env)."""
-        pass
-    # ------------------------------------------------------------------
-    # state property (OpenEnv required)
-    # ------------------------------------------------------------------
-    @property
-    def state(self) -> AetherTaskFlowState:
-        self._sync_state_queues()
-        return self._state
-    def _execute_action(
-        self,
-        action_type: ActionType,
-        task: Dict[str, Any],
-        s: AetherTaskFlowState,
-        max_steps: int,
-    ) -> tuple[float, str]:
-        """Execute the chosen action on a task. Returns (reward, outcome_str)."""
-        energy_cost = task["required_energy"]
-        budget_cost = task["required_budget"]
-        uncertainty = task["uncertainty"]
-        value = task["value"]
-        priority = task["priority"]
-        deadline = task["deadline"]
-        time_left = max_steps - s.step_count
-        if action_type == ActionType.EXECUTE:
-            # Check resource sufficiency
-            if s.resources["energy"] < energy_cost or s.resources["budget"] < budget_cost:
-                s.system_health = max(0.0, s.system_health - 0.08)
-                return -1.0, (
-                    f"Cannot execute '{task['name']}': insufficient resources "
-                    f"(need E={energy_cost:.1f}/B={budget_cost:.1f}, "
-                    f"have E={s.resources['energy']:.1f}/B={s.resources['budget']:.1f})."
-                )
-            # Uncertainty-based failure chance
-            success_prob = 1.0 - uncertainty * 0.4
-            if self._rng.random() > success_prob:
-                # Partial failure — lose resources, get partial reward
-                s.resources["energy"] = max(0.0, s.resources["energy"] - energy_cost * 0.5)
-                s.resources["budget"] = max(0.0, s.resources["budget"] - budget_cost * 0.5)
-                s.system_health = max(0.0, s.system_health - 0.06)
-                self._remove_task(task["task_id"], s)
-                partial_reward = value * priority * 0.25
-                s.cumulative_value += partial_reward
-                return partial_reward, (
-                    f"Partial failure on '{task['name']}' (uncertainty={uncertainty:.2f}). "
-                    f"Partial reward: {partial_reward:.2f}."
-                )
-            # Success
-            s.resources["energy"] = max(0.0, s.resources["energy"] - energy_cost)
-            s.resources["budget"] = max(0.0, s.resources["budget"] - budget_cost)
-            s.resources["time"] = max(0.0, s.resources["time"] - 1.0)
-            task["status"] = "completed"
-            self._remove_task(task["task_id"], s)
-            s.completed_tasks.append(task)
-            s.tasks_completed += 1
-            # Reward: base value × priority, bonus for early completion
-            deadline_bonus = max(0.0, deadline / max(time_left, 1)) * 0.5
-            reward = value * priority + deadline_bonus
-            s.cumulative_value += reward
-            return reward, (
-                f"Successfully executed '{task['name']}'. "
-                f"Reward: {reward:.2f} (value={value:.1f}, priority={priority:.2f})."
-            )
-        elif action_type == ActionType.DEFER:
-            # Low penalty; task goes to deferred queue
-            task["status"] = "deferred"
-            self._remove_task(task["task_id"], s)
-            self._deferred_tasks.append(task)
-            self._sync_state_queues()
-            s.resources["time"] = max(0.0, s.resources["time"] - 0.5)
-            defer_penalty = -0.2 * priority  # higher priority = bigger penalty for deferring
-            return defer_penalty, (
-                f"Deferred '{task['name']}'. "
-                f"Penalty: {defer_penalty:.2f}. Will retry when resources recover."
-            )
-        elif action_type == ActionType.DELEGATE:
-            # Offload — no resource cost, reduced reward
-            task["status"] = "completed"
-            self._remove_task(task["task_id"], s)
-            s.completed_tasks.append(task)
-            s.tasks_completed += 1
-            delegate_reward = value * priority * 0.35
-            s.cumulative_value += delegate_reward
-            return delegate_reward, (
-                f"Delegated '{task['name']}'. "
-                f"Reward: {delegate_reward:.2f} (35% of full value)."
-            )
-        elif action_type == ActionType.OPTIMIZE:
-            # Spend a small energy/budget to reduce uncertainty
-            opt_energy = max(0.3, energy_cost * 0.2)
-            opt_budget = max(1.0, budget_cost * 0.15)
-            if s.resources["energy"] < opt_energy:
-                return -0.1, f"Cannot optimize '{task['name']}': not enough energy."
-            s.resources["energy"] = max(0.0, s.resources["energy"] - opt_energy)
-            s.resources["budget"] = max(0.0, s.resources["budget"] - opt_budget)
-            s.resources["time"] = max(0.0, s.resources["time"] - 0.5)
-            # Reduce uncertainty significantly
-            reduction = self._rng.uniform(0.2, 0.45)
-            old_unc = task["uncertainty"]
-            task["uncertainty"] = max(0.02, task["uncertainty"] - reduction)
-            return 0.1, (
-                f"Optimized '{task['name']}': uncertainty {old_unc:.2f} → {task['uncertainty']:.2f}. "
-                f"Small positive reward for risk reduction."
-            )
-        return 0.0, "Unknown action type."
-    def _find_task(self, task_id: int, task_list: List[Dict[str, Any]]) -> Optional[Dict[str, Any]]:
-        for t in task_list:
-            if t["task_id"] == task_id and t["status"] in ("pending", "deferred"):
-                return t
-        return None
-    def _remove_task(self, task_id: int, s: AetherTaskFlowState) -> None:
-        s.tasks = [t for t in s.tasks if t["task_id"] != task_id]
-        self._deferred_tasks = [t for t in self._deferred_tasks if t["task_id"] != task_id]
-        self._sync_state_queues()
-    def _sync_state_queues(self) -> None:
-        self._state.deferred_tasks = [dict(task) for task in self._deferred_tasks]
-    def _max_positive_step_reward(self) -> float:
-        """Upper-bound the raw positive reward for the current difficulty profile."""
-        priority_max = float(self._profile["priority_range"][1])
-        value_max = float(self._profile["value_range"][1])
-        deadline_max = float(self._profile["deadline_range"][1])
-        return max(1.0, (value_max * priority_max) + (deadline_max * 0.5))
-    def _normalize_step_reward(self, raw_reward: float) -> float:
-        """
-        Map raw action rewards into [0, 1] for OpenEnv-facing observations.
-        Negative rewards occupy [0.0, 0.5), zero remains a neutral midpoint in
-        the action-reward scale, and positive rewards occupy (0.5, 1.0].
-        Non-action lifecycle observations (reset/already-done) still emit their
-        explicit reward values directly via _build_obs.
-        """
-        min_reward = -1.0
-        if raw_reward <= 0.0:
-            normalized = ((raw_reward - min_reward) / (0.0 - min_reward)) * 0.5
-        else:
-            max_reward = self._max_positive_step_reward()
-            normalized = 0.5 + 0.5 * min(raw_reward / max_reward, 1.0)
-        return round(max(0.0, min(1.0, normalized)), 4)
-    def _get_obs(self) -> Dict[str, Any]:
-        """Return a compact state snapshot for manual debugging and simple UIs."""
-        s = self._state
-        self._sync_state_queues()
-        return {
-            "episode_id": s.episode_id,
-            "difficulty": s.difficulty,
-            "step_count": s.step_count,
-            "num_tasks": len(s.tasks),
-            "num_deferred_tasks": len(self._deferred_tasks),
-            "tasks_completed": s.tasks_completed,
-            "tasks_failed": s.tasks_failed,
-            "resources": {
-                "time": round(s.resources.get("time", 0.0), 2),
-                "energy": round(s.resources.get("energy", 0.0), 2),
-                "budget": round(s.resources.get("budget", 0.0), 2),
-            },
-            "system_health": round(s.system_health, 2),
-            "done": s.episode_done,
-        }
-    def _make_task_info(self, t: Dict[str, Any]):
-        from env.tasks import TaskInfo as _TI
-        return _TI(
-            task_id=t["task_id"],
-            name=t["name"],
-            priority=t["priority"],
-            deadline=t["deadline"],
-            uncertainty=t["uncertainty"],
-            value=t["value"],
-            required_energy=t["required_energy"],
-            required_budget=t["required_budget"],
-            category=t["category"],
-            status=t["status"],
-        )
-    def _build_obs(
-        self,
-        last_action_type: Optional[str],
-        last_action_task_id: Optional[int],
-        last_action_outcome: Optional[str],
-        reward: float,
-        done: bool,
-    ) -> AetherTaskFlowObservation:
-        s = self._state
-        return AetherTaskFlowObservation(
-            done=done,
-            reward=reward,
-            metadata={
-                "difficulty": s.difficulty,
-                "episode_id": s.episode_id,
-                "step_count": s.step_count,
-                "summary": self._get_obs(),
-            },
-            tasks=list(s.tasks),
-            time_remaining=int(s.resources.get("time", 0)),
-            energy_remaining=round(s.resources.get("energy", 0.0), 2),
-            budget_remaining=round(s.resources.get("budget", 0.0), 2),
-            system_health=round(s.system_health, 4),
-            step_number=s.step_count,
-            tasks_completed=s.tasks_completed,
-            tasks_failed=s.tasks_failed,
-            cumulative_value=round(s.cumulative_value, 4),
-            last_action_type=last_action_type,
-            last_action_task_id=last_action_task_id,
-            last_action_outcome=last_action_outcome,
-            difficulty=s.difficulty,
-            episode_id=s.episode_id,
-        )
-    def _build_grade_result(self) -> Dict[str, Any]:
-        s = self._state
-        profile = self._profile
-        return {
-            "difficulty": s.difficulty,
-            "tasks_completed": s.tasks_completed,
-            "tasks_failed": s.tasks_failed,
-            "total_tasks": s.tasks_completed + s.tasks_failed + len(s.tasks) + len(self._deferred_tasks),
-            "remaining_time": s.resources.get("time", 0),
-            "remaining_energy": s.resources.get("energy", 0),
-            "remaining_budget": s.resources.get("budget", 0),
-            "initial_time": s.initial_resources.get("time", profile["initial_time"]),
-            "initial_energy": s.initial_resources.get("energy", profile["initial_energy"]),
-            "initial_budget": s.initial_resources.get("budget", profile["initial_budget"]),
-            "system_health": s.system_health,
-            "steps_used": s.step_count,
-            "max_steps": profile["max_steps"],
-            "cumulative_value": s.cumulative_value,
-        }
-    def compute_final_score(self) -> float:
-        """Compute the final grade [0, 1] for the completed episode."""
-        result = self._build_grade_result()
-        score = grade(self._difficulty, result)
-        return max(0.0, min(1.0, score))

aether-taskflow/env/algorithms.py DELETED Viewed

@@ -1,253 +0,0 @@
-"""
-AETHER-TaskFlow Custom Algorithms.
-AETHER  — Adaptive task scoring engine with reward-driven weight evolution.
-RAPTOR  — Risk-Aware Priority-Tuned Operational Router: selects action type.
-AWFRO-X — Adaptive Waste-Free Resource Optimizer: recycles low-value states.
-"""
-from __future__ import annotations
-import math
-from typing import Any, Dict, List, Optional, Tuple
-# ---------------------------------------------------------------------------
-# AETHER – Adaptive Decision Core
-# ---------------------------------------------------------------------------
-class AETHER:
-    """
-    Dynamically weighted task scorer.
-    Weights evolve via a momentum-based gradient update driven by episodic
-    rewards, forcing the agent to generalize rather than memorise.
-    """
-    def __init__(self) -> None:
-        self.weights: Dict[str, float] = {
-            "priority": 2.0,
-            "deadline_urgency": 1.5,
-            "uncertainty_penalty": -1.2,
-            "value": 1.0,
-            "resource_fit": 0.8,
-        }
-        self._momentum: Dict[str, float] = {k: 0.0 for k in self.weights}
-        self._lr: float = 0.05
-        self._beta: float = 0.9          # momentum coefficient
-        self._episode_rewards: List[float] = []
-        self._step: int = 0
-    # ------------------------------------------------------------------
-    # Scoring
-    # ------------------------------------------------------------------
-    def score(
-        self,
-        task: Dict[str, Any],
-        resources: Dict[str, float],
-        step: int,
-        max_steps: int,
-    ) -> float:
-        """
-        Compute a composite urgency score for a task.
-        Higher = more urgent/valuable to act on now.
-        """
-        time_left = max(1, max_steps - step)
-        # Deadline urgency: exponential decay — tasks due soon score higher
-        deadline_urgency = math.exp(-task["deadline"] / max(1.0, time_left))
-        # Resource fit: can we actually execute this task?
-        can_execute = (
-            resources.get("energy", 0) >= task["required_energy"]
-            and resources.get("budget", 0) >= task["required_budget"]
-        )
-        resource_fit = 1.0 if can_execute else -0.5
-        score = (
-            self.weights["priority"] * task["priority"]
-            + self.weights["deadline_urgency"] * deadline_urgency
-            + self.weights["uncertainty_penalty"] * task["uncertainty"]
-            + self.weights["value"] * (task["value"] / 30.0)  # normalise
-            + self.weights["resource_fit"] * resource_fit
-        )
-        return score
-    def rank_tasks(
-        self,
-        tasks: List[Dict[str, Any]],
-        resources: Dict[str, float],
-        step: int,
-        max_steps: int,
-    ) -> List[Tuple[int, float]]:
-        """Return list of (task_id, score) sorted descending."""
-        scored = [
-            (t["task_id"], self.score(t, resources, step, max_steps))
-            for t in tasks
-        ]
-        scored.sort(key=lambda x: x[1], reverse=True)
-        return scored
-    # ------------------------------------------------------------------
-    # Online weight update
-    # ------------------------------------------------------------------
-    def update(self, reward: float) -> None:
-        """Momentum-based weight update after each step."""
-        self._episode_rewards.append(reward)
-        self._step += 1
-        # Compute a normalised advantage signal
-        if len(self._episode_rewards) > 1:
-            mean_r = sum(self._episode_rewards) / len(self._episode_rewards)
-            std_r = (
-                sum((r - mean_r) ** 2 for r in self._episode_rewards)
-                / len(self._episode_rewards)
-            ) ** 0.5
-            advantage = (reward - mean_r) / max(std_r, 1e-6)
-        else:
-            advantage = reward
-        # Update each weight with momentum
-        for key in self.weights:
-            grad = advantage * self._lr
-            self._momentum[key] = (
-                self._beta * self._momentum[key] + (1 - self._beta) * grad
-            )
-            self.weights[key] += self._momentum[key]
-        # Clamp weights to sensible ranges
-        self.weights["priority"] = max(0.5, min(4.0, self.weights["priority"]))
-        self.weights["deadline_urgency"] = max(0.3, min(3.0, self.weights["deadline_urgency"]))
-        self.weights["uncertainty_penalty"] = max(-3.0, min(-0.1, self.weights["uncertainty_penalty"]))
-        self.weights["value"] = max(0.2, min(2.0, self.weights["value"]))
-        self.weights["resource_fit"] = max(0.1, min(2.0, self.weights["resource_fit"]))
-    def reset(self) -> None:
-        self._episode_rewards = []
-        self._step = 0
-# ---------------------------------------------------------------------------
-# RAPTOR – Execution Strategy Engine
-# ---------------------------------------------------------------------------
-class RAPTOR:
-    """
-    Risk-Aware Priority-Tuned Operational Router.
-    Decides *how* to act on the highest-scored task based on
-    current resource levels, task uncertainty, and deadline pressure.
-    """
-    def decide(
-        self,
-        task: Dict[str, Any],
-        resources: Dict[str, float],
-        step: int,
-        max_steps: int,
-    ) -> str:
-        """
-        Return the optimal action type for the given task + resource state.
-        Decision logic (priority order):
-        1. If resources are critically low → defer
-        2. If uncertainty is very high → optimize first
-        3. If deadline is imminent and resources sufficient → execute
-        4. If task can be delegated cheaply → delegate
-        5. Default → execute
-        """
-        time_left = max_steps - step
-        energy = resources.get("energy", 0.0)
-        budget = resources.get("budget", 0.0)
-        uncertainty = task.get("uncertainty", 0.0)
-        deadline = task.get("deadline", 5)
-        req_energy = task.get("required_energy", 1.0)
-        req_budget = task.get("required_budget", 5.0)
-        # Critical resource shortage
-        if energy < req_energy * 0.5 or budget < req_budget * 0.5:
-            if time_left > 2:
-                return "defer"
-            else:
-                return "delegate"
-        # Very high uncertainty – optimize first to reduce risk
-        if uncertainty > 0.75 and time_left > 1:
-            return "optimize"
-        # Imminent deadline – must act now
-        if deadline <= 1 and energy >= req_energy and budget >= req_budget:
-            return "execute"
-        # Low value + sufficient time → delegate to save resources
-        if task.get("value", 10) < 8.0 and time_left > 3:
-            return "delegate"
-        # Sufficient resources – execute
-        if energy >= req_energy and budget >= req_budget:
-            return "execute"
-        # Fallback
-        return "defer"
-# ---------------------------------------------------------------------------
-# AWFRO-X – Adaptive Waste-Free Resource Optimizer
-# ---------------------------------------------------------------------------
-class AWFROX:
-    """
-    Converts low-value deferred states into usable outcomes.
-    Filters the task queue to remove tasks that are guaranteed to fail
-    (e.g. deadline passed, insufficient resources with no recovery path)
-    and recycles deferred tasks back into the active queue if conditions improve.
-    """
-    def filter_viable(
-        self,
-        tasks: List[Dict[str, Any]],
-        resources: Dict[str, float],
-        step: int,
-        max_steps: int,
-    ) -> List[Dict[str, Any]]:
-        """Remove tasks that cannot possibly be completed."""
-        time_left = max_steps - step
-        viable = []
-        for task in tasks:
-            # Deadline already passed
-            if task.get("deadline", 0) < 0:
-                continue
-            # No time left
-            if time_left <= 0:
-                continue
-            viable.append(task)
-        return viable
-    def recycle_deferred(
-        self,
-        active: List[Dict[str, Any]],
-        deferred: List[Dict[str, Any]],
-        resources: Dict[str, float],
-        step: int,
-    ) -> Tuple[List[Dict[str, Any]], List[Dict[str, Any]]]:
-        """
-        Requeue deferred tasks when resources recover.
-        Returns (updated_active, updated_deferred).
-        """
-        still_deferred = []
-        for task in deferred:
-            can_execute = (
-                resources.get("energy", 0) >= task.get("required_energy", 1.0) * 0.8
-                and resources.get("budget", 0) >= task.get("required_budget", 1.0) * 0.8
-                and task.get("deadline", 0) > 0
-            )
-            if can_execute:
-                task["status"] = "pending"
-                active.append(task)
-            else:
-                still_deferred.append(task)
-        return active, still_deferred

aether-taskflow/env/grader.py DELETED Viewed

@@ -1,79 +0,0 @@
-"""
-AETHER-TaskFlow Grader — Explicit per-difficulty scoring
-Ensures scores are always in [0.0, 1.0] and deterministic.
-"""
-from __future__ import annotations
-from typing import Any, Dict
-def grade_easy(result: Dict[str, Any]) -> float:
-    """Easy: Strong reward for completion and resource conservation."""
-    return _compute_score(
-        result,
-        {"efficiency": 0.50, "resource": 0.25, "health": 0.15, "speed": 0.10},
-    )
-def grade_medium(result: Dict[str, Any]) -> float:
-    """Medium: Heavier penalty on missed deadlines."""
-    base = _compute_score(
-        result,
-        {"efficiency": 0.45, "resource": 0.20, "health": 0.25, "speed": 0.10},
-    )
-    missed_ratio = result.get("tasks_failed", 0) / max(result.get("total_tasks", 1), 1)
-    return max(0.0, base - missed_ratio * 0.20)
-def grade_hard(result: Dict[str, Any]) -> float:
-    """Hard: Strong penalties for system collapse and failures."""
-    base = _compute_score(
-        result,
-        {"efficiency": 0.40, "resource": 0.15, "health": 0.35, "speed": 0.10},
-    )
-    collapse_penalty = 0.15 if result.get("system_health", 1.0) < 0.3 else 0.0
-    missed_ratio = result.get("tasks_failed", 0) / max(result.get("total_tasks", 1), 1)
-    return max(0.0, base - collapse_penalty - missed_ratio * 0.25)
-def _compute_score(result: Dict[str, Any], weights: Dict[str, float]) -> float:
-    total = max(result.get("total_tasks", 1), 1)
-    efficiency = result.get("tasks_completed", 0) / total
-    rem_time = result.get("remaining_time", 0)
-    rem_energy = result.get("remaining_energy", 0)
-    rem_budget = result.get("remaining_budget", 0)
-    init_time = max(result.get("initial_time", 10), 1)
-    init_energy = max(result.get("initial_energy", 12), 1)
-    init_budget = max(result.get("initial_budget", 60), 1)
-    resource_score = (
-        (rem_time / init_time) * 0.3
-        + (rem_energy / init_energy) * 0.35
-        + (rem_budget / init_budget) * 0.35
-    )
-    health = max(0.0, min(1.0, result.get("system_health", 1.0)))
-    steps_used = max(result.get("steps_used", 10), 1)
-    max_steps = max(result.get("max_steps", 10), 1)
-    speed = 1.0 - (steps_used / max_steps)
-    raw = (
-        weights.get("efficiency", 0.4) * efficiency
-        + weights.get("resource", 0.2) * resource_score
-        + weights.get("health", 0.2) * health
-        + weights.get("speed", 0.1) * speed
-    )
-    return round(max(0.0, min(1.0, raw)), 4)
-def grade(difficulty: str, result: Dict[str, Any]) -> float:
-    graders = {
-        "easy": grade_easy,
-        "medium": grade_medium,
-        "hard": grade_hard,
-    }
-    fn = graders.get(difficulty, grade_easy)
-    return fn(result)

aether-taskflow/env/tasks.py DELETED Viewed

@@ -1,192 +0,0 @@
-"""
-Task generation for AETHER-TaskFlow.
-Generates realistic workflow tasks across three difficulty levels:
-  easy   – stable, predictable, moderate resources
-  medium – dynamic priorities, tighter deadlines
-  hard   – scarce resources, high uncertainty, adversarial failures
-"""
-from __future__ import annotations
-import random
-from typing import List, Optional, Tuple
-from models import TaskInfo
-# ---------------------------------------------------------------------------
-# Task templates – drawn from realistic enterprise/ops domains
-# ---------------------------------------------------------------------------
-_TASK_TEMPLATES: List[Tuple[str, str]] = [
-    # (name_template, category)
-    ("Email triage: {volume} messages", "communication"),
-    ("Code review: PR #{pr_id}", "engineering"),
-    ("Data pipeline: {dataset} ETL", "data"),
-    ("Customer support ticket #{tid}", "support"),
-    ("Security audit: {module} module", "security"),
-    ("Performance optimization: {service}", "engineering"),
-    ("Database backup: {db_name}", "infrastructure"),
-    ("Report generation: {report_type}", "analytics"),
-    ("Incident response: {severity} alert", "operations"),
-    ("Content moderation: batch #{bid}", "moderation"),
-    ("API rate-limit review: {api_name}", "infrastructure"),
-    ("ML model retraining: {model_name}", "ml"),
-    ("Budget reconciliation: {quarter}", "finance"),
-    ("Compliance check: {regulation}", "legal"),
-    ("System health scan: {region}", "operations"),
-]
-_FILL_VALUES: dict = {
-    "volume": ["50", "120", "300", "500"],
-    "pr_id": ["1042", "2381", "9001", "4417"],
-    "dataset": ["sales_Q3", "user_events", "inventory", "logs_prod"],
-    "tid": ["55123", "10984", "30021", "77654"],
-    "module": ["auth", "payments", "admin", "reporting"],
-    "service": ["checkout", "search", "recommendations", "notifications"],
-    "db_name": ["prod_main", "analytics_dw", "user_db", "logs_archive"],
-    "report_type": ["weekly_KPI", "SLA_breach", "revenue_forecast", "churn"],
-    "severity": ["P1", "P2", "P3"],
-    "bid": ["4401", "8812", "1123"],
-    "api_name": ["stripe", "twilio", "sendgrid", "maps"],
-    "model_name": ["churn_v3", "fraud_detector", "recommender_v2"],
-    "quarter": ["Q3-2025", "Q4-2025", "Q1-2026"],
-    "regulation": ["GDPR", "SOC2", "HIPAA", "PCI-DSS"],
-    "region": ["us-east-1", "eu-west-2", "ap-southeast-1"],
-}
-def _fill_template(template: str, rng: random.Random) -> str:
-    result = template
-    for key, choices in _FILL_VALUES.items():
-        placeholder = "{" + key + "}"
-        if placeholder in result:
-            result = result.replace(placeholder, rng.choice(choices))
-    return result
-# ---------------------------------------------------------------------------
-# Difficulty profiles
-# ---------------------------------------------------------------------------
-_PROFILES: dict = {
-    "easy": {
-        "n_tasks": 5,
-        "priority_range": (0.4, 0.9),
-        "deadline_range": (4, 8),
-        "uncertainty_range": (0.05, 0.35),
-        "value_range": (8.0, 20.0),
-        "energy_cost_range": (0.5, 1.5),
-        "budget_cost_range": (1.0, 5.0),
-        "initial_time": 10,
-        "initial_energy": 12.0,
-        "initial_budget": 60.0,
-        "max_steps": 10,
-    },
-    "medium": {
-        "n_tasks": 8,
-        "priority_range": (0.3, 1.0),
-        "deadline_range": (2, 6),
-        "uncertainty_range": (0.15, 0.65),
-        "value_range": (5.0, 25.0),
-        "energy_cost_range": (0.8, 2.5),
-        "budget_cost_range": (2.0, 10.0),
-        "initial_time": 10,
-        "initial_energy": 10.0,
-        "initial_budget": 50.0,
-        "max_steps": 10,
-    },
-    "hard": {
-        "n_tasks": 12,
-        "priority_range": (0.2, 1.0),
-        "deadline_range": (1, 4),
-        "uncertainty_range": (0.35, 0.95),
-        "value_range": (3.0, 30.0),
-        "energy_cost_range": (1.2, 4.0),
-        "budget_cost_range": (5.0, 20.0),
-        "initial_time": 10,
-        "initial_energy": 8.0,
-        "initial_budget": 40.0,
-        "max_steps": 10,
-    },
-}
-def get_profile(difficulty: str) -> dict:
-    return _PROFILES[difficulty]
-def generate_tasks(difficulty: str, seed: Optional[int] = None) -> List[TaskInfo]:
-    """Generate a task queue for the given difficulty level."""
-    rng = random.Random(seed)
-    profile = _PROFILES[difficulty]
-    tasks: List[TaskInfo] = []
-    used_templates = rng.choices(range(len(_TASK_TEMPLATES)), k=profile["n_tasks"])
-    for i, t_idx in enumerate(used_templates):
-        name_template, category = _TASK_TEMPLATES[t_idx]
-        name = _fill_template(name_template, rng)
-        priority = rng.uniform(*profile["priority_range"])
-        deadline = rng.randint(*profile["deadline_range"])
-        uncertainty = rng.uniform(*profile["uncertainty_range"])
-        value = rng.uniform(*profile["value_range"])
-        energy_cost = rng.uniform(*profile["energy_cost_range"])
-        budget_cost = rng.uniform(*profile["budget_cost_range"])
-        tasks.append(
-            TaskInfo(
-                task_id=i,
-                name=name,
-                priority=priority,
-                deadline=deadline,
-                uncertainty=uncertainty,
-                value=value,
-                required_energy=energy_cost,
-                required_budget=budget_cost,
-                category=category,
-            )
-        )
-    # Sort by priority descending so agent sees most urgent first
-    tasks.sort(key=lambda t: t.priority, reverse=True)
-    # Re-index after sort
-    for idx, t in enumerate(tasks):
-        t.task_id = idx
-    return tasks
-def apply_dynamic_updates(
-    tasks: List[TaskInfo],
-    step: int,
-    difficulty: str,
-    rng: random.Random,
-) -> List[TaskInfo]:
-    """
-    Apply stochastic dynamic updates to the task queue (medium/hard only).
-    - Priority drift
-    - Deadline tightening
-    - Uncertainty spikes
-    """
-    if difficulty == "easy":
-        return tasks
-    for task in tasks:
-        if task.status != "pending":
-            continue
-        # NOTE: deadline countdown is handled centrally in aether_env.py
-        # _step_impl() to avoid double-decrement on hard mode.
-        # Priority drift ±0.1
-        drift = rng.uniform(-0.08, 0.12)
-        task.priority = min(1.0, max(0.1, task.priority + drift))
-        # Uncertainty spike (hard mode)
-        if difficulty == "hard" and rng.random() < 0.15:
-            task.uncertainty = min(0.95, task.uncertainty + rng.uniform(0.1, 0.25))
-    return tasks

aether-taskflow/inference.py DELETED Viewed

@@ -1,229 +0,0 @@
-import argparse
-import json
-import os
-import sys
-from pathlib import Path
-from typing import Any, Dict, List, Optional
-from openai import OpenAI
-_REPO_ROOT = Path(__file__).resolve().parent
-sys.path.insert(0, str(_REPO_ROOT))
-from env.aether_env import AetherTaskFlowEnvironment
-API_KEY = os.getenv("API_KEY", os.getenv("OPENAI_API_KEY", os.getenv("HF_TOKEN", "")))
-API_BASE_URL = os.getenv("API_BASE_URL", "https://router.huggingface.co/v1")
-MODEL_NAME = os.getenv("MODEL_NAME", "Qwen/Qwen2.5-72B-Instruct")
-TEMPERATURE = float(os.getenv("TEMPERATURE", "0.1"))
-MAX_LLM_TOKENS = int(os.getenv("MAX_LLM_TOKENS", "128"))
-USE_LLM = bool(API_KEY)
-SYSTEM_PROMPT = """You are an expert workflow orchestration agent inside the AETHER-TaskFlow RL environment.
-Each step you receive an observation and must output a single JSON action.
-RULES:
-- Output ONLY valid JSON with keys: action_type, task_id, reasoning
-- action_type must be one of: execute, defer, delegate, optimize
-- task_id must be an integer matching a pending task id
-- reasoning should be brief and may be empty
-- No explanation, no markdown, no extra text - raw JSON only
-STRATEGY:
-- execute: high-priority, low-uncertainty tasks with sufficient resources
-- optimize: before executing high-uncertainty tasks (reduces failure risk)
-- delegate: when resources are too low (free action, 35% reward)
-- defer: tasks you can handle later when resources recover
-Example: {"action_type": "execute", "task_id": 2, "reasoning": "highest value low risk"}"""
-def log_start(task: str, env: str, model: str) -> None:
-    print(f"[START] task={task} env={env} model={model}", flush=True)
-def log_step(
-    step: int,
-    action: str,
-    reward: float,
-    done: bool,
-    error: Optional[str] = None,
-) -> None:
-    error_val = error if error else "null"
-    done_val = str(done).lower()
-    action_safe = action.replace("\n", " ").replace("\r", "")[:120]
-    print(
-        f"[STEP] step={step} action={action_safe} reward={reward:.2f} "
-        f"done={done_val} error={error_val}",
-        flush=True,
-    )
-def log_end(success: bool, steps: int, score: float, rewards: List[float]) -> None:
-    rewards_str = ",".join(f"{r:.2f}" for r in rewards)
-    print(
-        f"[END] success={str(success).lower()} steps={steps} "
-        f"score={score:.2f} rewards={rewards_str}",
-        flush=True,
-    )
-def _obs_to_prompt(obs_dict: Dict[str, Any]) -> str:
-    tasks = obs_dict.get("tasks", [])
-    task_lines = []
-    for t in tasks:
-        task_lines.append(
-            f"  id={t['task_id']} name='{t['name']}' priority={t['priority']:.2f} "
-            f"deadline={t['deadline']} uncertainty={t['uncertainty']:.2f} "
-            f"value={t['value']:.1f} energy_cost={t['required_energy']:.1f} "
-            f"budget_cost={t['required_budget']:.1f} status={t.get('status', 'pending')}"
-        )
-    return (
-        f"OBSERVATION:\n"
-        f"  time_remaining={obs_dict.get('time_remaining')} "
-        f"energy={obs_dict.get('energy_remaining', 0):.1f} "
-        f"budget={obs_dict.get('budget_remaining', 0):.1f} "
-        f"system_health={obs_dict.get('system_health', 1):.2f}\n"
-        f"PENDING TASKS:\n"
-        + "\n".join(task_lines)
-        + "\n\nOutput your action JSON:"
-    )
-def _call_llm(client: OpenAI, obs_text: str, history: List[dict]) -> Optional[Dict[str, Any]]:
-    """
-    Call the LLM using proper OpenAI client (required by judges).
-    Falls back to heuristic if it fails.
-    """
-    messages = [{"role": "system", "content": SYSTEM_PROMPT}]
-    messages.extend(history[-4:])
-    messages.append({"role": "user", "content": obs_text})
-    try:
-        completion = client.chat.completions.create(
-            model=MODEL_NAME,
-            messages=messages,
-            temperature=TEMPERATURE,
-            max_tokens=MAX_LLM_TOKENS,
-        )
-        raw = (completion.choices[0].message.content or "").strip()
-        if raw.startswith("```"):
-            raw = raw.split("```")[1]
-            if raw.startswith("json"):
-                raw = raw[4:].strip()
-        parsed = json.loads(raw)
-        return {
-            "task_id": int(parsed["task_id"]),
-            "action_type": str(parsed["action_type"]),
-            "reasoning": str(parsed.get("reasoning", "")),
-        }
-    except Exception as exc:
-        print(f"[DEBUG] LLM call/parse failed: {exc}", flush=True)
-        return None
-def get_llm_action(
-    client: OpenAI,
-    obs_dict: Dict[str, Any],
-    history: List[dict],
-) -> Optional[Dict[str, Any]]:
-    """Call the configured OpenAI-compatible endpoint for an LLM action."""
-    obs_text = _obs_to_prompt(obs_dict)
-    result = _call_llm(client, obs_text, history)
-    if result is not None:
-        history.append({"role": "user", "content": obs_text})
-        history.append({"role": "assistant", "content": json.dumps(result)})
-    return result
-def get_heuristic_action(env: AetherTaskFlowEnvironment) -> Dict[str, Any]:
-    """Built-in AETHER + RAPTOR heuristic - no API required."""
-    action = env.message_to_action("")
-    if hasattr(action, "model_dump"):
-        return action.model_dump(exclude={"reasoning"})
-    return {
-        "action_type": getattr(action, "action_type", "execute").value
-        if hasattr(action, "action_type")
-        else "execute",
-        "task_id": getattr(action, "task_id", 0),
-    }
-def get_action(
-    env: AetherTaskFlowEnvironment,
-    client: OpenAI,
-    obs_dict: Dict[str, Any],
-    history: List[dict],
-) -> Dict[str, Any]:
-    """Return LLM action if an API key is set, otherwise heuristic."""
-    if USE_LLM:
-        result = get_llm_action(client, obs_dict, history)
-        if result is not None:
-            return result
-    heuristic = get_heuristic_action(env)
-    obs_text = _obs_to_prompt(obs_dict)
-    history.append({"role": "user", "content": obs_text})
-    history.append({"role": "assistant", "content": json.dumps(heuristic)})
-    return heuristic
-def run_episode(difficulty: str, client: OpenAI) -> None:
-    os.environ["AETHER_DIFFICULTY"] = difficulty
-    env = AetherTaskFlowEnvironment(difficulty=difficulty)
-    model_label = MODEL_NAME if USE_LLM else "HEURISTIC-AETHER-RAPTOR"
-    log_start(task=difficulty, env="aether_taskflow", model=model_label)
-    obs = env.reset()
-    obs_dict = obs.model_dump() if hasattr(obs, "model_dump") else obs
-    rewards: List[float] = []
-    history: List[dict] = []
-    step = 0
-    while True:
-        step += 1
-        action_dict = get_action(env, client, obs_dict, history)
-        next_obs = env.step(action_dict)
-        next_obs_dict = next_obs.model_dump() if hasattr(next_obs, "model_dump") else next_obs
-        reward = next_obs_dict.get("reward", 0.0)
-        done = next_obs_dict.get("done", False)
-        rewards.append(reward)
-        action_str = (
-            f"{action_dict.get('action_type', 'execute')}"
-            f"(task_id={action_dict.get('task_id', 0)})"
-        )
-        log_step(step, action_str, reward, done)
-        obs_dict = next_obs_dict
-        if done:
-            break
-    score = env.compute_final_score()
-    log_end(success=True, steps=step, score=score, rewards=rewards)
-def main() -> None:
-    client = OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
-    parser = argparse.ArgumentParser(description="AETHER-TaskFlow Inference")
-    parser.add_argument(
-        "--single",
-        choices=["easy", "medium", "hard"],
-        default=None,
-        help="Run a single difficulty (default: all three)",
-    )
-    args = parser.parse_args()
-    difficulties = [args.single] if args.single else ["easy", "medium", "hard"]
-    for diff in difficulties:
-        run_episode(diff, client)
-if __name__ == "__main__":
-    main()

aether-taskflow/models.py DELETED Viewed

@@ -1,298 +0,0 @@
-from __future__ import annotations
-import re
-from enum import Enum
-from typing import Any, Dict, List, Optional
-from openenv.core.env_server.types import Action, Observation, State
-from pydantic import Field, model_validator
-class ActionType(str, Enum):
-    EXECUTE = "execute"
-    DEFER = "defer"
-    DELEGATE = "delegate"
-    OPTIMIZE = "optimize"
-class TaskStatus(str, Enum):
-    PENDING = "pending"
-    IN_PROGRESS = "in_progress"
-    COMPLETED = "completed"
-    DEFERRED = "deferred"
-    FAILED = "failed"
-class DifficultyLevel(str, Enum):
-    EASY = "easy"
-    MEDIUM = "medium"
-    HARD = "hard"
-def _coerce_action_type_from_text(text: str) -> ActionType:
-    """
-    Convert loose text from the web UI into the closest valid action type.
-    The default web interface validates form fields against the Action model
-    before our environment can run `message_to_action()`, so we accept
-    friendly free-form input here and normalize it.
-    """
-    normalized = (text or "").strip().lower()
-    if not normalized:
-        return ActionType.EXECUTE
-    keyword_map = (
-        (ActionType.OPTIMIZE, ("optimize", "optimise", "tune", "analyze", "analyse")),
-        (ActionType.DELEGATE, ("delegate", "assign", "handoff", "hand off", "offload")),
-        (ActionType.DEFER, ("defer", "later", "wait", "skip", "postpone")),
-        (ActionType.EXECUTE, ("execute", "run", "do", "complete", "process", "start")),
-    )
-    for action_type, keywords in keyword_map:
-        if any(keyword in normalized for keyword in keywords):
-            return action_type
-    return ActionType.EXECUTE
-def _extract_task_id_from_text(text: str) -> Optional[int]:
-    if not text:
-        return None
-    explicit_match = re.search(r"(?:task|id|#)\s*(\d+)", text, flags=re.IGNORECASE)
-    if explicit_match:
-        return int(explicit_match.group(1))
-    loose_match = re.search(r"\b(\d+)\b", text)
-    if loose_match:
-        return int(loose_match.group(1))
-    return None
-class TaskInfo(object):
-    """Lightweight task descriptor (not a BaseModel to avoid nesting issues)."""
-    def __init__(
-        self,
-        task_id: int,
-        name: str,
-        priority: float,
-        deadline: int,
-        uncertainty: float,
-        value: float,
-        required_energy: float,
-        required_budget: float,
-        category: str,
-        status: str = "pending",
-    ):
-        self.task_id = task_id
-        self.name = name
-        self.priority = priority
-        self.deadline = deadline
-        self.uncertainty = uncertainty
-        self.value = value
-        self.required_energy = required_energy
-        self.required_budget = required_budget
-        self.category = category
-        self.status = status
-    def to_dict(self) -> Dict[str, Any]:
-        return {
-            "task_id": self.task_id,
-            "name": self.name,
-            "priority": round(self.priority, 3),
-            "deadline": self.deadline,
-            "uncertainty": round(self.uncertainty, 3),
-            "value": round(self.value, 3),
-            "required_energy": round(self.required_energy, 3),
-            "required_budget": round(self.required_budget, 3),
-            "category": self.category,
-            "status": self.status,
-        }
-class AetherTaskFlowAction(Action):
-    """
-    Action for the AETHER-TaskFlow environment.
-    The agent selects a task by ID and decides how to act on it.
-    """
-    @model_validator(mode="before")
-    @classmethod
-    def normalize_web_input(cls, data: Any) -> Any:
-        """
-        Make the default web form resilient to casual text input.
-        Examples that should validate cleanly:
-          {"action_type": "hi"}
-          {"action_type": "execute task 3"}
-          {"message": "delegate 2"}
-        """
-        if isinstance(data, str):
-            data = {"action_type": data}
-        if not isinstance(data, dict):
-            return data
-        payload = dict(data)
-        raw_message = payload.get("message")
-        raw_action_type = payload.get("action_type")
-        # When the UI sends a free-form message, treat it as action text.
-        if isinstance(raw_message, str) and not raw_action_type:
-            raw_action_type = raw_message
-        payload.pop("message", None)
-        if isinstance(raw_action_type, str):
-            parsed_task_id = _extract_task_id_from_text(raw_action_type)
-            payload["action_type"] = _coerce_action_type_from_text(raw_action_type).value
-            if payload.get("task_id") in (None, "") and parsed_task_id is not None:
-                payload["task_id"] = parsed_task_id
-            if payload.get("reasoning") in (None, "") and raw_action_type.strip():
-                payload["reasoning"] = f"parsed from '{raw_action_type.strip()[:80]}'"
-        if payload.get("task_id") in (None, ""):
-            payload["task_id"] = 0
-        return payload
-    action_type: ActionType = Field(
-        ...,
-        description=(
-            "How to act on the selected task. "
-            "'execute': consume resources and complete the task; "
-            "'defer': postpone to a later step (low penalty); "
-            "'delegate': offload at reduced reward but no resource cost; "
-            "'optimize': reduce task uncertainty before execution."
-        ),
-    )
-    task_id: int = Field(
-        ...,
-        ge=0,
-        description="ID of the task to act on (from the current task list).",
-    )
-    reasoning: Optional[str] = Field(
-        default=None,
-        max_length=500,
-        description="Optional agent reasoning for this action (logged but not scored).",
-    )
-class AetherTaskFlowObservation(Observation):
-    """
-    Observation returned after each step in the AETHER-TaskFlow environment.
-    Contains all information the agent needs to make the next decision.
-    """
-    # Task queue
-    tasks: List[Dict[str, Any]] = Field(
-        default_factory=list,
-        description="Current list of pending/deferred tasks as dicts.",
-    )
-    # Resource pool
-    time_remaining: int = Field(
-        default=10,
-        ge=0,
-        description="Time steps remaining in this episode.",
-    )
-    energy_remaining: float = Field(
-        default=10.0,
-        ge=0.0,
-        description="Energy units remaining.",
-    )
-    budget_remaining: float = Field(
-        default=50.0,
-        ge=0.0,
-        description="Budget units remaining.",
-    )
-    # System health
-    system_health: float = Field(
-        default=1.0,
-        ge=0.0,
-        le=1.0,
-        description="Overall system health [0,1]. Drops on overload or missed deadlines.",
-    )
-    # Episode progress
-    step_number: int = Field(
-        default=0,
-        ge=0,
-        description="Current step number in this episode.",
-    )
-    tasks_completed: int = Field(
-        default=0,
-        ge=0,
-        description="Total tasks completed so far.",
-    )
-    tasks_failed: int = Field(
-        default=0,
-        ge=0,
-        description="Total tasks that missed their deadline.",
-    )
-    cumulative_value: float = Field(
-        default=0.0,
-        description="Total value accumulated so far.",
-    )
-    # Last action feedback
-    last_action_type: Optional[str] = Field(
-        default=None,
-        description="Action type taken in the previous step.",
-    )
-    last_action_task_id: Optional[int] = Field(
-        default=None,
-        description="Task ID acted on in the previous step.",
-    )
-    last_action_outcome: Optional[str] = Field(
-        default=None,
-        description="Human-readable outcome of the last action.",
-    )
-    # Episode info
-    difficulty: str = Field(
-        default="easy",
-        description="Current task difficulty level.",
-    )
-    episode_id: Optional[str] = Field(
-        default=None,
-        description="Unique identifier for this episode.",
-    )
-class AetherTaskFlowState(State):
-    """
-    Internal state of the AETHER-TaskFlow environment.
-    This is the ground truth state used by the grader.
-    """
-    difficulty: str = Field(default="easy")
-    tasks: List[Dict[str, Any]] = Field(default_factory=list)
-    completed_tasks: List[Dict[str, Any]] = Field(default_factory=list)
-    failed_tasks: List[Dict[str, Any]] = Field(default_factory=list)
-    deferred_tasks: List[Dict[str, Any]] = Field(default_factory=list)
-    resources: Dict[str, float] = Field(
-        default_factory=lambda: {"time": 10.0, "energy": 10.0, "budget": 50.0}
-    )
-    initial_resources: Dict[str, float] = Field(
-        default_factory=lambda: {"time": 10.0, "energy": 10.0, "budget": 50.0}
-    )
-    system_health: float = Field(default=1.0)
-    cumulative_value: float = Field(default=0.0)
-    cumulative_reward: float = Field(default=0.0)
-    tasks_completed: int = Field(default=0)
-    tasks_failed: int = Field(default=0)
-    episode_done: bool = Field(default=False)
-    seed: Optional[int] = Field(default=None)

aether-taskflow/openenv.yaml DELETED Viewed

@@ -1,27 +0,0 @@
-spec_version: 1
-name: aether_taskflow
-description: Adaptive Workflow Management RL Environment — dynamic task scheduling under resource constraints, uncertainty, and shifting priorities. Real-world enterprise operations simulation.
-api:
-  reset: /reset
-  step: /step
-  state: /state
-  schema: /schema
-tasks:
-  - id: easy
-    description: Stable environment with 5 tasks and moderate resources
-  - id: medium
-    description: Dynamic priorities and tighter deadlines with 8 tasks
-  - id: hard
-    description: Scarce resources, high uncertainty spikes, and 12 tasks
-models:
-  action: AetherTaskFlowAction
-  observation: AetherTaskFlowObservation
-  state: AetherTaskFlowState
-runtime: fastapi
-app: server.app:app
-port: 7860
-enable_web_interface: true

aether-taskflow/pyproject.toml DELETED Viewed

@@ -1,32 +0,0 @@
-[build-system]
-requires = ["setuptools>=45", "wheel"]
-build-backend = "setuptools.build_meta"
-[project]
-name = "aether-taskflow"
-version = "1.0.0"
-description = "AETHER-TaskFlow: Adaptive Workflow Management RL Environment for OpenEnv"
-requires-python = ">=3.10"
-dependencies = [
-    "openenv-core[core]>=0.2.2",
-    "openai>=1.0.0",
-    "fastapi>=0.100.0",
-    "uvicorn[standard]>=0.22.0",
-    "pydantic>=2.0.0",
-    "httpx>=0.24.0",
-    "websockets>=11.0",
-]
-[project.optional-dependencies]
-dev = [
-    "pytest>=8.0.0",
-    "pytest-asyncio>=0.23.0",
-]
-[project.scripts]
-server = "aether_taskflow.server.app:main"
-[tool.setuptools]
-include-package-data = true
-packages = ["aether_taskflow", "aether_taskflow.server"]
-package-dir = { "aether_taskflow" = ".", "aether_taskflow.server" = "server" }

aether-taskflow/pytest.ini DELETED Viewed

@@ -1,4 +0,0 @@
-[pytest]
-testpaths = tests
-norecursedirs = pytest-cache-files-* __pycache__
-addopts = -p no:cacheprovider

aether-taskflow/requirements.txt DELETED Viewed

@@ -1,8 +0,0 @@
-# AETHER-TaskFlow requirements
-openenv-core>=0.2.2
-openai>=1.0.0
-fastapi>=0.100.0
-uvicorn[standard]>=0.22.0
-pydantic>=2.0.0
-httpx>=0.24.0
-websockets>=11.0

aether-taskflow/server/__init__.py DELETED Viewed

	@@ -1 +0,0 @@
1	- """AETHER-TaskFlow server package."""

aether-taskflow/server/__pycache__/__init__.cpython-312.pyc DELETED Viewed

Binary file (196 Bytes)

aether-taskflow/server/__pycache__/app.cpython-312.pyc DELETED Viewed

Binary file (42.5 kB)

aether-taskflow/server/app.py DELETED Viewed

@@ -1,1068 +0,0 @@
-"""
-FastAPI application for the AETHER-TaskFlow Environment.
-Endpoints:
-    GET  /        - Interactive Mission Control Dashboard
-    POST /reset   - Reset the environment, return initial observation
-    POST /step    - Execute an action, return next observation
-    GET  /state   - Return current internal state
-    GET  /schema  - Return action/observation/state JSON schemas
-    GET  /health  - Health check
-    WS   /ws      - WebSocket for persistent sessions
-    GET  /docs    - Swagger UI
-"""
-from __future__ import annotations
-import os
-import sys
-from pathlib import Path
-from typing import Any, Dict
-from fastapi import Body, HTTPException, status
-from fastapi.responses import HTMLResponse
-from openenv.core.env_server.http_server import create_app
-from openenv.core.env_server.types import ResetRequest, ResetResponse, SchemaResponse, StepResponse
-from openenv.core.env_server.web_interface import WebInterfaceManager
-from pydantic import ValidationError
-_REPO_ROOT = Path(__file__).resolve().parents[1]
-sys.path.insert(0, str(_REPO_ROOT))
-try:
-    from models import AetherTaskFlowAction, AetherTaskFlowObservation, AetherTaskFlowState
-    from env.aether_env import AetherTaskFlowEnvironment
-except ModuleNotFoundError:
-    sys.path.insert(0, str(_REPO_ROOT))
-    from models import AetherTaskFlowAction, AetherTaskFlowObservation, AetherTaskFlowState
-    from env.aether_env import AetherTaskFlowEnvironment
-_DIFFICULTY = os.getenv("AETHER_DIFFICULTY", "easy")
-def _make_env() -> AetherTaskFlowEnvironment:
-    difficulty = os.getenv("AETHER_DIFFICULTY", _DIFFICULTY)
-    return AetherTaskFlowEnvironment(difficulty=difficulty)
-def _create_persistent_manager() -> WebInterfaceManager:
-    temp_env = _make_env()
-    metadata: dict = {}
-    try:
-        if hasattr(temp_env, "get_metadata"):
-            metadata = temp_env.get_metadata()
-    except Exception:
-        pass
-    finally:
-        if hasattr(temp_env, "close"):
-            try:
-                temp_env.close()
-            except Exception:
-                pass
-    return WebInterfaceManager(_make_env, AetherTaskFlowAction, AetherTaskFlowObservation, metadata=metadata)
-app = create_app(
-    _make_env, AetherTaskFlowAction, AetherTaskFlowObservation,
-    env_name="aether_taskflow", max_concurrent_envs=4,
-)
-_persistent_manager = _create_persistent_manager()
-def _remove_route(path: str, method: str) -> None:
-    app.router.routes = [
-        route for route in app.router.routes
-        if not (getattr(route, "path", None) == path and method in (getattr(route, "methods", set()) or set()))
-    ]
-for _path, _method in (("/reset", "POST"), ("/step", "POST"), ("/state", "GET"), ("/schema", "GET")):
-    _remove_route(_path, _method)
-def _action_to_payload(action: Any) -> Dict[str, Any]:
-    if hasattr(action, "model_dump"):
-        return action.model_dump(exclude={"metadata"})
-    if isinstance(action, dict):
-        return action
-    raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail="Invalid action")
-def _extract_action_payload(payload: Dict[str, Any]) -> Dict[str, Any]:
-    env = _persistent_manager.env
-    if "message" in payload and isinstance(payload["message"], str):
-        if hasattr(env, "message_to_action"):
-            return _action_to_payload(env.message_to_action(payload["message"]))
-        return {"message": payload["message"]}
-    action_payload = payload.get("action", payload)
-    if isinstance(action_payload, str):
-        if hasattr(env, "message_to_action"):
-            return _action_to_payload(env.message_to_action(action_payload))
-        return {"message": action_payload}
-    if isinstance(action_payload, dict):
-        if "message" in action_payload and isinstance(action_payload["message"], str):
-            if hasattr(env, "message_to_action"):
-                return _action_to_payload(env.message_to_action(action_payload["message"]))
-            return {"message": action_payload["message"]}
-        return action_payload
-    raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail="Invalid payload")
-@app.get("/", response_class=HTMLResponse, tags=["UI"], summary="Mission Control Dashboard")
-async def root() -> HTMLResponse:
-    difficulty = os.getenv("AETHER_DIFFICULTY", "easy")
-    html = f"""<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8"/>
-  <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
-  <title>AETHER-TaskFlow · Mission Control</title>
-  <link rel="preconnect" href="https://fonts.googleapis.com"/>
-  <link href="https://fonts.googleapis.com/css2?family=Space+Mono:ital,wght@0,400;0,700;1,400&family=Syne:wght@400;600;700;800&display=swap" rel="stylesheet"/>
-  <style>
-    :root {{
-      --bg:       #050810;
-      --panel:    #0b0f1e;
-      --border:   #1a2040;
-      --border2:  #252d50;
-      --accent:   #3d7eff;
-      --accent2:  #6b3dff;
-      --cyan:     #00d4ff;
-      --green:    #00e676;
-      --amber:    #ffab00;
-      --red:      #ff3d3d;
-      --text:     #cdd6f4;
-      --muted:    #6c7a9c;
-      --glow:     rgba(61,126,255,0.18);
-    }}
-    *, *::before, *::after {{ box-sizing: border-box; margin: 0; padding: 0; }}
-    body {{
-      font-family: 'Syne', sans-serif;
-      background: var(--bg);
-      color: var(--text);
-      min-height: 100vh;
-      overflow-x: hidden;
-    }}
-    /* Grid scanline overlay */
-    body::before {{
-      content: '';
-      position: fixed; inset: 0;
-      background:
-        repeating-linear-gradient(0deg, transparent, transparent 39px, rgba(61,126,255,0.03) 40px),
-        repeating-linear-gradient(90deg, transparent, transparent 39px, rgba(61,126,255,0.03) 40px);
-      pointer-events: none; z-index: 0;
-    }}
-    /* ── TOP BAR ── */
-    header {{
-      position: relative; z-index: 10;
-      display: flex; align-items: center; justify-content: space-between;
-      padding: 0 28px;
-      height: 60px;
-      background: rgba(11,15,30,0.95);
-      border-bottom: 1px solid var(--border2);
-      backdrop-filter: blur(12px);
-    }}
-    .logo {{
-      display: flex; align-items: center; gap: 12px;
-    }}
-    .logo-icon {{
-      width: 32px; height: 32px;
-      background: linear-gradient(135deg, var(--accent), var(--accent2));
-      border-radius: 8px;
-      display: flex; align-items: center; justify-content: center;
-      font-size: 16px;
-      box-shadow: 0 0 20px rgba(61,126,255,0.4);
-    }}
-    .logo-text {{ font-size: 1rem; font-weight: 800; letter-spacing: -0.02em; }}
-    .logo-sub {{ font-size: 0.7rem; color: var(--muted); font-family: 'Space Mono', monospace; margin-top: 1px; }}
-    .header-links {{ display: flex; gap: 6px; }}
-    .hlink {{
-      font-family: 'Space Mono', monospace;
-      font-size: 0.68rem; color: var(--muted);
-      text-decoration: none; padding: 5px 10px;
-      border: 1px solid var(--border2); border-radius: 4px;
-      transition: all .15s;
-    }}
-    .hlink:hover {{ color: var(--cyan); border-color: var(--cyan); }}
-    .live-indicator {{
-      display: flex; align-items: center; gap: 6px;
-      font-family: 'Space Mono', monospace; font-size: 0.68rem; color: var(--green);
-    }}
-    .live-dot {{
-      width: 6px; height: 6px; border-radius: 50%;
-      background: var(--green);
-      box-shadow: 0 0 6px var(--green);
-      animation: pulse-dot 1.8s ease-in-out infinite;
-    }}
-    @keyframes pulse-dot {{
-      0%,100% {{ opacity: 1; transform: scale(1); }}
-      50% {{ opacity: 0.5; transform: scale(0.7); }}
-    }}
-    /* ── LAYOUT ── */
-    .workspace {{
-      position: relative; z-index: 1;
-      display: grid;
-      grid-template-columns: 300px 1fr 260px;
-      grid-template-rows: auto 1fr auto;
-      gap: 0;
-      height: calc(100vh - 60px);
-      overflow: hidden;
-    }}
-    /* ── COMMAND BAR ── */
-    .cmd-bar {{
-      grid-column: 1 / -1;
-      display: flex; align-items: center; gap: 10px;
-      padding: 10px 20px;
-      background: rgba(11,15,30,0.8);
-      border-bottom: 1px solid var(--border);
-    }}
-    .cmd-label {{
-      font-family: 'Space Mono', monospace;
-      font-size: 0.65rem; color: var(--muted);
-      text-transform: uppercase; letter-spacing: .1em;
-      white-space: nowrap;
-    }}
-    select.diff-select {{
-      background: var(--panel); border: 1px solid var(--border2);
-      color: var(--text); padding: 7px 14px; border-radius: 6px;
-      font-family: 'Space Mono', monospace; font-size: 0.75rem;
-      cursor: pointer; outline: none;
-      transition: border-color .15s;
-    }}
-    select.diff-select:focus {{ border-color: var(--accent); }}
-    .cmd-btn {{
-      padding: 7px 18px; border: none; border-radius: 6px;
-      font-family: 'Syne', sans-serif; font-size: 0.78rem; font-weight: 700;
-      cursor: pointer; transition: all .15s; white-space: nowrap;
-    }}
-    .cmd-btn:hover {{ transform: translateY(-1px); filter: brightness(1.1); }}
-    .cmd-btn:active {{ transform: translateY(0); }}
-    .cmd-btn:disabled {{ opacity: 0.35; cursor: not-allowed; transform: none; }}
-    .btn-reset {{ background: linear-gradient(135deg, var(--accent), var(--accent2)); color: white; }}
-    .btn-step  {{ background: var(--green); color: #000; }}
-    .btn-auto  {{ background: var(--amber); color: #000; }}
-    .btn-stop  {{ background: var(--red); color: white; }}
-    .status-pill {{
-      margin-left: auto;
-      font-family: 'Space Mono', monospace; font-size: 0.68rem;
-      padding: 4px 12px; border-radius: 20px;
-      border: 1px solid var(--border2); color: var(--muted);
-      transition: all .3s;
-    }}
-    .status-pill.ready {{ border-color: var(--green); color: var(--green); }}
-    .status-pill.done  {{ border-color: var(--amber); color: var(--amber); }}
-    /* ── LEFT PANEL: Task Queue ── */
-    .panel-left {{
-      grid-row: 2;
-      background: var(--panel);
-      border-right: 1px solid var(--border);
-      display: flex; flex-direction: column;
-      overflow: hidden;
-    }}
-    .panel-title {{
-      padding: 12px 16px 8px;
-      font-size: 0.65rem; font-weight: 700;
-      text-transform: uppercase; letter-spacing: .12em;
-      color: var(--muted);
-      border-bottom: 1px solid var(--border);
-      display: flex; align-items: center; justify-content: space-between;
-    }}
-    .task-scroll {{
-      flex: 1; overflow-y: auto; padding: 10px;
-      scrollbar-width: thin; scrollbar-color: var(--border2) transparent;
-    }}
-    .task-card {{
-      border: 1px solid var(--border2);
-      border-radius: 8px; padding: 10px 12px;
-      margin-bottom: 8px; cursor: pointer;
-      transition: all .15s;
-      position: relative; overflow: hidden;
-    }}
-    .task-card::before {{
-      content: '';
-      position: absolute; left: 0; top: 0; bottom: 0;
-      width: 3px;
-      background: var(--muted);
-      transition: background .15s;
-    }}
-    .task-card:hover {{ border-color: var(--accent); background: rgba(61,126,255,0.05); }}
-    .task-card:hover::before {{ background: var(--accent); }}
-    .task-card.selected {{ border-color: var(--accent); background: rgba(61,126,255,0.08); box-shadow: 0 0 0 1px rgba(61,126,255,0.2); }}
-    .task-card.selected::before {{ background: var(--accent); box-shadow: 0 0 8px var(--accent); }}
-    .task-card.urgent {{ border-color: rgba(255,61,61,0.4); }}
-    .task-card.urgent::before {{ background: var(--red); }}
-    .task-name {{ font-size: 0.78rem; font-weight: 600; margin-bottom: 6px; line-height: 1.3; padding-left: 6px; }}
-    .task-chips {{ display: flex; flex-wrap: wrap; gap: 4px; padding-left: 6px; }}
-    .chip {{
-      font-family: 'Space Mono', monospace;
-      font-size: 0.6rem; padding: 2px 5px;
-      border-radius: 3px; border: 1px solid var(--border2);
-      color: var(--muted);
-    }}
-    .chip.hi  {{ color: var(--green);  border-color: rgba(0,230,118,0.3); }}
-    .chip.mid {{ color: var(--amber);  border-color: rgba(255,171,0,0.3); }}
-    .chip.lo  {{ color: var(--red);    border-color: rgba(255,61,61,0.3); }}
-    .chip.val {{ color: var(--cyan);   border-color: rgba(0,212,255,0.3); }}
-    .task-empty {{
-      text-align: center; padding: 40px 16px;
-      color: var(--muted); font-size: 0.8rem; line-height: 1.6;
-    }}
-    /* ── CENTRE: Visualisation ── */
-    .panel-centre {{
-      grid-row: 2;
-      display: flex; flex-direction: column;
-      overflow: hidden;
-      border-right: 1px solid var(--border);
-    }}
-    /* Resource meters */
-    .resource-row {{
-      display: grid; grid-template-columns: repeat(4, 1fr);
-      gap: 10px; padding: 14px 16px;
-      border-bottom: 1px solid var(--border);
-      background: rgba(11,15,30,0.5);
-    }}
-    .res-cell {{
-      background: var(--panel);
-      border: 1px solid var(--border2);
-      border-radius: 8px; padding: 10px 14px;
-      position: relative; overflow: hidden;
-    }}
-    .res-cell::after {{
-      content: '';
-      position: absolute; bottom: 0; left: 0;
-      height: 2px; width: var(--fill, 0%);
-      background: var(--fill-color, var(--accent));
-      transition: width .5s ease, background .5s ease;
-    }}
-    .res-label {{
-      font-family: 'Space Mono', monospace;
-      font-size: 0.6rem; color: var(--muted);
-      text-transform: uppercase; letter-spacing: .08em;
-    }}
-    .res-value {{
-      font-family: 'Space Mono', monospace;
-      font-size: 1.25rem; font-weight: 700;
-      color: var(--text); margin: 4px 0 0;
-    }}
-    /* Action picker */
-    .action-panel {{
-      padding: 12px 16px;
-      border-bottom: 1px solid var(--border);
-      background: rgba(11,15,30,0.3);
-    }}
-    .action-grid {{ display: grid; grid-template-columns: repeat(4,1fr); gap: 8px; margin-top: 8px; }}
-    .act-btn {{
-      border: 1px solid var(--border2);
-      border-radius: 8px; padding: 10px 6px;
-      cursor: pointer; text-align: center;
-      transition: all .15s; background: var(--panel);
-      color: var(--muted); font-family: 'Syne', sans-serif;
-    }}
-    .act-btn:hover {{ border-color: var(--accent); color: var(--text); background: rgba(61,126,255,0.07); }}
-    .act-btn.active {{
-      border-color: var(--accent); color: var(--accent);
-      background: rgba(61,126,255,0.12);
-      box-shadow: 0 0 12px rgba(61,126,255,0.15);
-    }}
-    .act-btn .act-icon {{ font-size: 1.2rem; display: block; margin-bottom: 3px; }}
-    .act-btn .act-name {{ font-size: 0.72rem; font-weight: 700; }}
-    .act-btn .act-sub  {{ font-size: 0.6rem; color: var(--muted); margin-top: 1px; font-family: 'Space Mono', monospace; }}
-    /* Outcome text */
-    .outcome-bar {{
-      padding: 10px 16px;
-      border-bottom: 1px solid var(--border);
-      font-family: 'Space Mono', monospace;
-      font-size: 0.72rem; color: var(--muted);
-      background: rgba(5,8,16,0.5);
-      min-height: 38px;
-    }}
-    .outcome-bar span {{ color: var(--cyan); }}
-    /* Reward chart area */
-    .chart-area {{
-      flex: 1; padding: 14px 16px;
-      display: flex; flex-direction: column; gap: 10px;
-    }}
-    .chart-title {{
-      font-size: 0.62rem; font-weight: 700;
-      text-transform: uppercase; letter-spacing: .1em;
-      color: var(--muted);
-    }}
-    .reward-chart {{
-      flex: 1;
-      display: flex; align-items: flex-end;
-      gap: 4px; border-bottom: 1px solid var(--border2);
-      padding-bottom: 4px; min-height: 80px;
-    }}
-    .reward-bar {{
-      flex: 1; min-width: 8px; border-radius: 3px 3px 0 0;
-      transition: height .4s ease, background .4s;
-      position: relative;
-    }}
-    .reward-bar::after {{
-      content: attr(data-val);
-      position: absolute; bottom: calc(100% + 2px); left: 50%;
-      transform: translateX(-50%);
-      font-family: 'Space Mono', monospace; font-size: 0.5rem;
-      color: var(--muted); white-space: nowrap;
-      opacity: 0; transition: opacity .2s;
-    }}
-    .reward-bar:hover::after {{ opacity: 1; }}
-    /* ── RIGHT PANEL: Telemetry ── */
-    .panel-right {{
-      grid-row: 2;
-      background: var(--panel);
-      display: flex; flex-direction: column;
-      overflow-y: auto;
-      scrollbar-width: thin; scrollbar-color: var(--border2) transparent;
-    }}
-    .score-hero {{
-      padding: 20px 16px 14px;
-      text-align: center;
-      border-bottom: 1px solid var(--border);
-      position: relative;
-    }}
-    .score-ring {{
-      width: 110px; height: 110px;
-      margin: 0 auto 10px;
-      position: relative;
-    }}
-    .score-ring svg {{ transform: rotate(-90deg); }}
-    .score-ring .ring-bg {{ fill: none; stroke: var(--border2); stroke-width: 8; }}
-    .score-ring .ring-fill {{
-      fill: none; stroke-width: 8;
-      stroke-linecap: round;
-      stroke-dasharray: 283;
-      stroke-dashoffset: 283;
-      transition: stroke-dashoffset .8s cubic-bezier(.4,0,.2,1), stroke .4s;
-      stroke: var(--accent);
-    }}
-    .score-num {{
-      position: absolute; top: 50%; left: 50%;
-      transform: translate(-50%,-50%);
-      font-family: 'Space Mono', monospace;
-      font-size: 1.5rem; font-weight: 700;
-    }}
-    .score-label {{ font-size: 0.62rem; color: var(--muted); text-transform: uppercase; letter-spacing: .1em; }}
-    .stat-grid {{
-      display: grid; grid-template-columns: 1fr 1fr;
-      gap: 8px; padding: 12px;
-      border-bottom: 1px solid var(--border);
-    }}
-    .stat-box {{
-      background: rgba(5,8,16,0.6);
-      border: 1px solid var(--border2);
-      border-radius: 8px; padding: 10px;
-      text-align: center;
-    }}
-    .stat-box .sn {{
-      font-family: 'Space Mono', monospace;
-      font-size: 1.3rem; font-weight: 700;
-    }}
-    .stat-box .sl {{ font-size: 0.6rem; color: var(--muted); margin-top: 2px; text-transform: uppercase; letter-spacing: .07em; }}
-    .stat-box.green .sn {{ color: var(--green); }}
-    .stat-box.red   .sn {{ color: var(--red);   }}
-    .stat-box.cyan  .sn {{ color: var(--cyan);  }}
-    .stat-box.amber .sn {{ color: var(--amber); }}
-    /* Health bar */
-    .health-section {{ padding: 12px; border-bottom: 1px solid var(--border); }}
-    .health-label {{ font-size: 0.62rem; color: var(--muted); text-transform: uppercase; letter-spacing: .1em; margin-bottom: 8px; display: flex; justify-content: space-between; }}
-    .health-track {{
-      height: 8px; background: var(--border2); border-radius: 4px; overflow: hidden;
-    }}
-    .health-fill {{
-      height: 100%; border-radius: 4px;
-      transition: width .5s ease, background .5s ease;
-      background: var(--green);
-    }}
-    /* Log */
-    .log-panel {{ flex: 1; padding: 10px; }}
-    .log-title {{ font-size: 0.62rem; font-weight: 700; text-transform: uppercase; letter-spacing: .1em; color: var(--muted); margin-bottom: 8px; }}
-    .log-scroll {{
-      height: 200px; overflow-y: auto;
-      scrollbar-width: thin; scrollbar-color: var(--border2) transparent;
-    }}
-    .log-entry {{
-      font-family: 'Space Mono', monospace;
-      font-size: 0.62rem; line-height: 1.7;
-      padding: 1px 0; border-bottom: 1px solid rgba(26,32,64,0.4);
-      color: var(--muted);
-    }}
-    .log-entry.pos {{ color: var(--green); }}
-    .log-entry.neg {{ color: var(--red);   }}
-    .log-entry.inf {{ color: var(--cyan);  }}
-    .log-entry.wrn {{ color: var(--amber); }}
-    /* ── STATUS BAR ── */
-    .status-bar {{
-      grid-column: 1 / -1;
-      display: flex; align-items: center; gap: 16px;
-      padding: 6px 20px;
-      background: rgba(11,15,30,0.95);
-      border-top: 1px solid var(--border);
-      font-family: 'Space Mono', monospace;
-      font-size: 0.62rem; color: var(--muted);
-    }}
-    .sb-item {{ display: flex; align-items: center; gap: 6px; }}
-    .sb-dot {{ width: 5px; height: 5px; border-radius: 50%; background: var(--muted); }}
-    .sb-dot.ok  {{ background: var(--green); box-shadow: 0 0 5px var(--green); }}
-    .sb-dot.bad {{ background: var(--red); }}
-    /* Spinner */
-    .spinner {{
-      display: inline-block; width: 12px; height: 12px;
-      border: 2px solid rgba(255,255,255,0.2);
-      border-top-color: white; border-radius: 50%;
-      animation: spin .6s linear infinite;
-      vertical-align: middle; margin-right: 5px;
-    }}
-    @keyframes spin {{ to {{ transform: rotate(360deg); }} }}
-    /* DONE FLASH */
-    @keyframes flash-border {{
-      0%,100% {{ border-color: var(--border2); }}
-      50% {{ border-color: var(--amber); box-shadow: 0 0 20px rgba(255,171,0,0.3); }}
-    }}
-    .episode-done {{ animation: flash-border 1.5s ease 2; }}
-  </style>
-</head>
-<body>
-<!-- ── TOP BAR ── -->
-<header>
-  <div class="logo">
-    <div class="logo-icon">⚡</div>
-    <div>
-      <div class="logo-text">AETHER-TaskFlow</div>
-      <div class="logo-sub">OPENENV · RL ENVIRONMENT · v1.0.0</div>
-    </div>
-  </div>
-  <div class="live-indicator"><div class="live-dot"></div>LIVE</div>
-  <div class="header-links">
-    <a class="hlink" href="/docs">Swagger</a>
-    <a class="hlink" href="/schema">Schema</a>
-    <a class="hlink" href="/state">State</a>
-    <a class="hlink" href="/health">Health</a>
-  </div>
-</header>
-<!-- ── WORKSPACE ── -->
-<div class="workspace">
-  <!-- COMMAND BAR -->
-  <div class="cmd-bar">
-    <span class="cmd-label">Difficulty</span>
-    <select class="diff-select" id="difficulty">
-      <option value="easy"   {"selected" if difficulty=="easy"   else ""}>🟢 EASY — 5 tasks, stable</option>
-      <option value="medium" {"selected" if difficulty=="medium" else ""}>🟡 MEDIUM — 8 tasks, dynamic</option>
-      <option value="hard"   {"selected" if difficulty=="hard"   else ""}>🔴 HARD — 12 tasks, scarce</option>
-    </select>
-    <button class="cmd-btn btn-reset" id="reset-btn" onclick="resetEnv()">
-      <span id="reset-spinner" style="display:none" class="spinner"></span>⟳ RESET
-    </button>
-    <button class="cmd-btn btn-step"  id="step-btn"  onclick="stepEnv()"  disabled>▶ STEP</button>
-    <button class="cmd-btn btn-auto"  id="auto-btn"  onclick="toggleAuto()" disabled>⏩ AUTO</button>
-    <span class="status-pill" id="status-pill">STANDBY</span>
-  </div>
-  <!-- LEFT: Task Queue -->
-  <div class="panel-left">
-    <div class="panel-title">
-      <span>📋 TASK QUEUE</span>
-      <span id="task-badge" style="font-family:'Space Mono',monospace;font-size:0.65rem;color:var(--accent);">0 tasks</span>
-    </div>
-    <div class="task-scroll" id="task-list">
-      <div class="task-empty">
-        Reset the environment<br/>to load tasks
-      </div>
-    </div>
-  </div>
-  <!-- CENTRE: Main visualisation -->
-  <div class="panel-centre">
-    <!-- Resource meters -->
-    <div class="resource-row">
-      <div class="res-cell" id="rc-time">
-        <div class="res-label">⏱ Time Remaining</div>
-        <div class="res-value" id="res-time">—</div>
-      </div>
-      <div class="res-cell" id="rc-energy">
-        <div class="res-label">⚡ Energy</div>
-        <div class="res-value" id="res-energy">—</div>
-      </div>
-      <div class="res-cell" id="rc-budget">
-        <div class="res-label">💰 Budget</div>
-        <div class="res-value" id="res-budget">—</div>
-      </div>
-      <div class="res-cell" id="rc-value">
-        <div class="res-label">🏆 Cumulative Value</div>
-        <div class="res-value" id="res-value">—</div>
-      </div>
-    </div>
-    <!-- Action picker -->
-    <div class="action-panel">
-      <div class="chart-title">SELECT ACTION</div>
-      <div class="action-grid">
-        <div class="act-btn active" onclick="selectAction('execute')" id="act-execute">
-          <span class="act-icon">⚡</span>
-          <div class="act-name">EXECUTE</div>
-          <div class="act-sub">Full reward</div>
-        </div>
-        <div class="act-btn" onclick="selectAction('optimize')" id="act-optimize">
-          <span class="act-icon">🔧</span>
-          <div class="act-name">OPTIMIZE</div>
-          <div class="act-sub">Reduce risk</div>
-        </div>
-        <div class="act-btn" onclick="selectAction('delegate')" id="act-delegate">
-          <span class="act-icon">📤</span>
-          <div class="act-name">DELEGATE</div>
-          <div class="act-sub">35% reward</div>
-        </div>
-        <div class="act-btn" onclick="selectAction('defer')" id="act-defer">
-          <span class="act-icon">⏳</span>
-          <div class="act-name">DEFER</div>
-          <div class="act-sub">Small penalty</div>
-        </div>
-      </div>
-    </div>
-    <!-- Outcome readout -->
-    <div class="outcome-bar" id="outcome-bar">
-      <span>›</span> Waiting for first action...
-    </div>
-    <!-- Reward history chart -->
-    <div class="chart-area">
-      <div class="chart-title">REWARD HISTORY — per step</div>
-      <div class="reward-chart" id="reward-chart">
-        <div style="color:var(--muted);font-size:0.72rem;width:100%;text-align:center;padding-bottom:10px;">No data yet</div>
-      </div>
-    </div>
-  </div>
-  <!-- RIGHT: Telemetry -->
-  <div class="panel-right">
-    <!-- Score ring -->
-    <div class="score-hero" id="score-hero">
-      <div class="score-ring">
-        <svg viewBox="0 0 100 100" width="110" height="110">
-          <circle class="ring-bg" cx="50" cy="50" r="45"/>
-          <circle class="ring-fill" id="ring-fill" cx="50" cy="50" r="45"/>
-        </svg>
-        <div class="score-num" id="score-num">—</div>
-      </div>
-      <div class="score-label">Episode Score</div>
-    </div>
-    <!-- Stats -->
-    <div class="stat-grid">
-      <div class="stat-box cyan">
-        <div class="sn" id="stat-step">0</div>
-        <div class="sl">Steps</div>
-      </div>
-      <div class="stat-box amber">
-        <div class="sn" id="stat-reward">0.00</div>
-        <div class="sl">Last Reward</div>
-      </div>
-      <div class="stat-box green">
-        <div class="sn" id="stat-done">0</div>
-        <div class="sl">Completed</div>
-      </div>
-      <div class="stat-box red">
-        <div class="sn" id="stat-fail">0</div>
-        <div class="sl">Failed</div>
-      </div>
-    </div>
-    <!-- Health -->
-    <div class="health-section">
-      <div class="health-label">
-        <span>SYSTEM HEALTH</span>
-        <span id="health-pct" style="color:var(--green);font-family:'Space Mono',monospace;">—</span>
-      </div>
-      <div class="health-track">
-        <div class="health-fill" id="health-fill" style="width:0%"></div>
-      </div>
-    </div>
-    <!-- Log -->
-    <div class="log-panel">
-      <div class="log-title">ACTION LOG</div>
-      <div class="log-scroll" id="log">
-        <div class="log-entry inf">› System online. Select difficulty and press RESET.</div>
-      </div>
-    </div>
-  </div>
-  <!-- STATUS BAR -->
-  <div class="status-bar">
-    <div class="sb-item"><div class="sb-dot ok" id="sb-api"></div>API ONLINE</div>
-    <div class="sb-item"><div class="sb-dot" id="sb-ep"></div><span id="sb-ep-text">NO EPISODE</span></div>
-    <div class="sb-item" style="margin-left:auto;">
-      <span>Meta PyTorch OpenEnv Hackathon 2025</span>
-    </div>
-    <div class="sb-item">
-      <a href="/docs" style="color:var(--muted);text-decoration:none;">OpenAPI ↗</a>
-    </div>
-  </div>
-</div>
-<script>
-// ── STATE ──
-let selectedTask   = null;
-let selectedAction = 'execute';
-let episodeDone    = false;
-let autoTimer      = null;
-let rewardHistory  = [];
-let stepCount      = 0;
-// ── HELPERS ──
-function log(msg, cls='') {{
-  const container = document.getElementById('log');
-  const el = document.createElement('div');
-  el.className = 'log-entry ' + cls;
-  el.textContent = new Date().toLocaleTimeString('en-GB', {{hour:'2-digit',minute:'2-digit',second:'2-digit'}}) + ' › ' + msg;
-  container.appendChild(el);
-  container.scrollTop = container.scrollHeight;
-}}
-function setStatusPill(text, cls='') {{
-  const p = document.getElementById('status-pill');
-  p.textContent = text;
-  p.className   = 'status-pill ' + cls;
-}}
-function selectAction(a) {{
-  selectedAction = a;
-  ['execute','optimize','delegate','defer'].forEach(x => {{
-    document.getElementById('act-' + x).classList.toggle('active', x === a);
-  }});
-}}
-function selectTask(id) {{
-  selectedTask = id;
-  document.querySelectorAll('.task-card').forEach(c => {{
-    c.classList.toggle('selected', parseInt(c.dataset.id) === id);
-  }});
-}}
-// ── RESOURCES ──
-function updateResources(obs) {{
-  const time   = obs.time_remaining   ?? 0;
-  const energy = obs.energy_remaining ?? 0;
-  const budget = obs.budget_remaining ?? 0;
-  const value  = obs.cumulative_value ?? 0;
-  const health = obs.system_health    ?? 1;
-  document.getElementById('res-time').textContent   = time;
-  document.getElementById('res-energy').textContent = energy.toFixed(1);
-  document.getElementById('res-budget').textContent = budget.toFixed(1);
-  document.getElementById('res-value').textContent  = value.toFixed(1);
-  // fill bars — approximate max from difficulty
-  const maxEnergy = 12; const maxBudget = 60;
-  setResFill('rc-time',   Math.min(time/10,1)          * 100, time < 3 ? 'var(--red)' : time < 6 ? 'var(--amber)' : 'var(--green)');
-  setResFill('rc-energy', Math.min(energy/maxEnergy,1) * 100, energy < 2 ? 'var(--red)' : energy < 5 ? 'var(--amber)' : 'var(--cyan)');
-  setResFill('rc-budget', Math.min(budget/maxBudget,1) * 100, budget < 5 ? 'var(--red)' : budget < 15 ? 'var(--amber)' : 'var(--accent2)');
-  setResFill('rc-value',  Math.min(value/50,1)         * 100, 'var(--amber)');
-  // health bar
-  const h   = Math.max(0, Math.min(1, health));
-  const hc  = h > 0.6 ? 'var(--green)' : h > 0.3 ? 'var(--amber)' : 'var(--red)';
-  document.getElementById('health-fill').style.width      = (h * 100) + '%';
-  document.getElementById('health-fill').style.background = hc;
-  document.getElementById('health-pct').textContent       = (h * 100).toFixed(0) + '%';
-  document.getElementById('health-pct').style.color       = hc;
-  // stats
-  document.getElementById('stat-step').textContent = obs.step_number    ?? stepCount;
-  document.getElementById('stat-done').textContent = obs.tasks_completed ?? 0;
-  document.getElementById('stat-fail').textContent = obs.tasks_failed    ?? 0;
-  // outcome
-  if (obs.last_action_outcome) {{
-    document.getElementById('outcome-bar').innerHTML =
-      '<span>›</span> ' + obs.last_action_outcome;
-  }}
-}}
-function setResFill(id, pct, color) {{
-  const el = document.getElementById(id);
-  el.style.setProperty('--fill', pct + '%');
-  el.style.setProperty('--fill-color', color);
-}}
-// ── SCORE RING ──
-function updateScore(score) {{
-  const n = typeof score === 'number' ? score : parseFloat(score);
-  if (isNaN(n)) return;
-  const circumference = 283;
-  const offset = circumference * (1 - Math.max(0, Math.min(1, n)));
-  document.getElementById('ring-fill').style.strokeDashoffset = offset;
-  const color = n >= 0.7 ? 'var(--green)' : n >= 0.4 ? 'var(--amber)' : 'var(--red)';
-  document.getElementById('ring-fill').style.stroke = color;
-  document.getElementById('score-num').textContent = n.toFixed(2);
-  document.getElementById('score-num').style.color = color;
-}}
-// ── REWARD CHART ──
-function pushReward(reward) {{
-  rewardHistory.push(reward);
-  if (rewardHistory.length > 30) rewardHistory.shift();
-  renderChart();
-}}
-function renderChart() {{
-  const chart = document.getElementById('reward-chart');
-  if (rewardHistory.length === 0) {{
-    chart.innerHTML = '<div style="color:var(--muted);font-size:0.72rem;width:100%;text-align:center;padding-bottom:10px;">No data yet</div>';
-    return;
-  }}
-  const max = Math.max(...rewardHistory.map(Math.abs), 0.01);
-  chart.innerHTML = '';
-  rewardHistory.forEach((r, i) => {{
-    const bar = document.createElement('div');
-    bar.className   = 'reward-bar';
-    bar.dataset.val = r.toFixed(2);
-    const hPct = (Math.abs(r) / max) * 90 + 5;
-    bar.style.height     = hPct + '%';
-    bar.style.background = r >= 0.5 ? 'var(--green)' : r >= 0.3 ? 'var(--cyan)' : r >= 0 ? 'var(--amber)' : 'var(--red)';
-    bar.style.opacity    = 0.5 + (i / rewardHistory.length) * 0.5;
-    chart.appendChild(bar);
-  }});
-}}
-// ── TASK CARDS ──
-function renderTasks(tasks) {{
-  const list = document.getElementById('task-list');
-  document.getElementById('task-badge').textContent = (tasks?.length ?? 0) + ' tasks';
-  if (!tasks || tasks.length === 0) {{
-    list.innerHTML = '<div class="task-empty">All tasks resolved</div>';
-    return;
-  }}
-  list.innerHTML = '';
-  tasks.forEach(t => {{
-    const urgency   = t.deadline <= 2;
-    const medUrgent = t.deadline <= 4;
-    const card = document.createElement('div');
-    card.className = 'task-card' + (urgency ? ' urgent' : '') + (selectedTask === t.task_id ? ' selected' : '');
-    card.dataset.id = t.task_id;
-    card.onclick    = () => selectTask(t.task_id);
-    const priCls  = t.priority  > 0.7 ? 'hi' : t.priority  > 0.4 ? 'mid' : 'lo';
-    const dlCls   = urgency ? 'lo' : medUrgent ? 'mid' : 'hi';
-    const riskCls = t.uncertainty > 0.6 ? 'lo' : t.uncertainty > 0.3 ? 'mid' : 'hi';
-    card.innerHTML = `
-      <div class="task-name">[#${{t.task_id}}] ${{t.name}}</div>
-      <div class="task-chips">
-        <span class="chip ${{priCls}}">PRI ${{(t.priority*100).toFixed(0)}}%</span>
-        <span class="chip ${{dlCls}}">⏰ ${{t.deadline}}s</span>
-        <span class="chip ${{riskCls}}">RISK ${{(t.uncertainty*100).toFixed(0)}}%</span>
-        <span class="chip val">${{t.value.toFixed(1)}}v</span>
-        <span class="chip">E${{t.required_energy.toFixed(1)}}</span>
-        <span class="chip">B${{t.required_budget.toFixed(1)}}</span>
-      </div>`;
-    list.appendChild(card);
-  }});
-  if (selectedTask === null && tasks.length > 0) selectTask(tasks[0].task_id);
-}}
-// ── RESET ──
-async function resetEnv() {{
-  stopAuto();
-  episodeDone    = false;
-  rewardHistory  = [];
-  stepCount      = 0;
-  selectedTask   = null;
-  renderChart();
-  document.getElementById('reset-spinner').style.display = 'inline-block';
-  document.getElementById('score-num').textContent = '—';
-  document.getElementById('score-num').style.color = 'var(--text)';
-  document.getElementById('ring-fill').style.strokeDashoffset = 283;
-  document.getElementById('ring-fill').style.stroke = 'var(--accent)';
-  document.getElementById('stat-reward').textContent = '0.00';
-  setStatusPill('RESETTING…');
-  const diff = document.getElementById('difficulty').value;
-  try {{
-    const r   = await fetch('/reset', {{
-      method: 'POST',
-      headers: {{'Content-Type': 'application/json'}},
-      body: JSON.stringify({{difficulty: diff}})
-    }});
-    const data = await r.json();
-    const obs  = data.observation || data;
-    renderTasks(obs.tasks || []);
-    updateResources(obs);
-    document.getElementById('step-btn').disabled = false;
-    document.getElementById('auto-btn').disabled = false;
-    document.getElementById('sb-ep').classList.add('ok');
-    document.getElementById('sb-ep-text').textContent = 'EPISODE ACTIVE · ' + diff.toUpperCase();
-    setStatusPill('READY — ' + diff.toUpperCase(), 'ready');
-    log('Episode reset · ' + diff + ' · ' + (obs.tasks||[]).length + ' tasks loaded', 'inf');
-  }} catch(e) {{
-    log('Reset failed: ' + e.message, 'wrn');
-    setStatusPill('ERROR');
-  }}
-  document.getElementById('reset-spinner').style.display = 'none';
-}}
-// ── STEP ──
-async function stepEnv() {{
-  if (episodeDone) return;
-  const tid = selectedTask ?? 0;
-  try {{
-    const r   = await fetch('/step', {{
-      method: 'POST',
-      headers: {{'Content-Type': 'application/json'}},
-      body: JSON.stringify({{action_type: selectedAction, task_id: tid, reasoning: 'UI step'}})
-    }});
-    const data = await r.json();
-    const obs  = data.observation || data;
-    const reward = data.reward ?? obs.reward ?? 0;
-    const done   = data.done   ?? obs.done   ?? false;
-    stepCount++;
-    pushReward(reward);
-    renderTasks(obs.tasks || []);
-    updateResources(obs);
-    document.getElementById('stat-reward').textContent = reward.toFixed(3);
-    document.getElementById('stat-reward').style.color = reward >= 0.5 ? 'var(--green)' : reward >= 0 ? 'var(--amber)' : 'var(--red)';
-    const cls = reward >= 0.5 ? 'pos' : reward >= 0 ? 'wrn' : 'neg';
-    log(selectedAction + '(task=' + tid + ') → reward=' + reward.toFixed(3) + (done ? ' [DONE]' : ''), cls);
-    if (done) {{
-      episodeDone = true;
-      stopAuto();
-      document.getElementById('step-btn').disabled = true;
-      document.getElementById('auto-btn').disabled = true;
-      document.getElementById('sb-ep-text').textContent = 'EPISODE COMPLETE';
-      document.getElementById('sb-ep').classList.remove('ok');
-      setStatusPill('EPISODE COMPLETE', 'done');
-      document.getElementById('score-hero').classList.add('episode-done');
-      await fetchFinalScore();
-    }}
-  }} catch(e) {{
-    log('Step error: ' + e.message, 'wrn');
-  }}
-}}
-// ── FETCH SCORE ──
-async function fetchFinalScore() {{
-  try {{
-    const r    = await fetch('/state');
-    const state = await r.json();
-    const completed = state.tasks_completed ?? 0;
-    const failed    = state.tasks_failed    ?? 0;
-    const total     = completed + failed + (state.tasks?.length ?? 0);
-    const eff       = total > 0 ? completed / total : 0;
-    updateScore(eff);
-    log('Final — completed ' + completed + '/' + total + ' · health ' + ((state.system_health??1)*100).toFixed(0) + '%', 'inf');
-  }} catch(e) {{}}
-}}
-// ── AUTO PLAY ──
-function toggleAuto() {{
-  if (autoTimer) {{ stopAuto(); return; }}
-  const btn = document.getElementById('auto-btn');
-  btn.textContent = '⏹ STOP';
-  btn.className   = 'cmd-btn btn-stop';
-  autoTimer = setInterval(async () => {{
-    if (episodeDone) {{ stopAuto(); return; }}
-    await stepEnv();
-  }}, 700);
-}}
-function stopAuto() {{
-  clearInterval(autoTimer);
-  autoTimer = null;
-  const btn = document.getElementById('auto-btn');
-  btn.textContent = '⏩ AUTO';
-  btn.className   = 'cmd-btn btn-auto';
-}}
-</script>
-</body>
-</html>"""
-    return HTMLResponse(content=html)
-# ---------------------------------------------------------------------------
-# API Routes
-# ---------------------------------------------------------------------------
-@app.post("/reset", response_model=ResetResponse, tags=["Environment Control"], summary="Reset the environment")
-async def reset(request: ResetRequest = Body(default_factory=ResetRequest)) -> ResetResponse:
-    response = await _persistent_manager.reset_environment(request.model_dump(exclude_unset=True))
-    return ResetResponse(**response)
-@app.post("/step", response_model=StepResponse, tags=["Environment Control"], summary="Execute an action")
-async def step(payload: Dict[str, Any] = Body(default_factory=dict)) -> StepResponse:
-    try:
-        action_payload = _extract_action_payload(payload)
-        response = await _persistent_manager.step_environment(action_payload)
-    except ValidationError as exc:
-        raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=exc.errors()) from exc
-    return StepResponse(**response)
-@app.get("/state", response_model=AetherTaskFlowState, tags=["State Management"], summary="Get current state")
-async def get_state() -> AetherTaskFlowState:
-    return _persistent_manager.env.state
-@app.get("/schema", response_model=SchemaResponse, tags=["Schema"], summary="Get JSON schemas")
-async def get_schemas() -> SchemaResponse:
-    return SchemaResponse(
-        action=AetherTaskFlowAction.model_json_schema(),
-        observation=AetherTaskFlowObservation.model_json_schema(),
-        state=AetherTaskFlowState.model_json_schema(),
-    )
-def main(host: str = "0.0.0.0", port: int = 7860) -> None:
-    import uvicorn
-    uvicorn.run(app, host=host, port=port)
-if __name__ == "__main__":
-    import argparse
-    parser = argparse.ArgumentParser(description="AETHER-TaskFlow server")
-    parser.add_argument("--host", default="0.0.0.0")
-    parser.add_argument("--port", type=int, default=7860)
-    parser.add_argument("--difficulty", choices=["easy", "medium", "hard"], default=_DIFFICULTY)
-    args = parser.parse_args()
-    if args.difficulty != _DIFFICULTY:
-        os.environ["AETHER_DIFFICULTY"] = args.difficulty
-    main(host=args.host, port=args.port)

aether-taskflow/tests/__init__.py DELETED Viewed

File without changes

aether-taskflow/tests/__pycache__/__init__.cpython-312.pyc DELETED Viewed

Binary file (149 Bytes)

aether-taskflow/tests/__pycache__/test_aether_taskflow.cpython-312-pytest-9.0.3.pyc DELETED Viewed

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:f1098ee062416b1c3a5ed3de5631bd01436302c4a2885a9e4236996097f6f5d9
-size 107270

aether-taskflow/tests/test_aether_taskflow.py DELETED Viewed

@@ -1,587 +0,0 @@
-from __future__ import annotations
-import sys
-from pathlib import Path
-sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
-import pytest
-from fastapi.testclient import TestClient
-from models import AetherTaskFlowAction, AetherTaskFlowObservation, AetherTaskFlowState, ActionType
-from env.tasks import generate_tasks, get_profile
-from env.algorithms import AETHER, RAPTOR, AWFROX
-from env.grader import grade, grade_easy, grade_medium, grade_hard
-from env.aether_env import AetherTaskFlowEnvironment
-from server.app import app
-@pytest.fixture
-def easy_env():
-    return AetherTaskFlowEnvironment(difficulty="easy")
-@pytest.fixture
-def medium_env():
-    return AetherTaskFlowEnvironment(difficulty="medium")
-@pytest.fixture
-def hard_env():
-    return AetherTaskFlowEnvironment(difficulty="hard")
-@pytest.fixture
-def resources():
-    return {"energy": 10.0, "budget": 50.0, "time": 10.0}
-@pytest.fixture
-def api_client():
-    return TestClient(app)
-class TestTaskGeneration:
-    def test_easy_task_count(self):
-        tasks = generate_tasks("easy", seed=42)
-        assert len(tasks) == 5
-    def test_medium_task_count(self):
-        tasks = generate_tasks("medium", seed=42)
-        assert len(tasks) == 8
-    def test_hard_task_count(self):
-        tasks = generate_tasks("hard", seed=42)
-        assert len(tasks) == 12
-    def test_tasks_have_required_fields(self):
-        tasks = generate_tasks("easy", seed=1)
-        for t in tasks:
-            d = t.to_dict()
-            assert "task_id" in d
-            assert "priority" in d
-            assert "deadline" in d
-            assert "uncertainty" in d
-            assert "value" in d
-            assert "required_energy" in d
-            assert "required_budget" in d
-            assert "category" in d
-            assert "status" in d
-    def test_priority_range(self):
-        tasks = generate_tasks("easy", seed=7)
-        for t in tasks:
-            assert 0.0 <= t.priority <= 1.0
-    def test_uncertainty_range(self):
-        tasks = generate_tasks("hard", seed=7)
-        for t in tasks:
-            assert 0.0 <= t.uncertainty <= 1.0
-    def test_reproducibility(self):
-        a = generate_tasks("medium", seed=99)
-        b = generate_tasks("medium", seed=99)
-        assert [t.task_id for t in a] == [t.task_id for t in b]
-        assert [round(t.priority, 5) for t in a] == [round(t.priority, 5) for t in b]
-    def test_different_seeds_differ(self):
-        a = generate_tasks("easy", seed=1)
-        b = generate_tasks("easy", seed=2)
-        # At least one task should differ
-        priorities_a = [t.priority for t in a]
-        priorities_b = [t.priority for t in b]
-        assert priorities_a != priorities_b
-class TestAETHER:
-    def test_score_returns_float(self, resources):
-        aether = AETHER()
-        task = {
-            "task_id": 0, "priority": 0.8, "deadline": 3,
-            "uncertainty": 0.2, "value": 15.0,
-            "required_energy": 1.0, "required_budget": 5.0,
-        }
-        score = aether.score(task, resources, step=0, max_steps=10)
-        assert isinstance(score, float)
-    def test_higher_priority_scores_higher(self, resources):
-        aether = AETHER()
-        low = {"task_id": 0, "priority": 0.2, "deadline": 5, "uncertainty": 0.1, "value": 10.0, "required_energy": 1.0, "required_budget": 5.0}
-        high = {"task_id": 1, "priority": 0.9, "deadline": 5, "uncertainty": 0.1, "value": 10.0, "required_energy": 1.0, "required_budget": 5.0}
-        assert aether.score(high, resources, 0, 10) > aether.score(low, resources, 0, 10)
-    def test_high_uncertainty_penalised(self, resources):
-        aether = AETHER()
-        base = {"task_id": 0, "priority": 0.7, "deadline": 4, "value": 10.0, "required_energy": 1.0, "required_budget": 5.0}
-        low_unc = {**base, "uncertainty": 0.1}
-        high_unc = {**base, "uncertainty": 0.9}
-        assert aether.score(low_unc, resources, 0, 10) > aether.score(high_unc, resources, 0, 10)
-    def test_rank_tasks_sorted_descending(self, resources):
-        aether = AETHER()
-        tasks = [
-            {"task_id": i, "priority": 0.3 + i * 0.2, "deadline": 5,
-             "uncertainty": 0.1, "value": 10.0, "required_energy": 1.0, "required_budget": 5.0}
-            for i in range(4)
-        ]
-        ranked = aether.rank_tasks(tasks, resources, 0, 10)
-        scores = [s for _, s in ranked]
-        assert scores == sorted(scores, reverse=True)
-    def test_update_modifies_weights(self):
-        aether = AETHER()
-        weights_before = dict(aether.weights)
-        aether.update(5.0)
-        aether.update(5.0)
-        assert aether.weights != weights_before
-    def test_weights_stay_in_range(self):
-        aether = AETHER()
-        for _ in range(50):
-            aether.update(10.0)
-        assert aether.weights["priority"] >= 0.5
-        assert aether.weights["uncertainty_penalty"] <= -0.1
-class TestRAPTOR:
-    def test_defers_on_low_energy(self):
-        raptor = RAPTOR()
-        task = {"priority": 0.8, "deadline": 3, "uncertainty": 0.2, "value": 15.0,
-                "required_energy": 5.0, "required_budget": 5.0}
-        resources = {"energy": 1.0, "budget": 50.0}  # energy too low
-        action = raptor.decide(task, resources, step=0, max_steps=10)
-        assert action in ("defer", "delegate")
-    def test_optimizes_high_uncertainty(self):
-        raptor = RAPTOR()
-        task = {"priority": 0.8, "deadline": 4, "uncertainty": 0.9, "value": 15.0,
-                "required_energy": 1.0, "required_budget": 5.0}
-        resources = {"energy": 10.0, "budget": 50.0}
-        action = raptor.decide(task, resources, step=0, max_steps=10)
-        assert action == "optimize"
-    def test_executes_with_good_resources(self):
-        raptor = RAPTOR()
-        task = {"priority": 0.8, "deadline": 3, "uncertainty": 0.1, "value": 15.0,
-                "required_energy": 1.0, "required_budget": 5.0}
-        resources = {"energy": 10.0, "budget": 50.0}
-        action = raptor.decide(task, resources, step=0, max_steps=10)
-        assert action == "execute"
-    def test_all_return_valid_action(self):
-        raptor = RAPTOR()
-        valid = {"execute", "defer", "delegate", "optimize"}
-        for seed in range(20):
-            import random
-            rng = random.Random(seed)
-            task = {"priority": rng.random(), "deadline": rng.randint(0, 8),
-                    "uncertainty": rng.random(), "value": rng.uniform(3, 30),
-                    "required_energy": rng.uniform(0.5, 4), "required_budget": rng.uniform(1, 20)}
-            resources = {"energy": rng.uniform(0, 12), "budget": rng.uniform(0, 60)}
-            action = raptor.decide(task, resources, rng.randint(0, 9), 10)
-            assert action in valid
-class TestAWFROX:
-    def test_removes_expired_tasks(self):
-        recycler = AWFROX()
-        tasks = [
-            {"task_id": 0, "deadline": -1, "status": "pending"},
-            {"task_id": 1, "deadline": 3, "status": "pending"},
-        ]
-        viable = recycler.filter_viable(tasks, {}, step=0, max_steps=10)
-        assert len(viable) == 1
-        assert viable[0]["task_id"] == 1
-    def test_recycles_deferred_when_resources_available(self):
-        recycler = AWFROX()
-        active = []
-        deferred = [{"task_id": 5, "status": "deferred", "deadline": 3,
-                     "required_energy": 1.0, "required_budget": 5.0}]
-        resources = {"energy": 10.0, "budget": 50.0}
-        new_active, new_deferred = recycler.recycle_deferred(active, deferred, resources, step=2)
-        assert len(new_active) == 1
-        assert new_active[0]["status"] == "pending"
-        assert len(new_deferred) == 0
-    def test_keeps_deferred_when_resources_insufficient(self):
-        recycler = AWFROX()
-        active = []
-        deferred = [{"task_id": 5, "status": "deferred", "deadline": 3,
-                     "required_energy": 10.0, "required_budget": 50.0}]
-        resources = {"energy": 0.5, "budget": 1.0}  # insufficient
-        new_active, new_deferred = recycler.recycle_deferred(active, deferred, resources, step=2)
-        assert len(new_active) == 0
-        assert len(new_deferred) == 1
-class TestGrader:
-    def _result(self, **kwargs):
-        base = {
-            "tasks_completed": 4, "tasks_failed": 1, "total_tasks": 5,
-            "remaining_time": 3.0, "remaining_energy": 5.0, "remaining_budget": 30.0,
-            "initial_time": 10.0, "initial_energy": 12.0, "initial_budget": 60.0,
-            "system_health": 0.9, "steps_used": 7, "max_steps": 10,
-        }
-        base.update(kwargs)
-        return base
-    def test_score_in_range(self):
-        for diff in ["easy", "medium", "hard"]:
-            s = grade(diff, self._result())
-            assert 0.0 <= s <= 1.0, f"{diff}: {s}"
-    def test_perfect_score_near_one(self):
-        perfect = {
-            "tasks_completed": 10, "tasks_failed": 0, "total_tasks": 10,
-            "remaining_time": 5.0, "remaining_energy": 8.0, "remaining_budget": 40.0,
-            "initial_time": 10.0, "initial_energy": 12.0, "initial_budget": 60.0,
-            "system_health": 1.0, "steps_used": 5, "max_steps": 10,
-        }
-        for diff in ["easy", "medium", "hard"]:
-            s = grade(diff, perfect)
-            assert s >= 0.6, f"{diff}: {s}"
-    def test_zero_score_on_all_failed(self):
-        worst = {
-            "tasks_completed": 0, "tasks_failed": 10, "total_tasks": 10,
-            "remaining_time": 0.0, "remaining_energy": 0.0, "remaining_budget": 0.0,
-            "initial_time": 10.0, "initial_energy": 12.0, "initial_budget": 60.0,
-            "system_health": 0.0, "steps_used": 10, "max_steps": 10,
-        }
-        for diff in ["easy", "medium", "hard"]:
-            s = grade(diff, worst)
-            assert s == 0.0, f"{diff}: {s}"
-    def test_deterministic(self):
-        result = self._result()
-        s1 = grade("medium", result)
-        s2 = grade("medium", result)
-        assert s1 == s2
-    def test_hard_collapse_penalty(self):
-        collapsed = self._result(system_health=0.1)
-        normal = self._result(system_health=0.8)
-        assert grade("hard", collapsed) < grade("hard", normal)
-class TestEnvironmentReset:
-    def test_reset_returns_observation(self, easy_env):
-        obs = easy_env.reset(seed=42)
-        assert isinstance(obs, AetherTaskFlowObservation)
-    def test_reset_provides_tasks(self, easy_env):
-        obs = easy_env.reset(seed=42)
-        assert len(obs.tasks) > 0
-    def test_reset_has_full_resources(self, easy_env):
-        obs = easy_env.reset(seed=42)
-        assert obs.time_remaining == 10
-        assert obs.energy_remaining > 0
-        assert obs.budget_remaining > 0
-    def test_reset_health_is_one(self, easy_env):
-        obs = easy_env.reset(seed=42)
-        assert obs.system_health == 1.0
-    def test_reset_not_done(self, easy_env):
-        obs = easy_env.reset(seed=42)
-        assert obs.done is False
-    def test_reset_is_reproducible(self, easy_env):
-        obs1 = easy_env.reset(seed=7)
-        obs2 = easy_env.reset(seed=7)
-        assert len(obs1.tasks) == len(obs2.tasks)
-        assert obs1.tasks[0]["task_id"] == obs2.tasks[0]["task_id"]
-    def test_reset_names_are_reproducible(self, easy_env):
-        obs1 = easy_env.reset(seed=42)
-        obs2 = easy_env.reset(seed=42)
-        assert [task["name"] for task in obs1.tasks] == [task["name"] for task in obs2.tasks]
-    def test_reset_episode_id_provided(self, easy_env):
-        obs = easy_env.reset(seed=1, episode_id="test-ep-001")
-        assert obs.episode_id == "test-ep-001"
-    def test_reset_generates_episode_id_if_missing(self, easy_env):
-        obs = easy_env.reset(seed=1)
-        assert obs.episode_id is not None
-        assert len(obs.episode_id) > 0
-class TestEnvironmentStep:
-    def test_execute_reduces_resources(self, easy_env):
-        obs = easy_env.reset(seed=42)
-        energy_before = obs.energy_remaining
-        task = obs.tasks[0]
-        action = AetherTaskFlowAction(action_type=ActionType.EXECUTE, task_id=task["task_id"])
-        obs2 = easy_env.step(action)
-        assert obs2.energy_remaining <= energy_before
-    def test_execute_valid_task_earns_positive_reward(self, easy_env):
-        obs = easy_env.reset(seed=42)
-        task = obs.tasks[0]
-        action = AetherTaskFlowAction(action_type=ActionType.EXECUTE, task_id=task["task_id"])
-        obs2 = easy_env.step(action)
-        # Positive action rewards are normalized into the upper half of [0, 1].
-        assert obs2.reward is not None
-        assert 0.5 < obs2.reward <= 1.0
-    def test_delegate_earns_positive_reward(self, easy_env):
-        obs = easy_env.reset(seed=42)
-        task = obs.tasks[0]
-        action = AetherTaskFlowAction(action_type=ActionType.DELEGATE, task_id=task["task_id"])
-        obs2 = easy_env.step(action)
-        assert obs2.reward is not None
-        assert 0.5 < obs2.reward <= 1.0
-    def test_defer_earns_negative_reward(self, easy_env):
-        obs = easy_env.reset(seed=42)
-        task = obs.tasks[0]
-        action = AetherTaskFlowAction(action_type=ActionType.DEFER, task_id=task["task_id"])
-        obs2 = easy_env.step(action)
-        assert obs2.reward is not None
-        assert 0.0 <= obs2.reward < 0.5
-    def test_optimize_returns_small_positive(self, easy_env):
-        obs = easy_env.reset(seed=42)
-        task = obs.tasks[0]
-        action = AetherTaskFlowAction(action_type=ActionType.OPTIMIZE, task_id=task["task_id"])
-        obs2 = easy_env.step(action)
-        assert 0.5 < obs2.reward < 0.55
-    def test_invalid_task_id_penalised(self, easy_env):
-        obs = easy_env.reset(seed=42)
-        action = AetherTaskFlowAction(action_type=ActionType.EXECUTE, task_id=9999)
-        obs2 = easy_env.step(action)
-        assert obs2.reward is not None
-        assert 0.0 <= obs2.reward < 0.5
-    def test_step_reward_is_normalized(self, easy_env):
-        obs = easy_env.reset(seed=42)
-        task = obs.tasks[0]
-        action = AetherTaskFlowAction(action_type=ActionType.EXECUTE, task_id=task["task_id"])
-        obs2 = easy_env.step(action)
-        assert 0.0 <= obs2.reward <= 1.0
-    def test_step_accepts_string_action(self, easy_env):
-        easy_env.reset(seed=42)
-        obs = easy_env.step("execute")
-        assert isinstance(obs, AetherTaskFlowObservation)
-        assert obs.last_action_type in {"execute", "defer", "delegate", "optimize"}
-    def test_step_safe_failure_returns_terminal_observation(self, easy_env):
-        easy_env.reset(seed=42)
-        obs = easy_env.step({"task_id": "not-an-int"})
-        assert obs.done is True
-        assert obs.reward == 0.0
-        assert "failed safely" in (obs.last_action_outcome or "").lower()
-    def test_last_action_feedback_populated(self, easy_env):
-        obs = easy_env.reset(seed=42)
-        task = obs.tasks[0]
-        action = AetherTaskFlowAction(action_type=ActionType.EXECUTE, task_id=task["task_id"])
-        obs2 = easy_env.step(action)
-        assert obs2.last_action_type == "execute"
-        assert obs2.last_action_task_id == task["task_id"]
-        assert obs2.last_action_outcome is not None
-    def test_step_after_done_returns_done(self, easy_env):
-        obs = easy_env.reset(seed=42)
-        # Exhaust all tasks
-        for _ in range(15):
-            if obs.done:
-                break
-            tasks = obs.tasks
-            if not tasks:
-                break
-            action = AetherTaskFlowAction(
-                action_type=ActionType.EXECUTE,
-                task_id=tasks[0]["task_id"]
-            )
-            obs = easy_env.step(action)
-        # Extra step after done should return done
-        if obs.done:
-            action = AetherTaskFlowAction(action_type=ActionType.EXECUTE, task_id=0)
-            obs2 = easy_env.step(action)
-            assert obs2.done is True
-    def test_defer_is_visible_in_state(self, easy_env):
-        obs = easy_env.reset(seed=42)
-        task = obs.tasks[0]
-        easy_env.state.resources["energy"] = 0.0
-        easy_env.state.resources["budget"] = 0.0
-        easy_env.step(
-            AetherTaskFlowAction(action_type=ActionType.DEFER, task_id=task["task_id"])
-        )
-        assert len(easy_env.state.deferred_tasks) == 1
-class TestFullEpisode:
-    def _run_episode(self, difficulty: str, seed: int = 42) -> dict:
-        env = AetherTaskFlowEnvironment(difficulty=difficulty)
-        obs = env.reset(seed=seed)
-        rewards = []
-        steps = 0
-        while not obs.done and steps < 15:
-            tasks = obs.tasks
-            if not tasks:
-                break
-            task = tasks[0]
-            action = AetherTaskFlowAction(
-                action_type=ActionType.EXECUTE,
-                task_id=task["task_id"],
-            )
-            obs = env.step(action)
-            rewards.append(obs.reward or 0)
-            steps += 1
-        score = env.compute_final_score()
-        return {"score": score, "steps": steps, "rewards": rewards}
-    def test_easy_episode_completes(self):
-        result = self._run_episode("easy")
-        assert result["score"] >= 0.0
-        assert result["steps"] > 0
-    def test_medium_episode_completes(self):
-        result = self._run_episode("medium")
-        assert result["score"] >= 0.0
-    def test_hard_episode_completes(self):
-        result = self._run_episode("hard")
-        assert result["score"] >= 0.0
-    def test_score_in_range_all_difficulties(self):
-        for diff in ["easy", "medium", "hard"]:
-            result = self._run_episode(diff)
-            assert 0.0 <= result["score"] <= 1.0, f"{diff}: {result['score']}"
-    def test_rewards_in_range_all_difficulties(self):
-        for diff in ["easy", "medium", "hard"]:
-            result = self._run_episode(diff)
-            assert all(0.0 <= reward <= 1.0 for reward in result["rewards"]), (
-                f"{diff}: {result['rewards']}"
-            )
-    def test_easy_score_higher_than_hard(self):
-        easy = self._run_episode("easy")
-        hard = self._run_episode("hard")
-        # Easy should generally score higher than hard with naive agent
-        assert easy["score"] >= hard["score"]
-class TestStateProperty:
-    def test_state_is_aether_state(self, easy_env):
-        easy_env.reset(seed=42)
-        state = easy_env.state
-        assert isinstance(state, AetherTaskFlowState)
-    def test_state_tracks_steps(self, easy_env):
-        obs = easy_env.reset(seed=42)
-        assert easy_env.state.step_count == 0
-        task = obs.tasks[0]
-        action = AetherTaskFlowAction(action_type=ActionType.EXECUTE, task_id=task["task_id"])
-        easy_env.step(action)
-        assert easy_env.state.step_count == 1
-    def test_state_tracks_completions(self, easy_env):
-        obs = easy_env.reset(seed=42)
-        assert easy_env.state.tasks_completed == 0
-        task = obs.tasks[0]
-        action = AetherTaskFlowAction(action_type=ActionType.DELEGATE, task_id=task["task_id"])
-        easy_env.step(action)
-        assert easy_env.state.tasks_completed == 1
-    def test_state_difficulty_matches_env(self):
-        for diff in ["easy", "medium", "hard"]:
-            env = AetherTaskFlowEnvironment(difficulty=diff)
-            env.reset(seed=1)
-            assert env.state.difficulty == diff
-    def test_debug_snapshot_is_readable(self, easy_env):
-        easy_env.reset(seed=42)
-        snapshot = easy_env._get_obs()
-        assert snapshot["num_tasks"] > 0
-        assert "resources" in snapshot
-        assert "system_health" in snapshot
-class TestOpenEnvCompliance:
-    def test_observation_is_pydantic_model(self, easy_env):
-        obs = easy_env.reset(seed=1)
-        assert hasattr(obs, "model_dump")
-        d = obs.model_dump()
-        assert isinstance(d, dict)
-    def test_observation_has_done_field(self, easy_env):
-        obs = easy_env.reset(seed=1)
-        assert hasattr(obs, "done")
-        assert isinstance(obs.done, bool)
-    def test_observation_has_reward_field(self, easy_env):
-        obs = easy_env.reset(seed=1)
-        assert hasattr(obs, "reward")
-    def test_state_has_episode_id(self, easy_env):
-        easy_env.reset(seed=1, episode_id="abc-123")
-        assert easy_env.state.episode_id == "abc-123"
-    def test_state_has_step_count(self, easy_env):
-        easy_env.reset(seed=1)
-        assert hasattr(easy_env.state, "step_count")
-    def test_invalid_difficulty_raises(self):
-        with pytest.raises(ValueError):
-            AetherTaskFlowEnvironment(difficulty="impossible")
-    def test_action_coerces_freeform_action_type(self):
-        action = AetherTaskFlowAction(action_type="hi", task_id=0)
-        assert action.action_type == ActionType.EXECUTE
-        assert action.task_id == 0
-    def test_action_extracts_task_id_from_freeform_text(self):
-        action = AetherTaskFlowAction(action_type="delegate task 3")
-        assert action.action_type == ActionType.DELEGATE
-        assert action.task_id == 3
-    def test_action_accepts_message_payload_shape(self):
-        action = AetherTaskFlowAction.model_validate({"message": "optimize 2"})
-        assert action.action_type == ActionType.OPTIMIZE
-        assert action.task_id == 2
-class TestPersistentServerRoutes:
-    def test_reset_step_state_share_same_session(self, api_client):
-        reset_response = api_client.post("/reset", json={"seed": 42})
-        assert reset_response.status_code == 200
-        reset_payload = reset_response.json()
-        first_task_id = reset_payload["observation"]["tasks"][0]["task_id"]
-        episode_id = reset_payload["observation"]["episode_id"]
-        step_response = api_client.post(
-            "/step",
-            json={"action": {"action_type": "execute", "task_id": first_task_id}},
-        )
-        assert step_response.status_code == 200
-        state_response = api_client.get("/state")
-        assert state_response.status_code == 200
-        state_payload = state_response.json()
-        assert state_payload["episode_id"] == episode_id
-        assert state_payload["step_count"] == 1
-    def test_step_accepts_message_payload(self, api_client):
-        api_client.post("/reset", json={"seed": 42})
-        response = api_client.post("/step", json={"message": "execute"})
-        assert response.status_code == 200
-        payload = response.json()
-        assert payload["observation"]["last_action_type"] in {
-            "execute",
-            "defer",
-            "delegate",
-            "optimize",
-        }

aether-taskflow/uv.lock DELETED Viewed

The diff for this file is too large to render. See raw diff

aether-taskflow/validation-su DELETED Viewed

File without changes

aether-taskflow/validation-submission.sh DELETED Viewed

@@ -1,185 +0,0 @@
-#!/usr/bin/env bash
-#
-# validate-submission.sh — OpenEnv Submission Validator
-#
-# Checks that your HF Space is live, Docker image builds, and openenv validate passes.
-#
-# Prerequisites:
-#   - Docker:       https://docs.docker.com/get-docker/
-#   - openenv-core: pip install openenv-core
-#   - curl (usually pre-installed)
-#
-# Run:
-#   curl -fsSL https://raw.githubusercontent.com/<owner>/<repo>/main/scripts/validate-submission.sh | bash -s -- <ping_url> [repo_dir]
-#
-#   Or download and run locally:
-#     chmod +x validate-submission.sh
-#     ./validate-submission.sh <ping_url> [repo_dir]
-#
-# Arguments:
-#   ping_url   Your HuggingFace Space URL (e.g. https://your-space.hf.space)
-#   repo_dir   Path to your repo (default: current directory)
-#
-# Examples:
-#   ./validate-submission.sh https://my-team.hf.space
-#   ./validate-submission.sh https://my-team.hf.space ./my-repo
-#
-set -uo pipefail
-DOCKER_BUILD_TIMEOUT=600
-if [ -t 1 ]; then
-  RED='\033[0;31m'
-  GREEN='\033[0;32m'
-  YELLOW='\033[1;33m'
-  BOLD='\033[1m'
-  NC='\033[0m'
-else
-  RED='' GREEN='' YELLOW='' BOLD='' NC=''
-fi
-run_with_timeout() {
-  local secs="$1"; shift
-  if command -v timeout &>/dev/null; then
-    timeout "$secs" "$@"
-  elif command -v gtimeout &>/dev/null; then
-    gtimeout "$secs" "$@"
-  else
-    "$@" &
-    local pid=$!
-    ( sleep "$secs" && kill "$pid" 2>/dev/null ) &
-    local watcher=$!
-    wait "$pid" 2>/dev/null
-    local rc=$?
-    kill "$watcher" 2>/dev/null
-    wait "$watcher" 2>/dev/null
-    return $rc
-  fi
-}
-portable_mktemp() {
-  local prefix="${1:-validate}"
-  mktemp "${TMPDIR:-/tmp}/${prefix}-XXXXXX" 2>/dev/null || mktemp
-}
-CLEANUP_FILES=()
-cleanup() { rm -f "${CLEANUP_FILES[@]+"${CLEANUP_FILES[@]}"}"; }
-trap cleanup EXIT
-PING_URL="${1:-}"
-REPO_DIR="${2:-.}"
-if [ -z "$PING_URL" ]; then
-  printf "Usage: %s <ping_url> [repo_dir]\n" "$0"
-  printf "\n"
-  printf "  ping_url   Your HuggingFace Space URL (e.g. https://your-space.hf.space)\n"
-  printf "  repo_dir   Path to your repo (default: current directory)\n"
-  exit 1
-fi
-if ! REPO_DIR="$(cd "$REPO_DIR" 2>/dev/null && pwd)"; then
-  printf "Error: directory '%s' not found\n" "${2:-.}"
-  exit 1
-fi
-PING_URL="${PING_URL%/}"
-export PING_URL
-PASS=0
-log()  { printf "[%s] %b\n" "$(date -u +%H:%M:%S)" "$*"; }
-pass() { log "${GREEN}PASSED${NC} -- $1"; PASS=$((PASS + 1)); }
-fail() { log "${RED}FAILED${NC} -- $1"; }
-hint() { printf "  ${YELLOW}Hint:${NC} %b\n" "$1"; }
-stop_at() {
-  printf "\n"
-  printf "${RED}${BOLD}Validation stopped at %s.${NC} Fix the above before continuing.\n" "$1"
-  exit 1
-}
-printf "\n"
-printf "${BOLD}========================================${NC}\n"
-printf "${BOLD}  OpenEnv Submission Validator${NC}\n"
-printf "${BOLD}========================================${NC}\n"
-log "Repo:     $REPO_DIR"
-log "Ping URL: $PING_URL"
-printf "\n"
-log "${BOLD}Step 1/3: Pinging HF Space${NC} ($PING_URL/reset) ..."
-CURL_OUTPUT=$(portable_mktemp "validate-curl")
-CLEANUP_FILES+=("$CURL_OUTPUT")
-HTTP_CODE=$(curl -s -o "$CURL_OUTPUT" -w "%{http_code}" -X POST \
-  -H "Content-Type: application/json" -d '{}' \
-  "$PING_URL/reset" --max-time 30 2>"$CURL_OUTPUT" || printf "000")
-if [ "$HTTP_CODE" = "200" ]; then
-  pass "HF Space is live and responds to /reset"
-elif [ "$HTTP_CODE" = "000" ]; then
-  fail "HF Space not reachable (connection failed or timed out)"
-  hint "Check your network connection and that the Space is running."
-  hint "Try: curl -s -o /dev/null -w '%%{http_code}' -X POST $PING_URL/reset"
-  stop_at "Step 1"
-else
-  fail "HF Space /reset returned HTTP $HTTP_CODE (expected 200)"
-  hint "Make sure your Space is running and the URL is correct."
-  hint "Try opening $PING_URL in your browser first."
-  stop_at "Step 1"
-fi
-log "${BOLD}Step 2/3: Running docker build${NC} ..."
-if ! command -v docker &>/dev/null; then
-  fail "docker command not found"
-  hint "Install Docker: https://docs.docker.com/get-docker/"
-  stop_at "Step 2"
-fi
-if [ -f "$REPO_DIR/Dockerfile" ]; then
-  DOCKER_CONTEXT="$REPO_DIR"
-elif [ -f "$REPO_DIR/server/Dockerfile" ]; then
-  DOCKER_CONTEXT="$REPO_DIR/server"
-else
-  fail "No Dockerfile found in repo root or server/ directory"
-  stop_at "Step 2"
-fi
-log "  Found Dockerfile in $DOCKER_CONTEXT"
-BUILD_OK=false
-BUILD_OUTPUT=$(run_with_timeout "$DOCKER_BUILD_TIMEOUT" docker build "$DOCKER_CONTEXT" 2>&1) && BUILD_OK=true
-if [ "$BUILD_OK" = true ]; then
-  pass "Docker build succeeded"
-else
-  fail "Docker build failed (timeout=${DOCKER_BUILD_TIMEOUT}s)"
-  printf "%s\n" "$BUILD_OUTPUT" | tail -20
-  stop_at "Step 2"
-fi
-log "${BOLD}Step 3/3: Running openenv validate${NC} ..."
-if ! command -v openenv &>/dev/null; then
-  fail "openenv command not found"
-  hint "Install it: pip install openenv-core"
-  stop_at "Step 3"
-fi
-VALIDATE_OK=false
-VALIDATE_OUTPUT=$(cd "$REPO_DIR" && openenv validate 2>&1) && VALIDATE_OK=true
-if [ "$VALIDATE_OK" = true ]; then
-  pass "openenv validate passed"
-  [ -n "$VALIDATE_OUTPUT" ] && log "  $VALIDATE_OUTPUT"
-else
-  fail "openenv validate failed"
-  printf "%s\n" "$VALIDATE_OUTPUT"
-  stop_at "Step 3"
-fi
-printf "\n"
-printf "${BOLD}========================================${NC}\n"
-printf "${GREEN}${BOLD}  All 3/3 checks passed!${NC}\n"
-printf "${GREEN}${BOLD}  Your submission is ready to submit.${NC}\n"
-printf "${BOLD}========================================${NC}\n"
-printf "\n"
-exit 0