rlaope/oh-my-hermes / skills/dag-ulw
dag-ulw
Verified[omh] Large multi-part job to run on its own: plan it as a graph of small nodes, run the ready ones in parallel through Hermes' delegate_task, verify the goal with a separate node, and repair failed nodes before reporting. Use when the user says: dag-ulw, dag ulw, ulw dag, dag ultrawork, ultrawork dag, даг ультраворк, граф задач, задачи графом.
Dag Ulw
This is a Hermes-native dag-ulw workflow skill.
Why This Exists
dag-ulw exists so a big job runs end to end without the person driving it: the parent plans a graph OMH can validate and draw, runs the ready nodes in parallel on Hermes' own children, verifies the goal with a separate node, and repairs before it reports.
First Steps
- Start at once; there is no plan approval. Write the goal in one line, and pass each separately checkable outcome the request names as
criteria(id and one line); a criterion names the state the person asked for (it works on staging), not that a check was run or its result reported; never ask the person to list them. - When the conversation holds a plan the user accepted (from
omh-plan,ulw-planoromh-refactor-plan), build the graph from it instead of re-planning: each task becomes a node with its id, depends_on and write scope, its done check goes into VERIFY and STOP WHEN, and its closing verification task becomes therole: verifynode; plan only what it leaves open. - Plan the graph and call
omh_dag action=definewith the complete rungoaland each node's id, label, category, prompt, depends_on, write_scope and role (buildby default;baseline,verify,review); fix every refusal and read the lint before going on. Neverdelegate_taskbeforedefinereturns its calls. The saved goal reaches every native task; local VERIFY does not replace goal acceptance. - Keep the plan todo as the run's layers in ONE tool:
todo_listwhentodo_listis in your tool list or tool_search finds it (OMH mirrors it), elseomh_todo; an accepted plan stays inomh_todo. One item per layer, named for what it delivers, never a list of its nodes (the panel draws those); advance it as each layer settles. - Before defining nodes, read
omh_role action=listand compare built-in and custom identity responsibilities equally. User instructions and project ownership win. Read suitable definitions withaction=read identity=REFERENCE; record the choice in each node's optionalidentity(builtin:nameorcustom:name). Omit it when none fits. Identity is prompt guidance;roleremains build/baseline/verify/review andcategorydescribes the work. - For each call
omh_dagreturns, run its route (omh_delegate_route, set or fallback as given), check that it succeeded (a refusal or exhausted chain stops dispatch), thendelegate_taskwith the tasks unchanged; never more calls than it returned. A call whose route names abackend(Hermes' model_map or profile_routes) runs no route tool: its tasks already carry what that backend takes. Then end the turn with one status line; never wait or poll. Whendelegate_taskreturns the children's results inside the call (a one-shot or other finite session), settle them and dispatch what settle returns in the same turn instead: no completion comes back as a later turn there. - On each completion read the node's handoff file and call
omh_dag action=settle(accepted, failed, or blocked; a provider error is failed with provider_error); a verify node with criteria is accepted only when everyCRITERIONline says met, failed when one is unmet, blocked when one could not be checked here. A handoff with anESCALATE:line is settledescalated, that question as the reason; never answer it yourself and accept. Dispatch what it returns in the same turn. - When the run reports done, check each node against its SCOPE and the goal criteria: extend the run when work is missing, otherwise report.
Do Not Use When
- One small change with one owner and one check: run it directly, or use
ulw-workwhen the person named it. - The plan itself is still undecided and needs a reviewed decision record first; use
ulw-plan. - Workers must talk to each other mid-run rather than hand off through files; use
ulw-workcoordinated lanes. - The graph tool (omh_dag) is not in your tool list: say so and offer
ulw-workfor the same plan; do not simulate the graph in chat.
Examples
Good example:
- Prompt: dag ulw: add the export API, its UI button and the docs page, then verify with the full test suite
- Expected behavior: Define four nodes (api, ui after api, docs after api, verify after all), dispatch api, settle from its handoff, dispatch ui and docs together, run the verification node, report with the run summary.
- Why: Three producers with one ordering edge and a shared verification fan-in is the shape the graph is for.
Bad example:
- Prompt: dag ulw fix the typo in README
- Expected behavior: Fix it directly; a one-node graph adds a tool round trip and a status line for nothing.
- Why: One bounded edit has no parallelism or ordering to plan.
Completion Checklist
- The run was defined in
omh_dagbefore the first dispatch, and every dispatched node was settled. - No two concurrently runnable nodes shared a write scope without an edge.
- A separate verification node ran the real command after every producer.
- Every accepted node was checked against its SCOPE; repairs stayed within two cycles per node and extend rounds within two per run.
- The report names what is still open and includes the observed run summary or an explicit run-summary not_available line before any specific next-action question.
Recovery Notes
- A node whose child returned blocked or failed blocks only its dependents: repair it, or report it.
- When
readyreturns no call because no slot is free, end the turn; the next completion frees one. - When the conversation was compacted,
omh_dag action=statusstill finds the run.
Workflow Lane
- Current lane: Intent -> plan - clarify, plan, ship, or loop goals.
- If intent belongs to another lane, hand back to
omh-routingor name the adjacent workflow. - Shared product, routing, compatibility, and evidence rules:
skill_view(name='omh-routing', file_path='references/skill-common-rail.md').
When to Use
Use when the request is a job of several parts that can run in parallel or in an order (a feature across modules, a migration, a broad cleanup, research then build then verify), or when the person says dag ulw.
Strong routing signals: `dag-ulw`, `$dag-ulw`, `dag ulw`, `ulw dag`, `dag ultrawork`, `ultrawork dag`, `даг ультраворк`, `граф задач`, `задачи графом`
Catalog Metadata
Category: agent-coordination
Phase: dag-delivery
Hermes role: tracker
Quality tier: evidence-gated
Reasoning demand: standard
Quality bar:
- When adapting an existing capability, load
skill_view(name='omh-verification-gate', file_path='references/adaptation-quality.md')before accepting a plan, dispatching work, or claiming completion; carry its criteria and comparisons into tasks and evidence. - Split for work that can run side by side: every child pays a start, a read of the repo and a handoff before its work counts, so a small step that only follows another (wiring, the docs for it) belongs in the node it follows, and parts that share a write scope or a judgement are one node. Several parts with nothing to run side by side are still a graph (baseline, one build node, verify), not a reason to skip it.
- Climb the difficulty ladder
quick->unspecified-low->unspecified-highwith a one-line reason per climb. When one build node's judgement decides the run (a design decision, a root cause, a contested trade-off), give itultrabrainwhere your routes serve it, at most one; a graph whose every node isdeepordeep-workis a routing failure. Arole=reviewnode takes categoryreviewwhere your routes serve it; arole=baselinenode staysquickorunspecified-low; arole=verifynode judges the run goal and baseline exemptions, so climb the ladder for it; it is not theultrabrainnode. - Write every node prompt self-contained, as you would brief a colleague who knows the project but not this conversation, in order: TASK, DELIVERABLE, SCOPE (what it may read and write), VERIFY (the literal command and expected result), STOP WHEN. Give a build node
review_focus: what you will look for when you read its work. depends_ononly orders nodes; data moves through the handoff filesomh_dagnames, never through the parent's memory.- Before full-suite verification, run a
baselinenode before changes and record in its handoff each failure's test id, assertion/error signature, command, environment and revision; make verification depend on it and exempt only those signatures re-executed under a comparable command at the pinned base and candidate revisions. Never exempt a changed same-id failure, missing evidence, skipped or reduced coverage, collection/exit errors, or security/mandatory gates; disclose genuine baseline failures as pre-existing rather than calling a full-suite-green goal met. - End every run with a
role: verifynode that depends on every producer, runs the real command, and is never the node that built the work; with criteria it writes oneCRITERIONline per criterion. - Completion is a claim: report the goal met only when
omh_dagsaysverdict: verified, and first check each node against its SCOPE in both directions, nothing owed missing and nothing beyond it done. The reply states the result in plain words (the goal is confirmed; part is not, and which; a check could not run here, and why; how many criteria were met; name a criterion by what it says, not its id); verified, unverified, needs_repair, blocked, settle and node ids are record words, not reply wording. - Goal loop: verify, repair, extend, verify. A failed check gets repair nodes (
omh_dag action=repair, two cycles per node, the last re-plans); when every node passed but the goal check finds work missing, add it to the same run (omh_dag action=extend, two rounds per run). Past either limit, report what is still open. - A familiar re-run of the same goal may pass
carry_forward(the base revision) at define: nodes an earlier run at that base accepted unchanged are carried, not run again, and listed; the verify node always runs. - Unknown path: scout first; see 'When the path is unknown' in
references/run-loop.md. - On a messenger, each completion turn's reply is the run's one status line, and dispatch goes one call per layer and category so the posts stay bounded; load
references/run-loop.mdfor the messenger, repair, extend and export details. - A mid-run user message is an interjection, not a stop: answer it briefly and, in the same reply, continue the run — re-read the phase todo when one is active and dispatch or advance the next pending step, or name the armed wait it is waiting on -- handle, bound completion signal, deadline -- instead of re-reading status. Only the user's explicit stop or cancel, or the engine's own completion gate, ends the run; when the interjection changes scope, say so and update the declared plan or todo instead of silently abandoning it. A mid-run message is the latest steering for the active task, not automatically a replacement objective: it replaces the objective when the user says so and steers the current one otherwise.
- A follow-up that needs new authority, materially expands the scope, or changes external state not already authorized is described first and started only on the user's approval: the turn ends by naming that next action and asking whether to take it, as one question carrying the choices the user has, never by declaring what will not be done; persistence never broadens the authorized scope. A refused escalation is answered the same way, with a safer alternative inside the boundary or the authorization the boundary asks for — never a workaround or an indirect execution.
- The closing brief scales to the change: one or two sentences for a simple change. Lead with the result and validation; omit abandoned approaches unless they explain a tradeoff, and internal bookkeeping. Disclose requested-but-not-done work and material prepared/unmerged work; omit unrelated non-action footers. Required accounting stays outside this scaling. Order: result -> relevant evidence/limits -> observed accounting (when required) -> specific question (if useful). For a real unresolved user decision or a useful briefing discussion, offer one specific, content-linked question. Completed work needs no question; discussion grants no authority. Never estimate usage.
- Close a finished run with
omh_run_summaryand print its summary_text verbatim, or an explicit run-summary not_available line, before any specific next-action question -- never estimated numbers.
Handoff policy:
Hermes owns the plan, the dispatch, the settling and the verdict; every node runs as Hermes' own delegate_task child, routed per category with omh_delegate_route. OMH's omh_dag tool keeps the graph, and only its calls start nodes: a delegate_task without the [dag:<run>/<node>] marker it returned is no node of the run. Coding nodes go to an external coding CLI only when the person named that owner in a request that invokes dag-ulw and defines the run; a choice counts only for the request it was made in, so an earlier request's choice, omh chat or omh coding does not count. Then omh_dag lists each owner's nodes under exports. Otherwise no external CLI runs.
Required inputs:
- the goal and the criteria that prove it
- the workspace the nodes may change
Expected outputs:
omh_dag/v1run with nodes, edges and settled outcomes- verification node result against the goal criteria
- closing report: what passed, what is still open, the run summary
Artifact expectations:
omh_dag/v1record under the OMH home, one per run- one handoff file per node, written by its child and read by the nodes after it
Safety rules:
- Two nodes that can run at the same time never share a write scope; a shared file needs an edge or one owner.
- A node's own report is a claim: settle it accepted only after reading its handoff file, and settle a child that says it is blocked as blocked.
- Ask the person only for scope, spend, or an irreversible step, as one required
Authorizequestion; an unanswered question means that part does not start. - No external coding CLI runs unless the person named it as the coding owner in this request.
Runtime Evidence
Record observed delegation results; otherwise return not_available or not_observed.
Prepared OMH routing is not execution, review, CI, merge-readiness, or merge evidence.
- Treat wrapper memory/context summaries as advisory local context, not proof of opaque Hermes memory reads or changes. Preserve workflow intent and stop conditions; verify before claiming completion. Reply in the user's own words and the host's own voice: its SOUL.md persona owns reply language, tone, speech level, and sentence endings, progress updates included (where it sets no language, use the one the user wrote in), and OMH shapes structure and content only. When the requested output is delivered, put any open points inside the result and end with no question or offer; only when the person asked to choose or decide and that choice is still theirs, end with one specific question about it, not a list, a generic offer, or a footer; the shared rail's Reply Language And Host Voice and Turn Ending sections hold the full rule.
Use Hermes-native subagent/delegation features when available: native subagents -> Hermes delegation when available, otherwise sequential lanes.
Shared product, compatibility, topology, memory, harness, and execution rules: skill_view(name='omh-routing', file_path='references/skill-common-rail.md'). Load it when applicable; otherwise name an unavailable capability.
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack." | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |