mism-build-dag

Translates a domain model into a DAG of per-side tasks with contract edges and release slices.

Updated Jun 12, 2026
One-click install
npx skills add https://github.com/lucolucus/mismagent --skill mism-build-dag-lucolucus
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: mism-build-dag
Source: https://github.com/lucolucus/mismagent/tree/main/attic/skills/mism-build-dag
Command: npx skills add https://github.com/lucolucus/mismagent --skill mism-build-dag-lucolucus

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? It bridges the gap between a domain model (context-map with processes and bounded contexts) and executable work by generating a structured DAG of lean backend, frontend, sync, and infra tasks, so teams know exactly what to build and in what dependency order. ## Core Features & Use Cases - Process fan-out: Each process in the context-map becomes one BE produces task plus N FE consumes tasks, with the pairing declaring the operationId that a later contract step reconciles into OpenAPI. - dag.yaml generation: Emits a structure-only YAML file with release slices (vertical value increments) and depends_on/contract edges, while task state stays in the filesystem. - Lean task files: Produces 80-120 line task files with Gherkin acceptance criteria, invariant ACs from the tactical model, and anchored references instead of embedded state. - Use Case: After modeling a feature, run this to turn the context-map into slices like "recording viewable per machine" with BE/FE tasks wired by contract arcs, ready for a readiness gate. ## Quick Start Ask the agent to transform the context-map and architecture notes of the current feature into a dag.yaml with per-side lean tasks under the feature output directory.

Frequently Asked Questions about mism-build-dag

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I turn a domain model into an executable task DAG?

Group the context-map processes into vertical release slices, then fan out each process into one BE produces task and N FE consumes tasks declaring an operationId. Write the slices and depends_on/contract edges into dag.yaml and generate lean task files per side.

What goes into dag.yaml versus the task files?

dag.yaml holds structure only: slices with their children and the depends_on plus contract edges. Task files hold Gherkin acceptance criteria, contract_ref roles, and anchored references. Neither contains status, since state is derived from the folder layout.

When should a BE to FE depends_on edge be added?

Add a BE to FE depends_on only for non-additive or breaking contract changes. For additive, backwards-compatible changes the FE consumes task already has generated types and can be developed in parallel, with ordering enforced only at deploy time.

How are domain invariants and open spikes handled in the DAG?

Invariants from the tactical model become invariant acceptance criteria on the BE produces task for write commands. Unresolved open spikes from the context-map become spike-type nodes, and dependent tasks link to them via depends_on until the spike closes.

What are the limitations of this file-driven DAG approach?

This skill is superseded by mism-build-manifest, where the building-block manifest rather than a dag.yaml of file-tasks drives the build. It is kept as a reference of the file-driven flow and may not match the current architecture-driven method.