hep-storm

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

Drive a goal through the **Stormbreaker Loop** — Hephaestus' force-robust,
verifier-first execution loop — inside this Antigravity workspace. 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.

## 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
  "$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 "$GOAL" --research-evidence --runtime antigravity)"
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. *