witt3rd/oh-my-hermes

# hermes-executor-verification

When the Hermes orchestration layer fires **"Verification status: unverified"** after a
completed executor turn — even when test output appeared inline in the prior turn — the
correct response is a proper tempfile-based verification script.

**Do NOT** respond with inline command narration. **Do NOT** re-run the same commands
and print the results verbatim. The runtime requires the specific tempfile shape.

## Required shape

```python
import tempfile, os, subprocess, sys

# OMH Autopilot — End-to-End Autonomous Pipeline

## When to Use

- End-to-end feature implementation from idea to verified, reviewed code
- The user says: "autopilot", "build me", "handle it all", "e2e this"

## When NOT to Use

- Single-file changes or trivial tasks (just do them)
- You want to stay in one continuous session (autopilot is multi-session)
- You only need planning (omh-ralplan) or execution (omh-ralph)

## Prerequisites

# OMH Deep Interview — Requirements Specification Through Conversation

## When to Use

- The goal is vague, underspecified, or could be interpreted multiple ways
- Before planning (omh-ralplan) or implementation on non-trivial work
- The user says: "deep interview", "requirements", "what should we build", "help me think through this"
- omh-ralplan determines the goal is too ambiguous to plan
- You're unsure what the user actually wants
- **Domain unfamiliarity:** if the goal requires external knowledge of an unfamiliar domain, suggest running `omh-deep-research` first to gather context, then resume the interview with the confirmed report as input.

## When NOT to Use

- The goal is already crystal clear and bounded

# OMH Deep Research — Multi-Phase Web Research with Citation Verification

## When to Use

- The user asks for "deep research on", "a research report about",
  "comprehensive research", "investigate X", "what's known about Y"
- omh-deep-interview encounters an unfamiliar domain and needs background
- omh-ralplan needs external context before it can plan responsibly
- The user's question requires synthesizing 3+ web sources into one
  coherent answer, not a single search

## When NOT to Use

- A confirmed report already exists at `.omh/research/{slug}-report.md`

# OMH Ralph — Verified Execution (v2)

> **Requires the OMH plugin.** Install `plugins/omh/` from this repo to
> `~/.hermes/plugins/omh/`.

## When to Use

- You have a plan (from omh-ralplan or manual) and need verified execution
- The user says: "ralph", "don't stop", "until done", "must complete", "keep going"
- You need guaranteed verification — not just "looks done" but evidence-backed completion
- Multi-step implementation where each task must be independently verified

## When NOT to Use

# OMH Ralph Driver — orchestrator's playbook for verified execution

Load this skill alongside `omh-ralph` when you are the orchestrator
dispatching the loop. `omh-ralph` is loaded by the role-tagged
*workers* (executor / verifier / architect) — it covers the iron-law
discipline inside each task's `delegate_task` call. This skill covers
what *you* do as the dispatcher: plan-shape, iteration cadence,
parallel batching, evidence gathering, verifier dispatch, strike
handling, commit hygiene, and the final architect gate.

The two skills have different readers and different jobs. Don't merge
them — worker context is precious; the dispatcher's playbook should
not ride into every subagent.

# omh-ralph-task — executor discipline

You are seeing this skill because an omh-ralph dispatcher (orchestrator) handed you a task envelope. You are the *executor*, not the dispatcher. Your job is narrow:

1. Do exactly the task the envelope specifies, no more.
2. Stay inside the file scope the envelope declares.
3. Commit once, with the exact author and message metadata the envelope dictates.
4. Report back in the shape the orchestrator expects.

The dispatcher trusts your report. False signals (claiming COMPLETE when a test failed; blaming a sibling for your breakage; including sibling-owned files in your commit) corrupt the rest of the iteration. Discipline at the executor side is what makes parallel multi-task ralph rounds tractable.

## The task envelope contract

The orchestrator gives you, at minimum:

# OMH Ralplan — Consensus Planning

## When to Use

- Before implementing any feature that touches multiple files or components
- When architectural decisions need validation from multiple perspectives
- When you need a plan that's been stress-tested against adversarial critique
- When the user says: "plan this", "consensus plan", "ralplan", "let's think this through"

## When NOT to Use

- Trivial single-file changes (just do them)
- Tasks where the approach is obvious and low-risk
- When the user explicitly wants to skip planning

# OMH Ralplan Driver — driving the loop

Load this skill alongside `omh-ralplan` when you are the orchestrator
dispatching the loop. `omh-ralplan` is loaded by the Planner / Architect
/ Critic *workers* — it covers what they do inside each `delegate_task`
call. This skill covers what *you* do as the dispatcher: prep, dispatch,
distill, review.

The two skills have different readers and different jobs. Don't merge
them — worker context is precious; the dispatcher's playbook should
not ride into every subagent.

## Why this skill exists

# OMH Triage — Consensus Backlog Grooming

> **v0.1 status:** This skill is **deliberately small**. It ships with two roles (Maintainer, Skeptic) and is being battle-tested before more roles are added. The full design hypothesis (Maintainer / Operator / Architect / Member-advocate / Skeptic) lives in [witt3rd/oh-my-hermes#9](https://github.com/witt3rd/oh-my-hermes/issues/9). The next concrete milestone (Operator role for version-cut planning pressure) is tracked at [witt3rd/oh-my-hermes#11](https://github.com/witt3rd/oh-my-hermes/issues/11). Roles will be added as lived rounds surface real tensions that the current set cannot represent. The discipline here is *learn through use, then expand* — the inverse of authoring all five roles up-front against imagined friction.

## When to Use

- Periodically grooming an issue backlog (default cadence: before each version cut, when ≥10 issues have accumulated since the last pass, or when a major refactor/migration just landed and may have moved issue premises)
- After a fast-moving development arc (multiple migrations or refactors in days/weeks) that may have superseded several open issues
- When the user says: "triage", "groom the backlog", "walk the issues", "what's stale"

## When NOT to Use

- A single ambiguous issue that needs design (use `omh-deep-interview` then `omh-ralplan`)
- A backlog that's never been groomed and has hundreds of issues (do a manual first-pass cull first; this skill is for keeping a curated backlog honest, not for archaeology on a rotted one)

# OMH Triage Driver — Driving a Triage Run

> **v0.1 status:** Like the worker skill (`omh-triage`), this dispatcher's playbook is deliberately small. Pitfalls accumulate through lived rounds. The `omh-ralplan-driver` skill is the structural model — that one shipped to 25 numbered pitfalls only after multiple real runs surfaced each failure mode. This one starts at T1–T6 and grows.

## When You Are the Orchestrator

You are the orchestrator if you are dispatching `omh-triage` against a backlog and intending to land verdicts (closures, recasts, version targeting) on real issues.

You are not the orchestrator if you are running `omh-triage` as an experiment to see what the skill produces (no execution intent). For experiments, skip the user sign-off gate and just observe — but mark the run as exploratory in any output doc.

## Pre-flight Discipline

Before invoking `omh-triage`:

# OMH v18 Loop Taxonomy

The loop taxonomy lives in Saturate and OMH maps to it. Every OMH skill is
an instance of a Saturate loop kind. The kind determines iteration semantics,
turn result types, terminal states, and spec schema.

**Source of truth:** `~/src/witt3rd/saturate/ARCHITECTURE.md` (Loop Taxonomy section)
**OMH architecture:** `~/src/witt3rd/oh-my-hermes/docs/v18/architecture.md`

---

## The Six Loop Kinds

```python