@khoavu882/doflow 2.0.0-beta.4 → 2.0.0

package/src/runtime/task-classifier.js

@@ -10,6 +10,7 @@ const { finishRuntime } = require('./cli-result.js');
 const { REPO_ROOT } = require('../helper/repo-root.js');
 const { loadAdviceRegistry } = require('./advice/registry.js');
 const { createAdviceClient } = require('./advice/client.js');
+const { resolveShadowConfig } = require('./advice/shadow-config.js');
 const { materializeKind } = require('./advice/kinds.js');
 const { appendOutcome, findPick } = require('./advice/record.js');
 const { strengthWords } = require('./advice/strength.js');
@@ -438,7 +439,7 @@ class TaskClassifier {
  * @param {boolean} [options.json=false]
  * @returns {number|Promise<number>} exit code; advisory calls are asynchronous
  */
-function handleClassifyCommand({ taskClass, rationale, proposedBy, callingSkill, request, requestFile, taskId, projectRoot, json = false }      = {}) {
+function handleClassifyCommand({ taskClass, rationale, proposedBy, callingSkill, request, requestFile, taskId, projectRoot, env = process.env, json = false }      = {}) {
   const classifier = new TaskClassifier({ repoRoot: REPO_ROOT });
   const decision = classifier.classify({ taskClass, rationale, proposedBy, callingSkill });
   const exitCode = decision.outcome === CLASSIFICATION_OUTCOMES.ACCEPTED
@@ -470,22 +471,57 @@ function handleClassifyCommand({ taskClass, rationale, proposedBy, callingSkill,
       try {
         const advice = loadAdviceRegistry({ repoRoot: REPO_ROOT });
         const storage = loadStorageRegistry({ repoRoot: REPO_ROOT });
-        const roots = resolveRoots({ registry: storage, projectRoot: path.resolve(projectRoot || process.cwd()) });
+        const roots = resolveRoots({ registry: storage, projectRoot: path.resolve(projectRoot || process.cwd()), env });
         const source = (name     ) => JSON.parse(fs.readFileSync(path.join(REPO_ROOT, 'core/registry', name), 'utf8'));
         const sources = { workflows: source('workflows.json') };
         const built = materializeKind('task-class', { adviceRegistry: advice.ok ? advice.registry : null, sources });
         const client = createAdviceClient({ adviceRegistry: advice.ok ? advice.registry : null, roots, sources });
-        const result = advice.ok && built.ok
-          ? await client.ask({
-            questionSet: { state, questions: [built.question] }, kind: 'task-class',
-            staticAnswer: taskClass ?? null, caller: 'classify', taskId: taskId ?? null, record: true,
-          })
-          : { status: 'unavailable', reason: 'config-invalid', answers: [] };
+        const resolvedRoot = path.resolve(projectRoot || process.cwd());
+        const shadow = resolveShadowConfig('task-class', { projectRoot: resolvedRoot, env, roots });
+        let result      = { status: 'unavailable', reason: 'config-invalid', answers: [] };
+        // The pick an outcome is recorded against: the shown answer's, or a shadow pick the client recorded.
+        let recordedPickId                = null;
+        if (advice.ok && built.ok && !shadow.kindSet) {
+          // advice.kinds.task-class unset: the client asks and records the pick itself, as before the dispatcher.
+          // A chosen rollout profile caps it: off asks nothing; shadow records the pick and shows none.
+          const { profileAdvisorCap, unsetKindPath } = require('./advice/mode.js');
+          const route = unsetKindPath(profileAdvisorCap({ projectRoot: resolvedRoot, env }));
+          if (route === 'off') result = { status: 'off', reason: null, answers: [] };
+          else {
+            result = await client.ask({
+              questionSet: { state, questions: [built.question] }, kind: 'task-class',
+              staticAnswer: taskClass ?? null, caller: 'classify', taskId: taskId ?? null, record: true,
+            });
+            if (route === 'shadow' && result?.status === 'answered') {
+              recordedPickId = result.answers?.[0]?.pickId ?? null;
+              result = { status: 'shadow', reason: null, answers: [] };
+            }
+          }
+        } else if (advice.ok && built.ok) {
+          const { interceptDecisionPoint } = require('./advice/shadow-dispatcher.js');
+          const intercepted = await interceptDecisionPoint({
+            kind: 'task-class', caller: 'classify', state, staticPick: taskClass || 'unknown',
+            staticAnswer: taskClass ?? null,
+            questionSet: { state, questions: [built.question] },
+            adviceRegistry: advice.registry, taskId: taskId ?? null, projectRoot: resolvedRoot, env,
+          }, { adviceClient: client, roots, shadowConfig: shadow });
+          // Only act shows a pick, and it is the decision after the raise-only rule. The dispatcher records the
+          // pick (IC-003); its pickId is the one findPick resolves below.
+          if (intercepted.mode === 'act' && intercepted.advisorPick) {
+            result = { status: 'answered', model: intercepted.advisorAnswer.model, answers: [{
+              ...intercepted.advisorAnswer, pick: intercepted.effectiveDecision, pickId: intercepted.pickId,
+              agrees: intercepted.effectiveDecision === taskClass,
+            }] };
+          } else if (intercepted.mode === 'shadow') result = { status: 'shadow', reason: intercepted.warning || null, answers: [] };
+          else if (intercepted.mode === 'off') result = { status: 'off', reason: null, answers: [] };
+          else result = { status: 'unavailable', reason: intercepted.warning || null, answers: [] };
+        }
         opinion = secondOpinion(result, taskClass);
-        if (decision.outcome === CLASSIFICATION_OUTCOMES.ACCEPTED && opinion.status === 'answered' && opinion.pickId) {
-          const found = findPick({ pickId: opinion.pickId, roots });
+        const outcomePickId = opinion.status === 'answered' ? opinion.pickId : recordedPickId;
+        if (decision.outcome === CLASSIFICATION_OUTCOMES.ACCEPTED && outcomePickId) {
+          const found = findPick({ pickId: outcomePickId, roots });
           if (found) appendOutcome({
-            pickId: opinion.pickId, actual: decision.taskClass, source: 'classify-verdict', roots, store: found.store,
+            pickId: outcomePickId, actual: decision.taskClass, source: 'classify-verdict', roots, store: found.store,
           });
         }
       } catch {

package/src/runtime/task-graph.js

@@ -0,0 +1,373 @@
+'use strict';
+
+// TypeScript migration (agent-docs/BRIEF_GOAL_DOFLOW.md): run directly by Node native type-stripping.
+
+// Task graph (feature 080, design C2): the plan's tasks as a dependency graph, validated before any
+// ledger rule reads it.
+//
+// Pure over `parsePlan` output: no file is read and nothing is written here. `buildGraph` collects
+// every IC-003 problem before it returns, so one refusal names everything wrong with a plan rather
+// than the first thing. The cycle search covers the explicit `depends-on:` task edges and the
+// implicit phase edges together (a task with no task dependency waits on every task of an earlier
+// phase, IC-005 row 9): validating explicit edges alone accepts a plan whose phase order and
+// declared dependencies wait on each other forever (design debate A-M1).
+
+const crypto = require('node:crypto');
+const { parsePlan } = require('./scaffold/artifacts.js');
+
+/** IC-008 / DEC-002: the attempt budget of a task that declares no `budget:`. */
+const DEFAULT_TASK_ATTEMPTS = 20;
+
+/** IC-001 acceptance grammar: a requirement, interface contract, story or scenario id. */
+const ACCEPTANCE = [/^(FR|NFR|IC)-\d{3}$/, /^US\d+$/, /^S-[a-z0-9]+(-[a-z0-9]+)*$/];
+
+/** DEC-008: only the `**Task graph:** v1` header makes a plan a graph plan. Accepts a parsed plan
+ * or a graph, both of which carry `graphHeader`. */
+function isGraphPlan(planOrGraph     ) {
+  return Boolean(planOrGraph) && planOrGraph.graphHeader === 'v1';
+}
+
+/** IC-016: a `files:` entry compared after trimming and dropping a leading `./`. */
+function normalizeFile(file        ) {
+  return String(file).trim().replace(/^(\.\/)+/, '');
+}
+
+/**
+ * Explicit and implicit edges out of each task, in plan order. An edge `from -> to` means `from`
+ * waits on `to`. Explicit: each known `taskDeps` value. Implicit (`phase: true`): a task with no
+ * `taskDeps` waits on every task of an earlier phase. Unknown dependencies have no edge; they are
+ * reported as `unknown-dependency` instead.
+ */
+function outEdges(tasks       , byId                  ) {
+  const edges = new Map                                               ();
+  for (const task of tasks) {
+    if (edges.has(task.id)) continue; // a duplicate id: the first occurrence stands for it
+    const out                                        = [];
+    if (task.taskDeps.length) {
+      for (const dep of [...new Set(task.taskDeps            )]) if (byId.has(dep)) out.push({ to: dep, phase: false });
+    } else {
+      for (const other of tasks) {
+        if (other.phaseIndex < task.phaseIndex && !out.some((e) => e.to === other.id)) out.push({ to: other.id, phase: true });
+      }
+    }
+    edges.set(task.id, out);
+  }
+  return edges;
+}
+
+/**
+ * Iterative three-colour depth-first search over `edges`, roots and successors in plan order, so
+ * the cycles reported and their order are deterministic. Returns every distinct cycle closed by a
+ * back edge, and a topological order (dependencies first) that is valid when no cycle exists.
+ */
+function searchCycles(ids          , edges                                                    ) {
+  const WHITE = 0, GREY = 1, BLACK = 2;
+  const colour = new Map                (ids.map((id) => [id, WHITE]));
+  const order           = [];
+  const cycles        = [];
+  const seenCycles = new Set        ();
+
+  for (const root of ids) {
+    if (colour.get(root) !== WHITE) continue;
+    // Each frame: the node, the index of its next edge, and the edge that entered it.
+    const stack                                      = [{ id: root, next: 0 }];
+    const entered                                               = [null];
+    colour.set(root, GREY);
+    while (stack.length) {
+      const frame = stack[stack.length - 1];
+      const out = edges.get(frame.id) || [];
+      if (frame.next >= out.length) {
+        colour.set(frame.id, BLACK);
+        order.push(frame.id);
+        stack.pop();
+        entered.pop();
+        continue;
+      }
+      const edge = out[frame.next++];
+      const state = colour.get(edge.to);
+      if (state === WHITE) {
+        colour.set(edge.to, GREY);
+        stack.push({ id: edge.to, next: 0 });
+        entered.push(edge);
+      } else if (state === GREY) {
+        const start = stack.findIndex((f) => f.id === edge.to);
+        const cycleIds = stack.slice(start).map((f) => f.id);
+        const via           = [];
+        for (let i = start + 1; i < stack.length; i += 1) {
+          via.push(`${stack[i - 1].id}->${stack[i].id}${entered[i] .phase ? ':phase' : ''}`);
+        }
+        via.push(`${frame.id}->${edge.to}${edge.phase ? ':phase' : ''}`);
+        const key = via.join('|');
+        if (!seenCycles.has(key)) {
+          seenCycles.add(key);
+          cycles.push({ kind: 'cycle', ids: cycleIds, via });
+        }
+      }
+    }
+  }
+  return { cycles, order };
+}
+
+/**
+ * The one owner comparison key (plan-check's review-owner warning and the claim's owner check):
+ * the owner without a trailing parenthetical note, trimmed and lowercased. The owner of record stays raw.
+ */
+function normalizeOwner(owner         )         {
+  return String(owner ?? '').replace(/\s*\([^()]*\)\s*$/, '').trim().toLowerCase();
+}
+
+/**
+ * IC-003: `parsePlan` output → `{ ok: true, graph, warnings }` or `{ ok: false, problems }`, with
+ * every problem collected first. The graph keeps the parsed tasks in plan order with `phaseIndex`
+ * (phase order is first appearance), plus `order`, a topological order with dependencies first.
+ */
+function buildGraph(parsed     ) {
+  const graphHeader = parsed.graphHeader === undefined ? null : parsed.graphHeader;
+  const graphPlan = graphHeader === 'v1';
+  const phases           = [...new Set        (parsed.tasks.map((t     ) => t.phase))];
+  const tasks = parsed.tasks.map((t     ) => ({
+    ...t,
+    phaseIndex: phases.indexOf(t.phase),
+    taskDeps: t.taskDeps || [],
+    nearMissDeps: t.nearMissDeps || [],
+    acceptance: t.acceptance || [],
+    budget: t.budget === undefined ? null : t.budget,
+    parallel: Boolean(t.parallel),
+  }));
+  const problems        = [];
+  const warnings        = [];
+
+  if (graphHeader && typeof graphHeader === 'object') problems.push({ kind: 'bad-header', ids: [], value: graphHeader.invalid });
+
+  const byId = new Map             ();
+  const reported = new Set        ();
+  for (const task of tasks) {
+    if (!byId.has(task.id)) { byId.set(task.id, task); continue; }
+    if (!reported.has(task.id)) { reported.add(task.id); problems.push({ kind: 'duplicate-id', ids: [task.id] }); }
+  }
+
+  for (const task of tasks) {
+    for (const dep of task.taskDeps) {
+      if (!byId.has(dep)) problems.push({ kind: 'unknown-dependency', ids: [task.id, dep] });
+    }
+    for (const value of task.nearMissDeps) {
+      if (graphPlan) problems.push({ kind: 'bad-dependency', ids: [task.id], value });
+      else warnings.push({ kind: 'near-miss-dependency', ids: [task.id], value });
+    }
+    for (const value of task.acceptance) {
+      if (!ACCEPTANCE.some((pattern) => pattern.test(value))) problems.push({ kind: 'bad-acceptance', ids: [task.id], value });
+    }
+    // IC-010: quality-guardian is the review hold, so a frontier-tier task there is mis-owned.
+    // A trailing model note such as 'quality-guardian (Opus)' is stripped (`normalizeOwner`); a claim compares owners the same way.
+    if (typeof task.owner === 'string' && normalizeOwner(task.owner) === 'quality-guardian' && task.tier === 'frontier') {
+      warnings.push({ kind: 'review-owner', ids: [task.id], value: 'quality-guardian' });
+    }
+    if (task.budget && typeof task.budget === 'object' && 'invalid' in task.budget) {
+      problems.push({ kind: 'bad-budget', ids: [task.id], value: task.budget.invalid });
+    }
+  }
+
+  const ids = [...byId.keys()];
+  const { cycles, order } = searchCycles(ids, outEdges(tasks, byId));
+  problems.push(...cycles);
+
+  if (problems.length) return { ok: false, problems, warnings };
+  return { ok: true, graph: { graphHeader, graphPlan, phases, tasks, order }, warnings };
+}
+
+/** IC-002: the canonical plan judgment, including plans with no task lines. */
+function planVerdict(text        )   
+              
+                
+                                                                                   
+                     
+  {
+  const parsed = parsePlan(text);
+  const built = buildGraph(parsed);
+  const problems = [...(built.problems || [])];
+  if (parsed.tasks.length === 0) problems.push({ kind: 'no-tasks', ids: [] });
+  const warnings = (built.warnings || []).map((warning     ) => {
+    const detail = warning.via
+      ? ` via ${warning.via.join(', ')}`
+      : warning.value !== undefined ? ` '${warning.value}'` : '';
+    return `${warning.kind}${warning.ids.length ? ` ${warning.ids.join(' ')}` : ''}${detail}`;
+  });
+  return { ok: problems.length === 0, tasks: parsed.tasks.length, problems, warnings };
+}
+
+/** IC-004: one tuple per task in plan order — the structure and declared files, never the
+ * description or the checkbox. */
+function graphTuples(graph     ) {
+  return graph.tasks.map((t     ) => [t.id, t.phase, t.owner, t.taskDeps, t.parallel, t.acceptance, t.budget, t.files]);
+}
+
+/** IC-004: `sha256:` over the tuples' canonical JSON (arrays and one-key objects only, so
+ * `JSON.stringify` is already canonical). */
+function graphDigest(graph     ) {
+  return `sha256:${crypto.createHash('sha256').update(JSON.stringify(graphTuples(graph))).digest('hex')}`;
+}
+
+/** IC-016: every pair of tasks, in plan order, declaring the same `files:` entry after
+ * normalisation, with the shared entries in the first task's declaration order. */
+function overlaps(graph     ) {
+  const declared = graph.tasks.map((t     ) => ({ id: t.id, files: [...new Set        ((t.files || []).map(normalizeFile))].filter(Boolean) }));
+  const pairs                                                   = [];
+  for (let i = 0; i < declared.length; i += 1) {
+    for (let j = i + 1; j < declared.length; j += 1) {
+      const other = new Set(declared[j].files);
+      const files = declared[i].files.filter((f        ) => other.has(f));
+      if (files.length) pairs.push({ a: declared[i].id, b: declared[j].id, files });
+    }
+  }
+  return pairs;
+}
+
+/** IC-008: the task's attempt limit and where it came from. An invalid `budget:` is refused by
+ * `buildGraph`, so here it can only mean the default. */
+function taskAttemptLimit(task     ) {
+  const attempts = task && task.budget && Number.isInteger(task.budget.attempts) ? task.budget.attempts : null;
+  return attempts === null ? { limit: DEFAULT_TASK_ATTEMPTS, source: 'default' } : { limit: attempts, source: 'plan' };
+}
+
+// ── derivation (IC-005, IC-008 `used`, IC-024 done-stale) ─────────────────────────────────────
+
+/** IC-005 `state` → the pre-080 `derived` vocabulary, which legacy flows keep reading. */
+const DERIVED                         = {
+  SUCCEEDED: 'done', RUNNING: 'running', BLOCKED: 'blocked', CANCELLED: 'cancelled',
+  FAILED: 'failed', PLANNED: 'pending', READY: 'ready',
+};
+
+/** A dependency in one of these states holds its dependents (IC-005 rows 7 and 9, `held`). */
+const HOLDING = new Set(['BLOCKED', 'FAILED', 'CANCELLED']);
+
+/** IC-005 "latest ended": the highest-token attempt that is `finished`, `cancelled` or
+ * `superseded`. `released` is skipped, as the pre-080 `latestFinished` skips it (design debate
+ * A-M2): counting it would turn a legacy BLOCKED-then-released task from `blocked` into `ready`. */
+function latestEnded(attempts       ) {
+  let latest      = null;
+  for (const a of attempts) {
+    if (a.state !== 'finished' && a.state !== 'cancelled' && a.state !== 'superseded') continue;
+    if (!latest || a.token > latest.token) latest = a;
+  }
+  return latest;
+}
+
+/** DEC-016 done-attempt-selection (IC-005 Terms): the done attempt is the highest-token `finished`
+ * attempt with result COMPLETED. A store holding one (every legacy and `8ce5ad7` store) is
+ * unchanged; a redo of a stale-done task wins over the stale attempt. */
+function doneOf(attempts       ) {
+  let done      = null;
+  for (const a of attempts) {
+    if (a.state === 'finished' && a.result === 'COMPLETED' && (!done || a.token > done.token)) done = a;
+  }
+  return done;
+}
+
+/** IC-008: attempts carrying a `runKey`, in any state, plus every `superseded` attempt. */
+function attemptsUsed(attempts       ) {
+  return attempts.filter((a     ) => Boolean(a.runKey) || a.state === 'superseded').length;
+}
+
+/** The current line hash of `task`: from `hashes` (a Map or a plain object keyed by task id), else
+ * the `hash` a `loadPlan` task carries. */
+function currentHash(task     , hashes     ) {
+  if (hashes instanceof Map) { if (hashes.has(task.id)) return hashes.get(task.id); }
+  else if (hashes && typeof hashes === 'object' && Object.prototype.hasOwnProperty.call(hashes, task.id)) return hashes[task.id];
+  return task.hash;
+}
+
+/**
+ * IC-005 rows 7 to 9 for one task, against the states already derived for its direct
+ * dependencies: the explicit `taskDeps`, or every task of an earlier phase when there are none.
+ * `held` is direct; a dependency that is PLANNED for its own reason is named in `unmet`.
+ */
+function readinessOf(task     , tasks       , states                     ) {
+  if (task.taskDeps.length) {
+    const deps = [...new Set        (task.taskDeps)];
+    const held = deps.filter((id) => HOLDING.has(states.get(id) )).map((id) => ({ id, state: states.get(id) }));
+    if (held.length) return { reason: 'dependency-held', held };
+    const unmet = deps.filter((id) => states.get(id) !== 'SUCCEEDED');
+    if (unmet.length) return { reason: 'unmet-dependency', unmet };
+    return { reason: 'ready' };
+  }
+  const earlier = tasks.filter((o     ) => o.phaseIndex < task.phaseIndex);
+  const unmet = earlier.filter((o     ) => states.get(o.id) !== 'SUCCEEDED').map((o     ) => o.id);
+  if (!unmet.length) return { reason: 'ready' };
+  const held = earlier.filter((o     ) => HOLDING.has(states.get(o.id) )).map((o     ) => ({ id: o.id, state: states.get(o.id) }));
+  return { reason: 'unmet-phase', unmet, held };
+}
+
+/**
+ * IC-005: one record per task, in plan order, evaluated in `graph.order` (dependencies first) so
+ * each task reads its dependencies' final states. Pure: the store is read, never changed, and the
+ * cleared cancels (a later `resume` of the cancelling run, IC-015) are computed by the caller.
+ *
+ * @param graph `buildGraph(...).graph`
+ * @param store the task-attempt ledger object (`{ tasks: { <id>: { attempts } } }`)
+ * @param options.clearedCancels iterable of `{ taskId, token }` naming cancelled attempts a resume
+ *   has cleared (IC-005 row 4)
+ * @param options.hashes current line hash per task id (Map or object); defaults to each graph
+ *   task's own `hash`. Read only in a graph plan, for a task with a done attempt (IC-024).
+ */
+function deriveTasks(graph     , store     , { clearedCancels = [], hashes = null }                                                                                 = {}) {
+  const graphPlan = isGraphPlan(graph);
+  const cleared = new Set        ();
+  for (const c of clearedCancels || []) cleared.add(`${c.taskId}#${c.token}`);
+  const byId = new Map             (graph.tasks.map((t     ) => [t.id, t]));
+  const states = new Map                ();
+  const records = new Map             ();
+
+  for (const id of graph.order) {
+    const task = byId.get(id);
+    const entry = store && store.tasks ? store.tasks[id] : null;
+    const attempts        = entry && Array.isArray(entry.attempts) ? entry.attempts : [];
+    const active = attempts.find((a     ) => a.state === 'active') || null;
+    let done = doneOf(attempts);
+    let doneStale      = null;
+    if (done && graphPlan) {
+      const hash = currentHash(task, hashes);
+      if (typeof hash !== 'string') throw new TypeError(`deriveTasks: no current line hash for task '${id}'; pass options.hashes or loadPlan tasks`);
+      if (hash !== done.taskLineHash) { doneStale = { token: done.token }; done = null; }
+    }
+    const last = latestEnded(attempts);
+    const { limit, source } = taskAttemptLimit(task);
+    const budget = { limit, used: attemptsUsed(attempts), source };
+
+    let state        , reason        , claimable = false;
+    let readiness      = null;
+    const extra      = {};
+    if (done) { state = 'SUCCEEDED'; reason = 'completed'; }
+    else if (active) { state = 'RUNNING'; reason = 'active-attempt'; }
+    else if (budget.used >= budget.limit) { state = 'BLOCKED'; reason = 'budget'; }
+    else if (last && last.state === 'cancelled' && !cleared.has(`${id}#${last.token}`)) { state = 'CANCELLED'; reason = 'cancelled'; }
+    else {
+      readiness = readinessOf(task, graph.tasks, states);
+      const ready = readiness.reason === 'ready';
+      if (last && last.state === 'finished' && last.result === 'FAILED') { state = 'FAILED'; reason = 'failed'; claimable = ready; }
+      else if (last && last.state === 'finished' && last.result === 'BLOCKED') { state = 'BLOCKED'; reason = 'result-blocked'; claimable = ready; }
+      else if (!ready) {
+        state = 'PLANNED'; reason = readiness.reason;
+        if (readiness.held) extra.held = readiness.held;
+        if (readiness.unmet) extra.unmet = readiness.unmet;
+      } else {
+        state = 'READY'; claimable = true;
+        reason = doneStale ? 'plan-changed-after-done' : last && last.state === 'superseded' ? 'reopened' : 'ready';
+      }
+    }
+    if (doneStale) extra.doneStale = doneStale;
+    states.set(id, state);
+    records.set(id, {
+      id, phase: task.phase, derived: DERIVED[state], state, reason, claimable, budget, ...extra,
+      activeToken: active ? active.token : null,
+      doneToken: done ? done.token : null,
+      active: active ? { owner: active.owner, mode: active.mode, startedAt: active.startedAt } : null,
+      readiness,
+    });
+  }
+  return graph.tasks.map((t     ) => records.get(t.id));
+}
+
+module.exports = {
+  DEFAULT_TASK_ATTEMPTS, buildGraph, planVerdict, isGraphPlan, graphTuples, graphDigest, overlaps, taskAttemptLimit,
+  deriveTasks, doneOf, normalizeOwner,
+};