Handling forking on different levels of Tasks

Question

I'm really stuck on handling different levels of Tasks in Ramda. I'm trying to build a script to parse LESS files for comments and build a pattern library site from the data in the comments and inline HTML from an example file. It's all working (with a lot of help from SO) except the inlining the example file contents.

const target = path.join(__dirname, 'app/dist/templates/');
const source = path.join(__dirname, 'source/');
const stylesSource = path.join(__dirname, 'source/less/');
const template = path.join(__dirname, 'app/src/templates/page-template.html');

const writeTemplate = function(data) {
    var rs = fs.createReadStream(template);
    var ws = fs.createWriteStream(path.join(target, R.toLower(R.concat(data.name, ".html"))));

    rs
        .pipe(replaceStream("{{name}}", data.name))
        .pipe(replaceStream("{{description}}", data.description))
        .pipe(replaceStream("{{example}}", data.example))
        .pipe(ws);
}

const inlineExample = function(data) {
    return readFile(path.join(source, data.example));
}

//    parseFile :: String -> { name :: String
//                           , description :: String
//                           , example :: String }
const parseFile = function parseFile(data) {
  return {
    name: R.trim(R.nth(1, R.match(/[$]name:(.*)/, data))),
    description: R.trim(R.nth(1, R.match(/[$]description:(.*)/, data))),
    example: R.trim(R.nth(1, R.match(/[$]example:(.*)/, data)))
  };
};

//    readDirectories :: String -> Task [String]
const readDirectories = function readDirectories(dir) {
  return new Task(function (reject, resolve) {
    glob(path.join(dir, "/**/*.less"), function (err, files) {
          err == null ? resolve(files) : reject(err);
        })
  });
};

//    readFile :: String -> Task String
const readFile = function readFile(filename) {
  return new Task(function (reject, resolve) {
    fs.readFile(path.normalize(filename), 'utf8', function (err, data) {
      err == null ? resolve(data) : reject(err);
    });
  });
};

//    dirs :: Task [String]
const dirs = readDirectories(stylesSource);

//    files :: Task [Task String]
const files = R.map(R.map(readFile), dirs);

//    commuted :: Task (Task [String])
const commuted = R.map(R.commute(Task.of), files);

//    unnested :: Task [String]
const unnested = R.unnest(commuted);

//    parsed :: Task [{ name :: String
//                    , description :: String
//                    , example :: String }]
const parsed = R.map(R.map(parseFile), unnested);

const inlined = R.map(R.chain(inlineExample), parsed);

inlined.fork(err => {
      process.stderr.write(err.message);
    },
    data => {
      R.map(writeTemplate, data);
      util.log(R.concat('Library successfully generated at: ', target));
    });
});

I can go through, read the directory, open the files (returning a new Task) and extract the template path from the comments. I'm then running (I think) parseFile on the path (which returns a Task) and that's where it's failing. I'm struggling with getting the example template Task forked so I can use the contents.

I'm open to any suggestions but suspect that the problem is somewhere in R.map(writeTemplate, data) in the original success fork but I'm a bit out of my depth now.