hep-storm

Update fallback: 자동 업데이트가 안 되면 `hephaestus update`를 한 번 실행하세요. 업데이트하지 않아도 현재 버전 명령은 그대로 동작합니다. # /hep-storm Drive a goal through the **Stormbreaker Loop** — Hephaestus' force-robust, verifier-first execution loop — inside this 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 >/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 "${AGENTLAS_HOST_RUNTIME:-terminal}")" 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`를 한 번 실행하세요. 업데이트하지 않아도 현재 버전 명령은 그대로 동작합니다.