@mindrian_os/cli 2.0.0-beta.3 → 2.0.0-beta.33

package/lib/workflow/f8-fanout-consumer.cjs

@@ -0,0 +1,208 @@
+'use strict';
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ *
+ * Phase 188-06 -- consumeF8Fanout: the F.8 multi-select FAN-OUT consumer (SFS-03).
+ * ================================================================================
+ * F.1 resolves ONE pick to ONE closeOffer call (lib/workflow/f1-pick-consumer.cjs).
+ * F.8 loops the captured ARRAY and calls the closer PER ITEM on ONE confirm:
+ * 1 confirm -> N typed edges. The per-item body clones consumeF1Pick's two-channel
+ * resolve; the outer loop is the only net-new structure.
+ *
+ * Part 9 chokepoint invariant (the load-bearing rule, f1-pick-consumer.cjs:44-49):
+ * this consumer NEVER opens room.db. The caller owns the handle and passes a
+ * populated roomState.db; every write routes through closeOffer -> navigation.cjs.
+ * No native / node sqlite require; no room-db open of its own (the source-grep in
+ * the suite proves the forbidden requires are absent). A test seam lets the caller
+ * inject roomState.closer (a spy) so a fan-out can be counted WITHOUT a live room.db.
+ *
+ * The two-channel split (MEDIUM-2), preserved PER ITEM:
+ *   (a) OUTCOME CHANNEL: the decision keyword accept|defer|reject|Free-Text is what
+ *       gets passed as closeOffer({pick:<outcome-keyword>}). We pass the OUTCOME
+ *       keyword, NEVER the matched verb -- passing the verb as {pick} would silently
+ *       coerce every reject to accept downstream.
+ *   (b) REACH CHANNEL: the matched verb looks up reach_id from priorPayload.reachIds
+ *       and populates offer.command. Kept EXPLICIT, never conflated.
+ *
+ * Degrade-never-block PER ITEM: a cold / unmatched / malformed / closer-failed item
+ * returns a structured no-op and does NOT abort the rest of the confirmed set. The
+ * fan-out returns an appliedCount (D-09 what's-next re-entry is a downstream family
+ * consumer's job -- NOT wired here; this module ships the fan-out + appliedCount).
+ *
+ * Framework: pure CJS, zero new dependencies (Phase 87 invariant). No em-dashes.
+ * No emoji. No Brain call.
+ *
+ * License: BSL 1.1.
+ */
+
+const path = require('node:path');
+
+const REPO = path.resolve(__dirname, '..', '..');
+
+// Lazy + tolerant require (mirrors f1-pick-consumer): a closer load failure degrades
+// to a structured no-op rather than crashing the turn.
+function _safeRequire(p) {
+  try {
+    return require(p);
+  } catch (_e) {
+    return null;
+  }
+}
+
+// The four canonical dial outcomes. Reused, NOT a parallel enum.
+const OUTCOMES = Object.freeze(['accept', 'defer', 'reject', 'Free-Text']);
+const FREE_TEXT = 'Free-Text';
+
+function _normalizeOutcome(raw) {
+  if (typeof raw !== 'string' || raw.length === 0) return null;
+  if (raw === 'Free-Text' || raw === 'free-text') return 'Free-Text';
+  const lower = raw.toLowerCase();
+  if (lower === 'accept' || lower === 'approve') return 'accept';
+  if (lower === 'defer') return 'defer';
+  if (lower === 'reject') return 'reject';
+  return null;
+}
+
+// Resolve {verb, outcome} from one captured array element. Deterministic; the
+// capture adapter hands us {verb, outcome} (the array shape) or a bare string.
+function _resolvePick(pick) {
+  if (pick && typeof pick === 'object') {
+    const verb = (typeof pick.verb === 'string' && pick.verb.length > 0) ? pick.verb : null;
+    const outcome = _normalizeOutcome(pick.outcome);
+    return { verb, outcome, sentence: (typeof pick.sentence === 'string' && pick.sentence.length > 0) ? pick.sentence : null };
+  }
+  if (typeof pick === 'string' && pick.length > 0) {
+    const outcome = _normalizeOutcome(pick);
+    if (outcome === FREE_TEXT) return { verb: FREE_TEXT, outcome: FREE_TEXT, sentence: null };
+    if (outcome) return { verb: null, outcome, sentence: null };
+    return { verb: pick, outcome: null, sentence: null };
+  }
+  return { verb: null, outcome: null, sentence: null };
+}
+
+// Resolve the closer. The caller MAY inject roomState.closer (a spy or a surface
+// closer) so the fan-out is testable WITHOUT a live room.db (Part 9). Otherwise
+// lazy-require the shipped offer-closer; a load failure degrades to null.
+function _resolveCloser(roomState) {
+  if (roomState && typeof roomState === 'object'
+      && roomState.closer && typeof roomState.closer.closeOffer === 'function') {
+    return roomState.closer;
+  }
+  return _safeRequire(path.join(REPO, 'lib', 'workflow', 'offer-closer.cjs'));
+}
+
+// consumeOne(pick, priorPayload, roomState, closer) -> { ok, reason?, outcome?, reach_id? }
+// Clones the consumeF1Pick per-item body: two-channel resolve + one closeOffer.
+// A no-op returns { ok:false, reason } and writes nothing (degrade-never-block).
+function _consumeOne(pick, priorPayload, roomState, closer) {
+  const resolved = _resolvePick(pick);
+  let verb = resolved.verb;
+  let outcome = resolved.outcome;
+
+  // Deterministic membership match (HOW-2): the matched verb MUST be present in the
+  // rendered card's verbs array. An unmatched pick is a no-op (never a false match).
+  if (verb === null || priorPayload.verbs.indexOf(verb) === -1) {
+    return { ok: false, reason: 'unmatched' };
+  }
+
+  if (verb === FREE_TEXT) {
+    outcome = FREE_TEXT;
+  }
+  if (outcome === null) {
+    outcome = 'accept';
+  }
+  if (OUTCOMES.indexOf(outcome) === -1) {
+    return { ok: false, reason: 'unmatched' };
+  }
+
+  // REACH CHANNEL: the matched verb looks up its reach_id. The escape carries none.
+  let reach_id = null;
+  if (verb !== FREE_TEXT
+      && priorPayload.reachIds
+      && typeof priorPayload.reachIds === 'object'
+      && typeof priorPayload.reachIds[verb] === 'string'
+      && priorPayload.reachIds[verb].length > 0) {
+    reach_id = priorPayload.reachIds[verb];
+  }
+
+  const scaffold = (roomState.offer && typeof roomState.offer === 'object') ? roomState.offer : {};
+  const offer = {
+    command: verb,
+    framework: (typeof scaffold.framework === 'string' && scaffold.framework.length > 0)
+      ? scaffold.framework : undefined,
+    confidence: (typeof scaffold.confidence === 'number') ? scaffold.confidence : undefined,
+    reason: (typeof scaffold.reason === 'string' && scaffold.reason.length > 0)
+      ? scaffold.reason : undefined,
+  };
+
+  // OUTCOME CHANNEL: {pick} is the OUTCOME keyword, NEVER the matched verb.
+  const closeArgs = { pick: outcome, offer: offer, roomState: roomState };
+  if (reach_id) closeArgs.reach_id = reach_id;
+  // Part 8 LOCAL lane: forward the per-element sentence when present.
+  if (resolved.sentence) closeArgs.sentence = resolved.sentence;
+  if (outcome === FREE_TEXT && resolved.sentence) closeArgs.user_intent = resolved.sentence;
+
+  let r;
+  try {
+    r = closer.closeOffer(closeArgs);
+  } catch (_e) {
+    return { ok: false, reason: 'closer_threw' };
+  }
+  if (!r || r.ok !== true) {
+    return { ok: false, reason: (r && r.reason) ? r.reason : 'close_failed' };
+  }
+  const out = { ok: true, recorded: true, outcome: outcome };
+  if (reach_id) out.reach_id = reach_id;
+  return out;
+}
+
+// ---------------------------------------------------------------------------
+// consumeF8Fanout({ priorPayload, picks, roomState })
+//   -> { ok, recorded, appliedCount, items }
+//
+// priorPayload: the prior turn's F.8 closer payload ({ verbs:[...], reachIds?:{} }).
+// picks:        the captured ARRAY ([{verb, outcome, sentence?}, ...]) from the
+//               F.8 array-capture adapter.
+// roomState:    the caller-owned room state; roomState.db MUST be populated by the
+//               caller (this consumer NEVER opens room.db; Part 9). roomState.closer
+//               MAY be injected for testing.
+//
+// Fans out ONE closeOffer PER CONFIRMED item on ONE confirm (N typed edges). One
+// bad item does NOT abort the set (degrade-never-block); appliedCount counts the
+// items that wrote. A cold / empty / closer-absent turn returns a structured no-op.
+// ---------------------------------------------------------------------------
+function consumeF8Fanout(args) {
+  const a = (args && typeof args === 'object') ? args : {};
+  const priorPayload = (a.priorPayload && typeof a.priorPayload === 'object') ? a.priorPayload : null;
+  const roomState = (a.roomState && typeof a.roomState === 'object') ? a.roomState : {};
+  const picks = Array.isArray(a.picks) ? a.picks : null;
+
+  if (!priorPayload || !Array.isArray(priorPayload.verbs) || priorPayload.verbs.length === 0) {
+    return { ok: false, reason: 'no_prior_payload', appliedCount: 0, recorded: 0, items: [] };
+  }
+  if (!picks || picks.length === 0) {
+    return { ok: false, reason: 'no_picks', appliedCount: 0, recorded: 0, items: [] };
+  }
+
+  const closer = _resolveCloser(roomState);
+  if (!closer || typeof closer.closeOffer !== 'function') {
+    return { ok: false, reason: 'closer_unavailable', appliedCount: 0, recorded: 0, items: [] };
+  }
+
+  let appliedCount = 0;
+  const items = [];
+  for (const pick of picks) {
+    const res = _consumeOne(pick, priorPayload, roomState, closer);
+    items.push(res);
+    if (res.ok === true) appliedCount++;
+  }
+
+  // The confirm itself succeeded (the fan-out ran); per-item failures degrade but
+  // never fail the set. ok:true so a downstream re-entry can act on appliedCount.
+  return { ok: true, recorded: appliedCount, appliedCount: appliedCount, items: items };
+}
+
+module.exports = {
+  consumeF8Fanout: consumeF8Fanout,
+  OUTCOMES: OUTCOMES,
+};

package/lib/workflow/f9-consumer.test.cjs

@@ -0,0 +1,71 @@
+'use strict';
+/*
+ * Phase 188-00 Wave 0 -- F.9 ordered consumer behavior stub (SFS-05).
+ * =========================================================================
+ * CONTRACT the Wave-C consumer (lib/workflow/f9-ordered-consumer.cjs) implements
+ * against. RED now (the module does not exist) and GREEN when the ordered consumer
+ * lands. Fails LOUDLY on module-not-found.
+ *
+ * What the F.9 consumer is: it walks the cascade in order and applies each item's
+ * ordered outcome (Decision 13, "rejection is data"):
+ *   APPROVE -> write the edge,
+ *   REJECT  -> record NOT-applied + reason (the reason becomes a graph node),
+ *   DEFER   -> leave a CONTRADICTS-linked competing-claim pair.
+ *
+ * Part 9 chokepoint invariant: the consumer NEVER opens room.db (same source
+ * assertion as the F.8 fan-out). The caller passes roomState.db; every write
+ * routes through the injectable closer / navigation.cjs.
+ *
+ * House rule: hyphens only, no em-dashes. Node built-ins only, zero deps.
+ */
+
+const assert = require('node:assert');
+const fs = require('node:fs');
+const path = require('node:path');
+
+let pass = 0;
+function ok(name, cond) { assert.ok(cond, name); console.log('  ok - ' + name); pass++; }
+
+// RED-loud: the module must exist.
+const mod = require('./f9-ordered-consumer.cjs');
+ok('module exports consumeF9Ordered', typeof mod.consumeF9Ordered === 'function');
+
+// ---- Part 9 source assertion: NO self-opened room.db ----
+const src = fs.readFileSync(path.join(__dirname, 'f9-ordered-consumer.cjs'), 'utf8');
+ok('consumer does NOT require better-sqlite3', src.indexOf('better-sqlite3') === -1);
+ok('consumer does NOT require node:sqlite', src.indexOf('node:sqlite') === -1);
+ok('consumer does NOT open room.db itself',
+  src.indexOf('.openRoomDb(') === -1 && src.indexOf('openRoomDbForCaller') === -1);
+
+// ---- ordered outcomes: APPROVE writes edge, REJECT records reason, DEFER leaves CONTRADICTS pair ----
+const writes = [];
+const spy = {
+  writeEdge: function (e) { writes.push({ kind: 'edge', edge: e }); return { ok: true }; },
+  recordRejection: function (r) { writes.push({ kind: 'rejection', reason: r }); return { ok: true }; },
+  leaveContradictsPair: function (p) { writes.push({ kind: 'contradicts', pair: p }); return { ok: true }; },
+};
+const items = [
+  { claim: 'A implies B', outcome: 'APPROVE' },
+  { claim: 'B is unsupported', outcome: 'REJECT', reason: 'no evidence' },
+  { claim: 'C competes with A', outcome: 'DEFER' },
+];
+const roomState = { db: { __fake__: true }, graph: spy };
+const result = mod.consumeF9Ordered({ items: items, roomState: roomState });
+
+ok('all three ordered items were consumed',
+  result && result.ok === true && (result.applied === items.length || (Array.isArray(result.items) && result.items.length === items.length)));
+
+// APPROVE writes the edge.
+ok('APPROVE writes an edge', writes.some((w) => w.kind === 'edge'));
+
+// REJECT records NOT-applied + the reason (rejection is data).
+const rej = writes.find((w) => w.kind === 'rejection');
+ok('REJECT records a NOT-applied reason (Decision 13: rejection is data)',
+  rej && JSON.stringify(rej).indexOf('no evidence') !== -1);
+
+// DEFER leaves a CONTRADICTS-linked competing-claim pair.
+ok('DEFER leaves a CONTRADICTS-linked competing-claim pair',
+  writes.some((w) => w.kind === 'contradicts'));
+
+console.log('\nPASS f9-consumer.test (' + pass + ' assertions)');
+console.log('>>> f9-consumer.test.cjs: PASSED');

package/lib/workflow/f9-ordered-consumer.cjs

@@ -0,0 +1,199 @@
+'use strict';
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ *
+ * Phase 188-07 -- consumeF9Ordered: the F.9 ordered cascade consumer (SFS-05).
+ * ================================================================================
+ * F.8's fan-out (lib/workflow/f8-fanout-consumer.cjs) loops an UNORDERED confirmed
+ * set and writes N edges on ONE confirm. F.9 walks the cascade IN ORDER (array order
+ * IS meaning) and applies each item's ORDERED outcome (Decision 13, "rejection is
+ * data"):
+ *   APPROVE -> write the edge,
+ *   REJECT  -> record NOT-applied + the reason (the reason becomes a graph node),
+ *   DEFER   -> leave a CONTRADICTS-linked competing-claim pair (both claims survive).
+ * The outer ordered loop clones the F.8 fan-out; the three-way per-item resolve is
+ * the only net-new structure.
+ *
+ * Part 9 chokepoint invariant (the load-bearing rule, f8-fanout-consumer.cjs:11-17):
+ * this consumer NEVER opens room.db. The caller owns the handle and passes a
+ * populated roomState.db; every write routes through lib/core/navigation.cjs (the
+ * single SQL chokepoint) via the resolved graph writer. No native / node sqlite
+ * require; no room-db open of its own (the source-grep in the suite proves the
+ * forbidden requires are absent). A test seam lets the caller inject roomState.graph
+ * (a spy) so the three ordered outcomes can be counted WITHOUT a live room.db.
+ *
+ * Degrade-never-block PER ITEM: a malformed / unmatched / writer-failed item returns
+ * a structured no-op and does NOT abort the rest of the ordered cascade. The consumer
+ * returns an applied count + a per-item result array (order preserved).
+ *
+ * SEED-039 is the CONSUMER of F.9, NOT its owner: the version-stamp / multi-session
+ * reconcile machinery is DEFERRED and is deliberately NOT imported here. This module
+ * ships F.9 the SHAPE; the multi-session reconcile rides it later.
+ *
+ * Framework: pure CJS, zero new dependencies (Phase 87 invariant). No em-dashes.
+ * No emoji. No Brain call.
+ *
+ * License: BSL 1.1.
+ */
+
+const path = require('node:path');
+
+const REPO = path.resolve(__dirname, '..', '..');
+
+// Lazy + tolerant require (mirrors the F.8 fan-out): a navigation load failure
+// degrades to a structured no-op rather than crashing the turn.
+function _safeRequire(p) {
+  try {
+    return require(p);
+  } catch (_e) {
+    return null;
+  }
+}
+
+// The closed ordered-outcome vocabulary (canon literal tokens). Reused, NOT a
+// parallel enum -- it folds onto the four-outcome OUTCOMES via _normalizeOrdered.
+const ORDERED_OUTCOMES = Object.freeze(['APPROVE', 'REJECT', 'DEFER']);
+
+// The edge type a DEFER leaves: BOTH claims survive as competing claims linked by a
+// CONTRADICTS edge (Decision 13; the reconcile happens later, the drop never does).
+const CONTRADICTS = 'CONTRADICTS';
+
+function _normalizeOrdered(raw) {
+  if (typeof raw !== 'string' || raw.length === 0) return null;
+  const lower = raw.toLowerCase();
+  if (lower === 'approve' || lower === 'accept') return 'APPROVE';
+  if (lower === 'reject') return 'REJECT';
+  if (lower === 'defer') return 'DEFER';
+  return null;
+}
+
+// Resolve { item_id, outcome, reason, sentence, claim } from one ordered element.
+function _resolveItem(raw, index) {
+  if (!raw || typeof raw !== 'object') {
+    return { item_id: 'item:' + String(index), outcome: null, reason: null, sentence: null, claim: null };
+  }
+  const item_id = (typeof raw.item_id === 'string' && raw.item_id.length > 0)
+    ? raw.item_id
+    : ((typeof raw.id === 'string' && raw.id.length > 0) ? raw.id : 'item:' + String(index));
+  const outcome = _normalizeOrdered(raw.outcome);
+  const reason = (typeof raw.reason === 'string' && raw.reason.length > 0) ? raw.reason : null;
+  const sentence = (typeof raw.sentence === 'string' && raw.sentence.length > 0) ? raw.sentence : null;
+  const claim = (typeof raw.claim === 'string' && raw.claim.length > 0)
+    ? raw.claim
+    : ((typeof raw.label === 'string' && raw.label.length > 0) ? raw.label : null);
+  return { item_id, outcome, reason, sentence, claim };
+}
+
+// Resolve the graph writer. The caller MAY inject roomState.graph (a spy or a surface
+// writer exposing writeEdge / recordRejection / leaveContradictsPair) so the ordered
+// walk is testable WITHOUT a live room.db (Part 9). Otherwise build a thin adapter
+// over navigation.cjs -- the single SQL chokepoint -- that NEVER opens room.db and
+// writes only over the caller-supplied roomState.db handle.
+function _resolveGraph(roomState) {
+  const injected = roomState && typeof roomState === 'object' ? roomState.graph : null;
+  if (injected && typeof injected.writeEdge === 'function'
+      && typeof injected.recordRejection === 'function'
+      && typeof injected.leaveContradictsPair === 'function') {
+    return injected;
+  }
+
+  // Production adapter: route every write through navigation.cjs (the chokepoint).
+  // The consumer opens NO room.db; it forwards the caller-owned db handle only.
+  const nav = _safeRequire(path.join(REPO, 'lib', 'core', 'navigation.cjs'));
+  if (!nav || typeof nav.writeEdge !== 'function') return null;
+  const db = roomState && typeof roomState === 'object' ? roomState.db : null;
+
+  return {
+    // APPROVE: write the cascade edge over the caller-owned handle.
+    writeEdge: function (edge) {
+      return nav.writeEdge(Object.assign({ db: db }, edge));
+    },
+    // REJECT: record NOT-applied + reason (rejection is data) as a typed edge.
+    recordRejection: function (rej) {
+      return nav.writeEdge(Object.assign({ db: db, type: 'NOT_APPLIED' }, rej));
+    },
+    // DEFER: leave BOTH claims as a CONTRADICTS-linked competing pair.
+    leaveContradictsPair: function (pair) {
+      return nav.writeEdge(Object.assign({ db: db, type: CONTRADICTS }, pair));
+    },
+  };
+}
+
+// consumeOne(item, graph) -> { ok, item_id, outcome, reason?, kind }
+// Applies the ordered three-way resolve for ONE cascade item over the resolved graph
+// writer. A no-op returns { ok:false, reason } and writes nothing (degrade-never-block).
+function _consumeOne(item, graph) {
+  const outcome = item.outcome;
+  if (outcome === null || ORDERED_OUTCOMES.indexOf(outcome) === -1) {
+    return { ok: false, item_id: item.item_id, outcome: null, reason: 'unmatched' };
+  }
+
+  try {
+    if (outcome === 'APPROVE') {
+      // APPROVE writes the edge.
+      const r = graph.writeEdge({ item_id: item.item_id, claim: item.claim, sentence: item.sentence });
+      if (!r || r.ok !== true) return { ok: false, item_id: item.item_id, outcome: outcome, reason: (r && r.reason) ? r.reason : 'write_failed' };
+      return { ok: true, item_id: item.item_id, outcome: outcome, kind: 'edge' };
+    }
+    if (outcome === 'REJECT') {
+      // REJECT records NOT-applied + the reason (Decision 13: rejection is data).
+      const r = graph.recordRejection({ item_id: item.item_id, claim: item.claim, reason: item.reason || null });
+      if (!r || r.ok !== true) return { ok: false, item_id: item.item_id, outcome: outcome, reason: (r && r.reason) ? r.reason : 'write_failed' };
+      return { ok: true, item_id: item.item_id, outcome: outcome, kind: 'rejection', reason: item.reason || null };
+    }
+    // DEFER leaves a CONTRADICTS-linked competing-claim pair (both survive).
+    const r = graph.leaveContradictsPair({ item_id: item.item_id, claim: item.claim, edge_type: CONTRADICTS });
+    if (!r || r.ok !== true) return { ok: false, item_id: item.item_id, outcome: outcome, reason: (r && r.reason) ? r.reason : 'write_failed' };
+    return { ok: true, item_id: item.item_id, outcome: outcome, kind: 'contradicts' };
+  } catch (_e) {
+    return { ok: false, item_id: item.item_id, outcome: outcome, reason: 'writer_threw' };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// consumeF9Ordered({ items, roomState }) -> { ok, applied, items }
+//
+// items:     the ORDERED cascade ([{ item_id?, claim?, outcome, reason? }, ...]) from
+//            the F.9 ordered-capture adapter. Array order IS meaning (walked in order).
+// roomState: the caller-owned room state; roomState.db MUST be populated by the
+//            caller (this consumer NEVER opens room.db; Part 9). roomState.graph MAY
+//            be injected (writeEdge / recordRejection / leaveContradictsPair) for tests.
+//
+// Walks the cascade IN ORDER and applies each item's ordered outcome: APPROVE writes
+// the edge, REJECT records the reason, DEFER leaves a CONTRADICTS pair. One bad item
+// does NOT abort the cascade (degrade-never-block); `applied` counts the items that
+// wrote. A cold / empty / graph-absent turn returns a structured no-op.
+// ---------------------------------------------------------------------------
+function consumeF9Ordered(args) {
+  const a = (args && typeof args === 'object') ? args : {};
+  const roomState = (a.roomState && typeof a.roomState === 'object') ? a.roomState : {};
+  const rawItems = Array.isArray(a.items) ? a.items : null;
+
+  if (!rawItems || rawItems.length === 0) {
+    return { ok: false, reason: 'no_items', applied: 0, items: [] };
+  }
+
+  const graph = _resolveGraph(roomState);
+  if (!graph) {
+    return { ok: false, reason: 'graph_unavailable', applied: 0, items: [] };
+  }
+
+  let applied = 0;
+  const results = [];
+  for (let i = 0; i < rawItems.length; i++) {
+    const item = _resolveItem(rawItems[i], i);
+    const res = _consumeOne(item, graph);
+    results.push(res);
+    if (res.ok === true) applied++;
+  }
+
+  // The confirm itself succeeded (the ordered walk ran); per-item failures degrade
+  // but never fail the cascade. ok:true so a downstream reconcile can act on `applied`.
+  return { ok: true, applied: applied, items: results };
+}
+
+module.exports = {
+  consumeF9Ordered: consumeF9Ordered,
+  ORDERED_OUTCOMES: ORDERED_OUTCOMES,
+  CONTRADICTS: CONTRADICTS,
+};