hephaestus-storm

Files (1)

• SKILL.md

SKILL.md (first lines)

Update fallback: 자동 업데이트가 안 되면 `hephaestus update`를 한 번 실행하세요. 업데이트하지 않아도 현재 버전 명령은 그대로 동작합니다.

# Hephaestus Stormbreaker Loop

Drive a goal through the **Stormbreaker Loop** — Hephaestus' force-robust,
verifier-first execution loop. Unlike a one-shot answer or a generic parallel
fan-out, Stormbreaker **routes the goal to real Agentlas specialists**, structures
the work as a dependency-ordered pipeline fabric, drives each work packet as a
**hardened goal loop** (it does not stall, run away, or claim false success), and
**refuses to report success without evidence**. Never guess an agent yourself when
this skill is active — the router or Hub decides the workforce.

## Core-owned Goal + UltraCode harness

Every `hep-storm` result includes `execution_harness`. Before planning or
executing any packet, apply `execution_harness.system_prompt` **verbatim** and
retain its `prompt_sha256` in the goal ledger. This adapter must never redefine,
summarize, or replace Goal mode or UltraCode mode with host-local wording. The
adapter owns invocation only; Agentlas Core owns the execution protocol.

If the host exposes live Codex, Claude Code, Antigravity, local-model, or other
sessions, provide their JSON array through `AGENTLAS_SESSION_INVENTORY` or
`--session-inventory`. If it does not, accept Core's explicit `host:primary`
fallback; never invent a model ID or claim unavailable parallel workers.

With no external executor, the runner intentionally returns `status:
materialized` and `final_gate.can_report_success: false`. That is the host's
signal to execute the returned packets with its native tools; it is not a
failure and must never be rewritten as completion.

## 1. Resolve the runner

Run this resolution in a shell and use the first hit:

```bash
RUNNER=""
for c in \
  "$HOME/.agentlas/runtime/current/bin/hephaestus" \
  ./bin/hephaestus
do [ -x "$c" ] && RUNNER="$c" && break; done
if [ -z "$RUNNER" ]; then
  for cache in \
    "$HOME/.claude/plugins/cache/agentlas-core-engine/hephaestus" \
    "$HOME/.codex/plugins/cache/agentlas-core-engine/hephaestus"; do
    newest="$(ls -d "$cache"/*/bin/hephaestus 2>/dev/null | sort -V | tail -1)"
    [ -n "$newest" ] && [ -x "$newest" ] && RUNNER="$newest" && break
  done
fi
```

If no runner exists, tell the user to run the one-touch installer:
`curl -fsSL https://raw.githubusercontent.com/agentlas-ai/Agentlas-OS/main/scripts/install-all-runtimes.sh | bash`

## 1.5 Core project first-contact contract

Every `hep-storm` call is a trusted plugin contact. Before routing or
materializing packets, Agentlas Core synchronously creates or repairs the
canonical private project soul memory, code map, ontology runtime, CareerGraph,
and merge-only `.gitignore` block for all of `.agentlas/`. A blocked bootstrap
receipt blocks the storm. The adapter must not substitute host-local files or a
second bootstrap implementation.

## 2. Agentlas sign-in

Before routing, ensure Agentlas is signed in:

```bash
if [ "${HEPHAESTUS_AUTH_AUTOPOPUP:-1}" != "0" ]; then
  "$RUNNER" auth ensure >/dev/null 2>&1 || true
fi
```

This opens the user's default browser only when there is no valid local
Agentlas sign-in yet. If a saved sign-in already exists, it silently reuses it.
For CI/headless checks only, set `HEPHAESTUS_AUTH_AUTOPOPUP=0` and skip this step.

## 3. Route and materialize the execution fabric

The Stormbreaker engine routes the goal and materializes a pipeline fabric
(packets, parallel groups, dependency gates, goal loops, a final gate, and a
resumable journal). In an agentic runtime **you are the executor** — the engine
gives you the verified plan; you carry it out with your own tools. No
`--executor-command`: the host model (you) executes each packet natively.
`--research-evidence` grounds plan/research packets with Research Engine receipts.

```bash
FABRIC="$("$RUNNER" hep-storm "<the user's goal>" --research-evidence --runtime "${AGENTLAS_HOST_RUNTIME:-agent-skills}")"
printf '%s\n' "$FABRIC"
```

## 4. Branch on the route decision

Read `route_decision.action` (or `route_action`) and branch — Stormbreaker only
auto-materializes a full fabric for a **pipeline**; other actions still start a
storm, just with the workforce the router chose:

- **`pipeline`** — the result carries the `execution_fabric` (`packets`,
  `parallel_groups`, `sessions`, `resume_policy`), per-packet `write_scope` and
  `goal`/verifier, a `pipeline_id`, a `journal` path, and `final_gate` criteria.
  Run the full loop in §5.
- **`clarify`** — the goal is ambiguous. Ask `clarify_question` with the candidate
  list as ONE batch, then re-run `"$RUNNER" hep-storm "<refined goal>"`. This is
  the scope-lock ambiguity gate; do not guess past it.
- **`route`** (single card) — a one-agent storm: borrow and run that card attached
  to this project, then still apply the verify → repair → final-gate steps.
- **`hub_fallback` / `hub_candidates`** — Hub lookup used redacted keywords only.
  If an `execution` block lists `recommended_agents`, borrow each in stage order
  via `"$RUNNER" hep-call "<agent>" "<goal>" --project .` and run them attached to
  this repo; otherwise report candidates and offer `/hep-build`.
- **`propose_new`** — no fit exists; offer to build one via `/hep-build`.
- **`refuse`** — explain `reasons` (e.g. loop guard) and stop. Do not retry around
  it.

## 5. Run the Stormbreaker Loop over the fabric

Execute the goal to completion under this protocol. **Do not stop to ask for
confirmation** — this is a force-robust run. Only halt when the goal is verified,
or you are genuinely blocked by auth, payment, policy, a missing secret/tool, or
a required user approval.

From agentlas-ai/Agentlas-OS, Apache-2.0.

More from agentlas-ai/Agentlas-OS