/hep-storm

description: Run a force-robust Stormbreaker loop — route to real agents, execute a verified pipeline to completion.
argument-hint: '<goal>'
allowed-tools: Bash, Read, Glob, Grep, Edit, Write, Task

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

/hep-storm

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**. Also triggered by `@Hephaestus storm <goal>`.

Use it for loop-worthy work: apps, sites, agents, automations, debugging, multi-step research, data/report generation — anything with files, tools, tests, or external verification. Trivial questions should be answered directly, not stormed.

Raw arguments: `$ARGUMENTS`

Core-owned Goal + UltraCode harness

Every result includes `execution_harness`. Apply `execution_harness.system_prompt` **verbatim** before planning or executing any packet, and retain its `prompt_sha256` in the goal ledger. Do not redefine, summarize, or replace Goal mode or UltraCode mode in this Claude Code adapter. If live session JSON is available, expose it as `AGENTLAS_SESSION_INVENTORY`; otherwise use Core's explicit `host:primary` fallback and do not invent workers or models. With no external executor, `status: materialized` plus `final_gate.can_report_success: false` is the expected handoff to Claude Code's native tools, never a completed run.

1. Resolve the runner 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.

1. Find the first executable Hephaestus runner:

RUNNER=""
CODEX_HOME_DIR="${CODEX_HOME:-$HOME/.codex}"
for candidate in \
  "$HOME/.agentlas/runtime/current/bin/hephaestus" \
  "${CLAUDE_PLUGIN_ROOT:+$CLAUDE_PLUGIN_ROOT/bin/hephaestus}" \
  "${CODEX_PLUGIN_ROOT:+$CODEX_PLUGIN_ROOT/bin/hephaestus}" \
  "${PLUGIN_ROOT:+$PLUGIN_ROOT/bin/hephaestus}" \
  "./bin/hephaestus" \
  "./claude/plugins/agentlas-core-engine-meta-agent/bin/hephaestus"
do
  if [ -n "$candidate" ] && [ -x "$candidate" ]; then RUNNER="$candidate"; break; fi
done
if [ -z "$RUNNER" ]; then
  for cache in "$HOME/.claude/plugins/cache/agentlas-core-engine/hephaestus" \
               "${CODEX_HOME:-$HOME/.codex}/plugins/cache/agentlas-core-engine/hephaestus"; do
    newest="$(ls -d "$cache"/*/bin/hephaestus 2>/dev/null | sort -V | tail -1)"
    if [ -n "$newest" ] && [ -x "$newest" ]; then RUNNER="$newest"; break; fi
  done
fi
[ -n "$RUNNER" ] || { echo "Hephaestus runtime not found. Run the installer first." >&2; exit 1; }
if [ "${HEPHAESTUS_AUTH_AUTOPOPUP:-1}" != "0" ]; then
  "$RUNNER" auth ensure --timeout 180 >/dev/null 2>&1 || true
fi
# Route + materialize the pipeline fabric for THIS goal. No --executor-command:
# the host model (you) executes each packet natively. --research-evidence grounds
# plan/research packets with Research Engine receipts.
FABRIC="$("$RUNNER" hep-storm "$ARGUMENTS" --research-evidence --runtime claude-code)"
printf '%s\n' "$FABRIC"

2. 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 §2.

• **`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.

2. 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.

1. **scope-lock** — Restate the goal as one sentence and lock to it. Check the route decision's failure-memory. If (and only if) the goal is too ambiguous to decompose safely, ask ONE batch of 3–5 questions (what NOT to do / smallest version / done signal / dependencies), then proceed. If it is already specific, ask nothing. 2. **issue contract** — Write the acceptance criteria: the concrete, checkable done-signal for each packet and for the whole goal. These become the loop's stop criteria. 3. **plan-lock** — Adopt the fabric's `parallel_groups` and `depends_on` ordering as the plan. Open a **visible goal ledger**: packet, owner, verification gate, status, resume point. 4. **act** — Execute the next unblocked group. Run independent packets in the