Spaces:
Running
Running
Deploy Aureon OS (deploy/selfhost stack: nginx edge + fusion API x2 + console + HNC organ + redis + postgres; paper mode) (part 20)
8495bb8 verified | #!/usr/bin/env python3 | |
| """ | |
| AUREON HYPER TEST — 10× EXPANDED ULTIMATE | |
| ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ | |
| The ultimate stress test, expanded by a factor of 10 across every axis: | |
| LLM capabilities 10 → 100 (10 families × 10 variants each) | |
| Parallel agents 4 → 40 | |
| VM sessions 10 → 100 | |
| Library chain depth 500 → 5000 | |
| Swarm scouts 8 → 80 | |
| Motion snapshots 800 → 8000 | |
| Pillar alignment 5000 → 50000 | |
| Tool registry ops 10000 → 100000 | |
| VM dispatch 10000 → 100000 | |
| Soak workers 4 → 40 | |
| Total test runs 26 → 26 scaled + this hyper test | |
| The hyper test itself authors 100 unique LLM capability skills across | |
| 10 families, validates every one, exercises every one, and runs a | |
| 40-agent parallel swarm. | |
| Family Variants | |
| ────────────────────────────────────────── | |
| prompt 10 variants | |
| reasoning 10 variants (chain depths 1-10) | |
| planning 10 variants | |
| reflection 10 variants | |
| tool_use 10 variants (one per primitive) | |
| code_gen 10 variants | |
| recovery 10 variants | |
| delegation 10 variants | |
| memory 10 variants | |
| meta 10 variants | |
| Usage: | |
| python tests/hyper/expanded_ultimate.py | |
| python tests/hyper/expanded_ultimate.py --families 1,2,3 # subset | |
| """ | |
| from __future__ import annotations | |
| import argparse | |
| import logging | |
| import os | |
| import sys | |
| import tempfile | |
| import shutil | |
| import threading | |
| import time | |
| from concurrent.futures import ThreadPoolExecutor, as_completed | |
| from dataclasses import dataclass, field | |
| from pathlib import Path | |
| from typing import Any, Callable, Dict, List, Tuple | |
| REPO_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..")) | |
| if REPO_ROOT not in sys.path: | |
| sys.path.insert(0, REPO_ROOT) | |
| logging.basicConfig(level=logging.ERROR, format="%(levelname)s %(name)s %(message)s") | |
| from aureon.autonomous.vm_control import VMControlDispatcher | |
| from aureon.code_architect import ( | |
| CodeArchitect, | |
| SkillLibrary, | |
| SkillLevel, | |
| SkillProposal, | |
| SkillStatus, | |
| ) | |
| # ───────────────────────────────────────────────────────────────────────────── | |
| # Reporting | |
| # ───────────────────────────────────────────────────────────────────────────── | |
| BANNER_WIDTH = 96 | |
| def banner(text: str, fill: str = "═") -> None: | |
| print() | |
| print(fill * BANNER_WIDTH) | |
| print(f" {text}") | |
| print(fill * BANNER_WIDTH) | |
| def info(text: str) -> None: | |
| print(f" {text}") | |
| def ok(text: str) -> None: | |
| print(f" [OK] {text}") | |
| def err(text: str) -> None: | |
| print(f" [!!] {text}") | |
| def progress(text: str) -> None: | |
| print(f" -> {text}") | |
| # ───────────────────────────────────────────────────────────────────────────── | |
| # Capability source generators (one per family) | |
| # ───────────────────────────────────────────────────────────────────────────── | |
| def _name(family: str, variant: str) -> str: | |
| return f"{family}_{variant}" | |
| def gen_prompt_family() -> List[Tuple[str, str, SkillLevel, List[str], str]]: | |
| """10 prompt variants: different token budgets and styles.""" | |
| variants = [ | |
| ("default", 400, "You are a helpful reasoning engine."), | |
| ("short", 100, "Be concise. One sentence max."), | |
| ("long", 800, "Be thorough and detailed."), | |
| ("structured", 400, "Return structured JSON-like output."), | |
| ("code", 600, "Focus on code. Produce runnable snippets."), | |
| ("creative", 500, "Think creatively. Offer novel angles."), | |
| ("technical", 600, "Be technically precise."), | |
| ("terse", 80, "One-word answer if possible."), | |
| ("verbose", 1000, "Explain every detail."), | |
| ("json", 400, "Respond in strict JSON only."), | |
| ] | |
| out = [] | |
| for name, max_toks, style in variants: | |
| full = _name("prompt", name) | |
| code = f''' | |
| def {full}(query="", context=None, **kwargs): | |
| """Prompt variant: {name} (max_tokens={max_toks})""" | |
| emit_event("cap.{full}", {{"q": str(query)[:80]}}) | |
| result = ai_reason( | |
| "{style} " + str(query), | |
| context=context, | |
| max_tokens={max_toks}, | |
| ) | |
| return {{ | |
| "ok": result.get("ok", False), | |
| "text": result.get("text", ""), | |
| "variant": "{name}", | |
| "max_tokens": {max_toks}, | |
| }} | |
| ''' | |
| out.append((full, code, SkillLevel.TASK, [], f"Prompt variant {name}")) | |
| return out | |
| def gen_reasoning_family() -> List[Tuple[str, str, SkillLevel, List[str], str]]: | |
| """10 reasoning variants: chain depths 1..10.""" | |
| out = [] | |
| for depth in range(1, 11): | |
| full = _name("reason", f"chain_{depth}") | |
| code = f''' | |
| def {full}(query="", **kwargs): | |
| """{depth}-step chain of thought""" | |
| chain = [] | |
| prior = "" | |
| i = 0 | |
| while i < {depth}: | |
| r = ai_reason( | |
| "Step " + str(i + 1) + " of {depth}: " + str(query), | |
| context={{"step": i + 1, "prior": str(prior)[:300]}}, | |
| max_tokens=200, | |
| ) | |
| chain.append(r) | |
| prior = str(prior) + " | " + str(r.get("text", ""))[:150] | |
| i = i + 1 | |
| return {{ | |
| "ok": all(c.get("ok", False) for c in chain), | |
| "depth": {depth}, | |
| "steps": len(chain), | |
| "final_answer": str(prior)[:600], | |
| }} | |
| ''' | |
| out.append((full, code, SkillLevel.WORKFLOW, [], f"Reasoning depth {depth}")) | |
| return out | |
| def gen_planning_family() -> List[Tuple[str, str, SkillLevel, List[str], str]]: | |
| """10 planning variants: different decomposition strategies.""" | |
| variants = [ | |
| ("short", 3), ("medium", 5), ("long", 8), | |
| ("deep", 10), ("wide", 5), ("sequential", 5), | |
| ("parallel", 5), ("milestones", 4), ("phases", 5), | |
| ("sprint", 6), | |
| ] | |
| out = [] | |
| for name, n_steps in variants: | |
| full = _name("plan", name) | |
| # Use "\\n" in the template so the generated source gets a literal | |
| # backslash-n (which Python parses as a newline char at compile time). | |
| code = f''' | |
| def {full}(goal="", **kwargs): | |
| """Planning variant: {name} ({n_steps} steps)""" | |
| emit_event("cap.{full}", {{"goal": str(goal)[:80]}}) | |
| r = ai_reason( | |
| "Decompose this goal into {n_steps} ordered steps: " + str(goal), | |
| context={{"variant": "{name}", "n_steps": {n_steps}}}, | |
| max_tokens=500, | |
| ) | |
| text = r.get("text", "") or "" | |
| lines = [ln.strip() for ln in text.split("\\n") if ln.strip()] | |
| sub_goals = lines[:{n_steps}] if lines else ["Analyse", "Act", "Verify"] | |
| return {{ | |
| "ok": r.get("ok", False), | |
| "variant": "{name}", | |
| "goal": goal, | |
| "sub_goals": sub_goals, | |
| "count": len(sub_goals), | |
| }} | |
| ''' | |
| out.append((full, code, SkillLevel.TASK, [], f"Planning variant {name}")) | |
| return out | |
| def gen_reflection_family() -> List[Tuple[str, str, SkillLevel, List[str], str]]: | |
| """10 reflection variants.""" | |
| variants = ["reflect", "critique", "affirm", "retrospect", "prospect", | |
| "introspect", "evaluate", "assess", "review", "meta"] | |
| out = [] | |
| for i, name in enumerate(variants): | |
| full = _name("reflection", name) | |
| code = f''' | |
| def {full}(subject="", last_result=None, **kwargs): | |
| """Reflection variant: {name}""" | |
| query = "{name.capitalize()} on: " + str(subject) + ". Prior: " + str(last_result)[:300] | |
| r = consult_queen(query, context={{"variant": "{name}"}}) | |
| return {{ | |
| "ok": r.get("ok", False), | |
| "variant": "{name}", | |
| "text": r.get("text", "")[:400], | |
| }} | |
| ''' | |
| out.append((full, code, SkillLevel.TASK, [], f"Reflection variant {name}")) | |
| return out | |
| def gen_tool_use_family() -> List[Tuple[str, str, SkillLevel, List[str], str]]: | |
| """10 tool-use variants — one for each VM primitive category.""" | |
| tools = [ | |
| ("screenshot", "vm_screenshot", "{}"), | |
| ("click", "vm_left_click", '{"x": 500, "y": 300}'), | |
| ("type", "vm_type_text", '{"text": "hello"}'), | |
| ("key", "vm_press_key", '{"key": "enter"}'), | |
| ("hotkey", "vm_hotkey", '{"keys": ["ctrl", "c"]}'), | |
| ("scroll", "vm_scroll", '{"x": 500, "y": 300, "direction": "down"}'), | |
| ("focus", "vm_focus_window", '{"title": "Desktop"}'), | |
| ("list_windows", "vm_list_windows", "{}"), | |
| ("shell", "vm_execute_shell", '{"command": "whoami"}'), | |
| ("powershell", "vm_execute_powershell", '{"command": "Get-Process"}'), | |
| ] | |
| out = [] | |
| for name, primitive, args_literal in tools: | |
| full = _name("tool", name) | |
| code = f''' | |
| def {full}(**kwargs): | |
| """Tool use variant: {name} ({primitive})""" | |
| result = {primitive}(**{args_literal}) | |
| return {{ | |
| "ok": result.get("ok", False), | |
| "tool": "{primitive}", | |
| "variant": "{name}", | |
| "data": result.get("data", {{}}), | |
| }} | |
| ''' | |
| out.append((full, code, SkillLevel.TASK, [], f"Tool use {name}")) | |
| return out | |
| def gen_code_gen_family() -> List[Tuple[str, str, SkillLevel, List[str], str]]: | |
| """10 code-generation variants.""" | |
| variants = [ | |
| ("function", "a simple function"), | |
| ("class", "a class"), | |
| ("test", "a unit test"), | |
| ("refactor", "refactor code"), | |
| ("debug", "debug a snippet"), | |
| ("document", "add documentation"), | |
| ("explain", "explain a snippet"), | |
| ("review", "review code quality"), | |
| ("optimize", "optimise performance"), | |
| ("type", "add type hints"), | |
| ] | |
| out = [] | |
| for name, style in variants: | |
| full = _name("code", name) | |
| code = f''' | |
| def {full}(spec="", **kwargs): | |
| """Code gen variant: {name} ({style})""" | |
| r = ai_reason( | |
| "Write Python to {style}: " + str(spec), | |
| context={{"variant": "{name}", "style": "{style}"}}, | |
| max_tokens=600, | |
| ) | |
| return {{ | |
| "ok": r.get("ok", False), | |
| "variant": "{name}", | |
| "draft": str(r.get("text", ""))[:500], | |
| }} | |
| ''' | |
| out.append((full, code, SkillLevel.TASK, [], f"Code gen {name}")) | |
| return out | |
| def gen_recovery_family() -> List[Tuple[str, str, SkillLevel, List[str], str]]: | |
| """10 recovery variants.""" | |
| variants = ["retry", "rollback", "fallback", "escalate", "alert", | |
| "circuit_break", "degrade", "restart", "heal", "reroute"] | |
| out = [] | |
| for name in variants: | |
| full = _name("recovery", name) | |
| code = f''' | |
| def {full}(failed_skill="", last_error="", **kwargs): | |
| """Recovery variant: {name}""" | |
| r = consult_queen( | |
| "Recovery strategy '{name}' for skill " + str(failed_skill) + ": " + str(last_error), | |
| context={{"variant": "{name}", "failed": failed_skill}}, | |
| ) | |
| return {{ | |
| "ok": r.get("ok", False), | |
| "variant": "{name}", | |
| "plan": r.get("text", "")[:400], | |
| }} | |
| ''' | |
| out.append((full, code, SkillLevel.TASK, [], f"Recovery {name}")) | |
| return out | |
| def gen_delegation_family() -> List[Tuple[str, str, SkillLevel, List[str], str]]: | |
| """10 delegation variants.""" | |
| variants = ["direct", "best_match", "random", "weighted", "chain", | |
| "parallel", "sequential", "race", "consensus", "vote"] | |
| out = [] | |
| for name in variants: | |
| full = _name("delegate", name) | |
| code = f''' | |
| def {full}(skill_name="", **kwargs): | |
| """Delegation variant: {name}""" | |
| available = list_skills() | |
| if not available.get("ok", False): | |
| return {{"ok": False, "variant": "{name}", "error": "no_skills"}} | |
| names = available.get("skills", []) | |
| if skill_name and skill_name in names: | |
| result = call_skill(str(skill_name)) | |
| return {{ | |
| "ok": result.get("ok", False), | |
| "variant": "{name}", | |
| "delegated_to": skill_name, | |
| }} | |
| return {{ | |
| "ok": True, | |
| "variant": "{name}", | |
| "library_size": len(names), | |
| }} | |
| ''' | |
| out.append((full, code, SkillLevel.TASK, [], f"Delegation {name}")) | |
| return out | |
| def gen_memory_family() -> List[Tuple[str, str, SkillLevel, List[str], str]]: | |
| """10 memory variants.""" | |
| variants = ["remember_fact", "recall_fact", "list_facts", "index_facts", | |
| "search_facts", "summarise", "compress", "expand", | |
| "prune", "audit"] | |
| out = [] | |
| for name in variants: | |
| full = _name("memory", name) | |
| code = f''' | |
| def {full}(target="", key="fact", value="", **kwargs): | |
| """Memory variant: {name}""" | |
| if "remember" in "{name}" or "index" in "{name}": | |
| r = remember(str(target) or "memory_family", str(key), str(value)) | |
| return {{"ok": r.get("ok", False), "variant": "{name}", "op": "write"}} | |
| if "recall" in "{name}" or "search" in "{name}": | |
| r = recall(str(target) or "memory_family", str(key)) | |
| return {{"ok": r.get("ok", False), "variant": "{name}", "op": "read"}} | |
| available = list_skills() | |
| return {{ | |
| "ok": available.get("ok", False), | |
| "variant": "{name}", | |
| "op": "enumerate", | |
| "count": available.get("count", 0), | |
| }} | |
| ''' | |
| out.append((full, code, SkillLevel.TASK, [], f"Memory {name}")) | |
| return out | |
| def gen_meta_family() -> List[Tuple[str, str, SkillLevel, List[str], str]]: | |
| """10 meta-cognitive variants.""" | |
| variants = ["improve", "learn", "compose", "decompose", "abstract", | |
| "instantiate", "audit", "reflect", "plan", "execute"] | |
| out = [] | |
| for name in variants: | |
| full = _name("meta", name) | |
| code = f''' | |
| def {full}(target="", **kwargs): | |
| """Meta variant: {name}""" | |
| emit_event("cap.meta.{name}", {{"target": str(target)[:80]}}) | |
| r = consult_queen( | |
| "Meta operation '{name}' on target: " + str(target), | |
| context={{"variant": "{name}"}}, | |
| ) | |
| available = list_skills() | |
| return {{ | |
| "ok": r.get("ok", False), | |
| "variant": "{name}", | |
| "insight": r.get("text", "")[:300], | |
| "library_size": available.get("count", 0), | |
| }} | |
| ''' | |
| out.append((full, code, SkillLevel.ROLE, [], f"Meta {name}")) | |
| return out | |
| FAMILIES: Dict[str, Callable[[], List[Tuple[str, str, SkillLevel, List[str], str]]]] = { | |
| "prompt": gen_prompt_family, | |
| "reasoning": gen_reasoning_family, | |
| "planning": gen_planning_family, | |
| "reflection": gen_reflection_family, | |
| "tool_use": gen_tool_use_family, | |
| "code_gen": gen_code_gen_family, | |
| "recovery": gen_recovery_family, | |
| "delegation": gen_delegation_family, | |
| "memory": gen_memory_family, | |
| "meta": gen_meta_family, | |
| } | |
| # ───────────────────────────────────────────────────────────────────────────── | |
| # Harness | |
| # ───────────────────────────────────────────────────────────────────────────── | |
| class HyperHarness: | |
| tmp: Path | |
| dispatcher: VMControlDispatcher = field(default=None) | |
| lib: SkillLibrary = field(default=None) | |
| architect: CodeArchitect = field(default=None) | |
| authored: List[str] = field(default_factory=list) | |
| blocked: List[Tuple[str, str]] = field(default_factory=list) | |
| def build(cls) -> "HyperHarness": | |
| tmp = Path(tempfile.mkdtemp(prefix="aureon_hyper_")) | |
| h = cls(tmp=tmp) | |
| h.dispatcher = VMControlDispatcher() | |
| sid = h.dispatcher.create_session(backend="simulated", name="hyper-vm", make_default=True) | |
| h.dispatcher.get_session(sid).arm(dry_run=False) | |
| h.lib = SkillLibrary(storage_dir=h.tmp) | |
| h.architect = CodeArchitect(library=h.lib, dispatcher=h.dispatcher) | |
| return h | |
| def teardown(self) -> None: | |
| try: | |
| self.dispatcher.destroy_all() | |
| except Exception: | |
| pass | |
| shutil.rmtree(self.tmp, ignore_errors=True) | |
| # ───────────────────────────────────────────────────────────────────────────── | |
| # Phases | |
| # ───────────────────────────────────────────────────────────────────────────── | |
| def phase_bootstrap(h: HyperHarness) -> Dict[str, Any]: | |
| banner("HYPER PHASE 1 — Bootstrap L0 atomics") | |
| atomics = h.architect.bootstrap_atomics() | |
| info(f"Seeded {len(atomics)} atomic skills") | |
| return {"phase": 1, "atomics": len(atomics), "ok": len(atomics) >= 15} | |
| def phase_author_100(h: HyperHarness, families_filter: List[str] = None) -> Dict[str, Any]: | |
| banner("HYPER PHASE 2 — Author 100 LLM capability skills (10 families × 10 variants)") | |
| total_authored = 0 | |
| total_blocked = 0 | |
| per_family: Dict[str, Dict[str, int]] = {} | |
| target_families = families_filter or list(FAMILIES.keys()) | |
| for family_name in target_families: | |
| generator = FAMILIES.get(family_name) | |
| if not generator: | |
| continue | |
| specs = generator() | |
| fam_ok = 0 | |
| fam_fail = 0 | |
| for full_name, code, level, deps, desc in specs: | |
| proposal = SkillProposal( | |
| name=full_name, | |
| description=desc, | |
| level=level, | |
| category=f"hyper_{family_name}", | |
| code=code.strip(), | |
| entry_function=full_name, | |
| params_schema={"type": "object", "properties": {}}, | |
| dependencies=deps, | |
| reasoning=f"Hyper test {family_name} variant", | |
| target="either", | |
| ) | |
| skill = h.architect._store_if_valid(proposal) | |
| if skill is None or skill.status == SkillStatus.BLOCKED: | |
| stored = h.lib.get(full_name) | |
| err_msg = stored.last_error if stored else "unknown" | |
| h.blocked.append((full_name, err_msg)) | |
| fam_fail += 1 | |
| total_blocked += 1 | |
| else: | |
| h.authored.append(full_name) | |
| fam_ok += 1 | |
| total_authored += 1 | |
| per_family[family_name] = {"ok": fam_ok, "fail": fam_fail} | |
| status = "OK" if fam_fail == 0 else "PARTIAL" | |
| info(f"{status:8s} {family_name:12s} {fam_ok}/{fam_ok + fam_fail} authored") | |
| # Show blocked details (if any) | |
| if h.blocked: | |
| print() | |
| info("Blocked skills:") | |
| for name, error in h.blocked[:10]: | |
| info(f" {name}: {error[:80]}") | |
| if len(h.blocked) > 10: | |
| info(f" ... and {len(h.blocked) - 10} more") | |
| expected = len(target_families) * 10 | |
| return { | |
| "phase": 2, | |
| "total_authored": total_authored, | |
| "total_blocked": total_blocked, | |
| "expected": expected, | |
| "per_family": per_family, | |
| "ok": total_authored == expected, | |
| } | |
| def phase_exercise_100(h: HyperHarness) -> Dict[str, Any]: | |
| banner("HYPER PHASE 3 — Exercise all 100 authored capabilities") | |
| test_params = { | |
| "prompt": {"query": "What is coherence?"}, | |
| "reason": {"query": "Should we deploy?"}, | |
| "plan": {"goal": "Ship a new feature"}, | |
| "reflection": {"subject": "today", "last_result": "mixed"}, | |
| "tool": {}, | |
| "code": {"spec": "add two numbers"}, | |
| "recovery": {"failed_skill": "deploy", "last_error": "timeout"}, | |
| "delegate": {"skill_name": "screenshot"}, | |
| "memory": {"target": "test", "key": "k", "value": "v"}, | |
| "meta": {"target": "prompt_default"}, | |
| } | |
| successes = 0 | |
| failures = 0 | |
| per_family: Dict[str, Dict[str, int]] = {} | |
| for name in h.authored: | |
| family = name.split("_")[0] | |
| params = test_params.get(family, {}) | |
| r = h.architect.execute_skill(name, params=params) | |
| inner = r.return_value if isinstance(r.return_value, dict) else {} | |
| inner_ok = bool(r.ok and inner.get("ok", False)) | |
| per_family.setdefault(family, {"ok": 0, "fail": 0}) | |
| if inner_ok: | |
| successes += 1 | |
| per_family[family]["ok"] += 1 | |
| else: | |
| failures += 1 | |
| per_family[family]["fail"] += 1 | |
| # Report | |
| for family, stats in sorted(per_family.items()): | |
| total = stats["ok"] + stats["fail"] | |
| marker = "OK" if stats["fail"] == 0 else "PARTIAL" | |
| info(f"{marker:8s} {family:12s} {stats['ok']}/{total} executed ok") | |
| return { | |
| "phase": 3, | |
| "total_executed": len(h.authored), | |
| "successes": successes, | |
| "failures": failures, | |
| "per_family": per_family, | |
| "ok": successes >= len(h.authored) * 0.95, # at least 95% should work | |
| } | |
| def phase_parallel_40(h: HyperHarness) -> Dict[str, Any]: | |
| banner("HYPER PHASE 4 — 40-agent parallel swarm") | |
| if not h.authored: | |
| return {"phase": 4, "ok": False, "error": "no_capabilities"} | |
| # Pick 40 distinct skill executions | |
| import random | |
| selected = random.sample(h.authored, min(40, len(h.authored))) | |
| successes = 0 | |
| failures = 0 | |
| durations: List[float] = [] | |
| lock = threading.Lock() | |
| def run_one(skill_name: str): | |
| nonlocal successes, failures | |
| family = skill_name.split("_")[0] | |
| params = { | |
| "prompt": {"query": "bench"}, | |
| "reason": {"query": "bench"}, | |
| "plan": {"goal": "bench"}, | |
| "reflection": {"subject": "bench", "last_result": "bench"}, | |
| "tool": {}, | |
| "code": {"spec": "bench"}, | |
| "recovery": {"failed_skill": "bench", "last_error": "bench"}, | |
| "delegate": {"skill_name": "screenshot"}, | |
| "memory": {"target": "bench", "key": "k", "value": "v"}, | |
| "meta": {"target": "bench"}, | |
| }.get(family, {}) | |
| t0 = time.time() | |
| r = h.architect.execute_skill(skill_name, params=params) | |
| dt = time.time() - t0 | |
| inner = r.return_value if isinstance(r.return_value, dict) else {} | |
| inner_ok = bool(r.ok and inner.get("ok", False)) | |
| with lock: | |
| if inner_ok: | |
| successes += 1 | |
| else: | |
| failures += 1 | |
| durations.append(dt) | |
| with ThreadPoolExecutor(max_workers=40) as ex: | |
| futures = [ex.submit(run_one, name) for name in selected] | |
| for f in as_completed(futures): | |
| pass | |
| p50 = sorted(durations)[len(durations) // 2] * 1000 if durations else 0 | |
| p99 = sorted(durations)[int(len(durations) * 0.99)] * 1000 if len(durations) > 1 else 0 | |
| info(f"40 parallel runs: successes={successes} failures={failures}") | |
| info(f" p50 latency: {p50:.2f} ms") | |
| info(f" p99 latency: {p99:.2f} ms") | |
| return { | |
| "phase": 4, | |
| "parallel_agents": 40, | |
| "successes": successes, | |
| "failures": failures, | |
| "p50_ms": round(p50, 2), | |
| "p99_ms": round(p99, 2), | |
| "ok": failures == 0, | |
| } | |
| def phase_compose_pipeline(h: HyperHarness) -> Dict[str, Any]: | |
| banner("HYPER PHASE 5 — Compose 10-step multi-family pipeline") | |
| # Compose one skill from each family into a 10-step workflow | |
| pipeline = [ | |
| ("prompt_default", {"query": "What is the market state?"}), | |
| ("reason_chain_3", {"query": "Is BTC bullish?"}), | |
| ("plan_medium", {"goal": "Ship new feature"}), | |
| ("reflection_reflect", {"subject": "plan", "last_result": "OK"}), | |
| ("tool_screenshot", {}), | |
| ("code_function", {"spec": "hash a string"}), | |
| ("recovery_retry", {"failed_skill": "step_5", "last_error": "timeout"}), | |
| ("delegate_direct", {"skill_name": "screenshot"}), | |
| ("memory_remember_fact", {"target": "pipeline", "key": "completed", "value": "true"}), | |
| ("meta_audit", {"target": "pipeline"}), | |
| ] | |
| results = [] | |
| all_ok = True | |
| for name, params in pipeline: | |
| if not h.lib.contains(name): | |
| results.append((name, False, "not_authored")) | |
| all_ok = False | |
| continue | |
| r = h.architect.execute_skill(name, params=params) | |
| inner = r.return_value if isinstance(r.return_value, dict) else {} | |
| inner_ok = bool(r.ok and inner.get("ok", False)) | |
| results.append((name, inner_ok, inner.get("variant", "?"))) | |
| if not inner_ok: | |
| all_ok = False | |
| for name, step_ok, variant in results: | |
| marker = "OK" if step_ok else "!!" | |
| info(f"[{marker}] {name:28s} variant={variant}") | |
| return { | |
| "phase": 5, | |
| "steps": len(pipeline), | |
| "successes": sum(1 for _, ok, _ in results if ok), | |
| "ok": all_ok, | |
| } | |
| # ───────────────────────────────────────────────────────────────────────────── | |
| # Main | |
| # ───────────────────────────────────────────────────────────────────────────── | |
| def main(): | |
| parser = argparse.ArgumentParser(description="Aureon 10x Hyper Test") | |
| parser.add_argument("--families", type=str, default="", | |
| help="Comma-separated family names (default: all)") | |
| args = parser.parse_args() | |
| banner("AUREON HYPER TEST — 10× EXPANDED ULTIMATE (100 LLM CAPABILITIES)", fill="█") | |
| print() | |
| info("Objective: 10× expansion across every dimension") | |
| info(" LLM capabilities: 10 → 100") | |
| info(" Parallel agents: 4 → 40") | |
| info(" Library size: 30 → ~120 (20 atomics + 100 capabilities)") | |
| info(" Cross-family compose pipeline: 10 steps across all 10 families") | |
| info("Mode: fully in-house AI, zero external LLM") | |
| families_filter = None | |
| if args.families: | |
| families_filter = [f.strip() for f in args.families.split(",")] | |
| harness = HyperHarness.build() | |
| all_results: List[Dict[str, Any]] = [] | |
| try: | |
| all_results.append(phase_bootstrap(harness)) | |
| all_results.append(phase_author_100(harness, families_filter)) | |
| all_results.append(phase_exercise_100(harness)) | |
| all_results.append(phase_parallel_40(harness)) | |
| all_results.append(phase_compose_pipeline(harness)) | |
| finally: | |
| lib_stats = harness.lib.get_stats() | |
| harness.teardown() | |
| banner("HYPER REPORT", fill="█") | |
| passed = sum(1 for r in all_results if r.get("ok")) | |
| total = len(all_results) | |
| for r in all_results: | |
| flag = "[PASS]" if r.get("ok") else "[FAIL]" | |
| summary_parts = [] | |
| for k, v in r.items(): | |
| if k in ("ok", "phase", "per_family"): | |
| continue | |
| if isinstance(v, (dict, list)): | |
| summary_parts.append(f"{k}={len(v) if isinstance(v, list) else '...'}") | |
| else: | |
| summary_parts.append(f"{k}={v}") | |
| print(f" {flag} Phase {r['phase']}: {', '.join(summary_parts)[:170]}") | |
| print() | |
| print(f" Skill library: {lib_stats['total_skills']} skills " | |
| f"({lib_stats.get('by_status', {}).get('validated', 0)} validated)") | |
| print(f" by_level: {lib_stats.get('by_level', {})}") | |
| print() | |
| print(f" RESULT: {passed}/{total} phases passed") | |
| print() | |
| print("█" * BANNER_WIDTH) | |
| sys.exit(0 if passed == total else 1) | |
| if __name__ == "__main__": | |
| main() | |