git:20260912.9f91196 to git:20260913.78e7f07

---

name: hep-storm

description: Run a force-robust Stormbreaker loop — route to real agents, execute a verified pipeline to completion.

---

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

# /hep-storm

Drive a goal through the **Stormbreaker Loop** — Hephaestus' force-robust,

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.

## Core-owned Goal + UltraCode harness

Every result includes `execution_harness`. Apply

`execution_harness.system_prompt` verbatim before planning or executing packets,

retain its `prompt_sha256`, and never redefine Goal mode or UltraCode mode in

this adapter. Pass live session JSON with `AGENTLAS_SESSION_INVENTORY` when the

host provides it; otherwise use Core's explicit `host:primary` fallback.

The goal is the exact text the user typed after `/hep-storm`.

## How to run

Run the shell block below **verbatim**, replacing only the `GOAL` value with the

user's exact goal text. The block resolves the Hephaestus runner by **absolute

path** and runs it — there is nothing to install and nothing to add to `PATH`.

In an agentic runtime **you are the executor**: the engine gives you the verified

plan (the execution fabric); you carry it out with your own tools.

> Guardrails — do NOT do any of these. They are not how this workflow works and

> have caused fabricated reports before:

> - Do NOT diagnose `command not found` or `PATH`, and do NOT edit `~/.zshrc`.

> The runner is resolved by absolute path inside the block.

> - Do NOT claim a packet, gate, or external action succeeded without the

> verifier's evidence. A materialized or scheduled run is not proof.

> - If the runner is genuinely missing, say so and stop. Never fabricate a fix

> or a run.

```bash

GOAL="<replace with the exact text the user typed after /hep-storm>"

case "$GOAL" in

"<replace"*) echo "GOAL placeholder not filled — substitute the user's goal first." >&2; exit 2 ;;

esac

RUNNER=""

for candidate in \

"$HOME/.agentlas/runtime/current/bin/hephaestus" \

"./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

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.

printf '%s\n' "$FABRIC"

```

## Act 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:

- `action: "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 "Run the Stormbreaker Loop" below.

- `action: "clarify"` — the goal is ambiguous. Ask `clarify_question` with the

candidate list as ONE batch, then re-run the block with the refined goal. This

is the scope-lock ambiguity gate; do not guess past it.

- `action: "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.

- `action: "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`.

- `action: "propose_new"` — no fit exists; offer to build one via `/hep-build`.

- `action: "refuse"` — explain `reasons` (e.g. loop guard) and stop. Do not retry

around it.

## 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

group concurrently where the runtime supports it. When a packet's `card` names

an Agentlas specialist, **borrow and run it attached to this project** via

`"$RUNNER" hep-call "<card>" "<goal>" --project .` rather than role-playing it.

Write artifacts to each packet's `write_scope`.

5. **verify** — A packet passes only with separately attributable, validated

verification. A `loop.goal_command` exiting 0 may end the goal loop, but it

cannot verify the executor's own output or self-attest success. Require an

independent verifier and hash-validated artifact evidence. "It ran" is never

success.

6. **bounded repair/retry** — On a concrete validation failure, repair and re-run

that packet — bounded. Honor the goal-loop budget: tolerate transient failures

with backoff, stop a packet as `stalled` after consecutive no-progress

iterations, and never exceed its iteration ceiling. A resumed run continues

from the journal, it does not restart.

7. **final-gate** — Report success only if the fabric's final gate clears

(`can_report_success`). Run the evidence/security gate on produced artifacts.

Keep visible progress concise: what was attempted, what was **verified**, and

exactly where to resume if blocked. Never expose hidden reasoning — show

progress, evidence, decisions, and final status only.

## Loop invariants (why this beats a one-shot loop)

- **Don't break (안 끊기게):** a transient packet failure is journaled and retried

with backoff, not fatal. Only a genuine streak of hard failures stops the run.

- **Don't run away:** a hard iteration ceiling plus stall detection — measured

no-progress stops the loop as `stalled` instead of spinning.

- **Keep the goal until done (될 때까지):** the loop reports `reached_goal` only

when the verifier proves it. No bare "it ran" ever counts.

- **Survive a hard stop:** every packet is a journal step, so a killed run resumes

its numbering from the journal instead of colliding or restarting from zero.

## Hard rules

- **No fake pass.** If the engine is unavailable, an account/tool/connector/browser

session is missing, or a gate did not run, report the run as **blocked or

unverified with the exact next step** — never as complete. A scheduled or

materialized run is not proof that an external action succeeded.

- The router only chooses agents and fetches BYOM bundles. Actual tool execution

follows this runtime's own safety and permission model.

- Report the `receipt_id`, `pipeline_id`, and `journal` path in your final message

so the run is auditable and resumable.

## Examples

```text

/hep-storm ship a working waitlist landing page with a verified signup flow

/hep-storm 이 리포 결제 버그를 재현 PoC까지 만들어서 고치고 회귀 테스트로 검증해줘

@Hephaestus storm turn this research question into a cited report with evidence

```

---

Update fallback: 자동 업데이트가 안 되면 `hephaestus update`를 한 번 실행하세요.

업데이트하지 않아도 현재 버전 명령은 그대로 동작합니다.