@cohortapp/agent-sdk 2.3.1 → 2.4.0

package/lib/execution/match.mjs

@@ -0,0 +1,331 @@
+/**
+ * lib/execution/match.mjs — bind a directed event to the obligation that covers it.
+ *
+ * `disposition.decide` takes an `obligation` argument and changes its behaviour
+ * sharply on it: with one, the event is planned work and may route up the rungs
+ * on the obligation's tool scope and budget; without one, `finish()` caps the
+ * rung at ≤1 and opens `PlanDrift{uncovered_event}`. Nothing in the tree has
+ * ever supplied that argument — the compiler emits REACT obligations with a
+ * `trigger {topic, kind, predicate}` (lib/plan/compile.mjs) and nobody reads
+ * them back. Every event therefore looks uncovered, which makes the drift signal
+ * useless and pins the whole reactive lane at rung 1.
+ *
+ * This module is that missing read. It is the second half of the §6.1 step
+ * "match a REACT obligation by (topic, kind, predicate)", and it also produces
+ * the OTHER half of the same sentence — the proposed REACT obligation an
+ * uncovered event should generate, "so the plan learns instead of ossifying".
+ *
+ * Matching is DETERMINISTIC and explains itself. Two obligations that both match
+ * are ordered by specificity and then by key, so the same event always binds to
+ * the same obligation, and `why[]` says which lost and why.
+ *
+ * PURE apart from {@link loadReactObligations}, which reads `config/plan.yaml`
+ * through the loader `lib/plan/explain.mjs` already owns.
+ *
+ * @module lib/execution/match
+ */
+
+"use strict";
+
+import { readPlan } from "../plan/explain.mjs";
+import { validateObligation } from "../plan/schema.mjs";
+import { policyFor } from "./surface-policy.mjs";
+
+/** Obligation statuses that may bind an event. `suspended`/`proposed` may not. */
+export const BINDABLE_STATUSES = Object.freeze(["active"]);
+
+/**
+ * Predicate fields a REACT trigger may constrain. Deliberately small and
+ * CLOSED: a predicate naming anything else does not match, and says so, rather
+ * than being ignored — an unmatchable predicate that silently passes would bind
+ * events the plan never intended to cover.
+ */
+export const PREDICATE_FIELDS = Object.freeze([
+  "surface",
+  "reason",
+  "tier",
+  "actor",
+  "family",
+  "kind",
+  "topic",
+  "channelId",
+  "objectiveId",
+]);
+
+/** Blank-safe string. */
+function s(v) {
+  return v == null ? "" : String(v);
+}
+
+/**
+ * The set of `kind` tokens an event can legitimately answer a trigger with.
+ *
+ * A raw chain event has chain coordinates (`family:"board", kind:"assigned"`),
+ * but the same event reconstructed from a flattened inbox item has the SURFACE
+ * as its kind (`task_assigned`) because that is all `raw_ref` preserved. Both
+ * must bind the obligation `{topic:"task", kind:"assigned"}` or an event's
+ * coverage would depend on which delivery path it happened to arrive by.
+ *
+ * @param {object} candidate @param {object} verdict @returns {string[]}
+ */
+export function kindAliases(candidate = {}, verdict = {}) {
+  const out = new Set();
+  const kind = s(candidate.kind);
+  const surface = s(verdict.surface);
+  if (kind) {
+    out.add(kind);
+    // "messaging.send" → "send"; a legacy dotted kind that skipped coordsOf.
+    if (kind.includes(".")) out.add(kind.slice(kind.indexOf(".") + 1));
+    // "task_assigned" → "assigned"
+    if (kind.includes("_")) out.add(kind.slice(kind.indexOf("_") + 1));
+  }
+  if (surface) {
+    out.add(surface);
+    if (surface.includes("_")) out.add(surface.slice(surface.indexOf("_") + 1));
+  }
+  out.delete("");
+  return Array.from(out);
+}
+
+/** The flat field view a predicate is evaluated against. */
+export function predicateView(candidate = {}, verdict = {}, extra = {}) {
+  const ids = candidate.ids && typeof candidate.ids === "object" ? candidate.ids : {};
+  return {
+    surface: s(verdict.surface),
+    reason: s(verdict.reason),
+    tier: s(extra.tier),
+    actor: s(candidate.actor),
+    family: s(candidate.family),
+    kind: s(candidate.kind),
+    topic: s(candidate.topic),
+    channelId: s(ids.channelId),
+    objectiveId: s(extra.objectiveId),
+  };
+}
+
+/**
+ * Evaluate a trigger predicate. Returns `{ok, why}`.
+ *
+ * Accepts `null`/absent (always matches), an object of `field: value` (all must
+ * match; a value may be an array, meaning "any of"), and nothing else. A
+ * predicate shape this does not understand FAILS the match and names itself in
+ * `why` — fail-closed, because the alternative is an obligation binding traffic
+ * its author scoped away.
+ *
+ * @param {object|null|undefined} predicate
+ * @param {object} view
+ * @returns {{ok:boolean, why:string}}
+ */
+export function evalPredicate(predicate, view) {
+  if (predicate == null) return { ok: true, why: "no predicate" };
+  if (typeof predicate !== "object" || Array.isArray(predicate)) {
+    return { ok: false, why: `predicate is a ${Array.isArray(predicate) ? "array" : typeof predicate}, not a field map — cannot evaluate` };
+  }
+  const entries = Object.entries(predicate);
+  if (entries.length === 0) return { ok: true, why: "empty predicate" };
+  for (const [field, want] of entries) {
+    if (!PREDICATE_FIELDS.includes(field)) {
+      return { ok: false, why: `predicate names unknown field "${field}" (known: ${PREDICATE_FIELDS.join(", ")})` };
+    }
+    const got = s(view[field]);
+    const list = Array.isArray(want) ? want.map(s) : [s(want)];
+    if (!list.includes(got)) {
+      return { ok: false, why: `predicate ${field}=${list.join("|")} but event has "${got}"` };
+    }
+  }
+  return { ok: true, why: `predicate matched on ${entries.map(([k]) => k).join(", ")}` };
+}
+
+/** The REACT obligations in a plan, in key order. */
+export function reactObligations(plan) {
+  const list = plan && Array.isArray(plan.obligations) ? plan.obligations : [];
+  return list
+    .filter((o) => o && o.kind === "REACT")
+    .slice()
+    .sort((a, b) => (s(a.key) < s(b.key) ? -1 : s(a.key) > s(b.key) ? 1 : 0));
+}
+
+/**
+ * Find the obligation covering one directed event.
+ *
+ * Specificity order, most specific first: an obligation constraining kind AND a
+ * predicate beats one constraining kind alone, which beats a topic-only
+ * catch-all. Ties break on the key so the choice is reproducible.
+ *
+ * @param {object} o
+ * @param {object} o.candidate
+ * @param {object} o.verdict
+ * @param {object[]|object} o.plan       a plan object or a bare obligations array
+ * @param {string} [o.tier]              T0/T1, for predicates that constrain it
+ * @returns {{obligation:object|null, why:string[], considered:number, suspended:object[]}}
+ */
+export function matchObligation(o = {}) {
+  const why = [];
+  const candidate = o.candidate && typeof o.candidate === "object" ? o.candidate : null;
+  const verdict = o.verdict && typeof o.verdict === "object" ? o.verdict : null;
+  const plan = Array.isArray(o.plan) ? { obligations: o.plan } : o.plan;
+  const suspended = [];
+
+  if (!candidate || !verdict || verdict.directed !== true) {
+    why.push("no directed event to match — an undirected event needs no obligation");
+    return { obligation: null, why, considered: 0, suspended };
+  }
+  const reacts = reactObligations(plan);
+  if (reacts.length === 0) {
+    why.push("the compiled plan contains no REACT obligations — every event will read as uncovered");
+    return { obligation: null, why, considered: 0, suspended };
+  }
+
+  const topic = s(candidate.topic);
+  const surface = s(verdict.surface);
+  const aliases = kindAliases(candidate, verdict);
+  const view = predicateView(candidate, verdict, { tier: o.tier, objectiveId: o.objectiveId });
+
+  const hits = [];
+  for (const ob of reacts) {
+    const trig = ob.trigger && typeof ob.trigger === "object" ? ob.trigger : null;
+    if (!trig || !trig.topic) continue; // schema already rejects these; skip quietly
+    const wantTopic = s(trig.topic);
+    // A trigger may be written against the coarse topic ("task") or against the
+    // surface ("task_assigned"). Both are legitimate ways to say the same thing.
+    if (wantTopic !== topic && wantTopic !== surface) continue;
+
+    const wantKind = trig.kind == null ? null : s(trig.kind);
+    if (wantKind !== null && !aliases.includes(wantKind)) continue;
+
+    const pred = evalPredicate(trig.predicate, view);
+    if (!pred.ok) {
+      why.push(`${ob.key}: topic/kind matched but ${pred.why}`);
+      continue;
+    }
+
+    if (!BINDABLE_STATUSES.includes(s(ob.status))) {
+      // NEVER SILENT. A suspended obligation matching is materially different
+      // from nothing matching: the plan DOES cover this event, it is just
+      // switched off, and a reader must not confuse that with a coverage gap.
+      suspended.push(ob);
+      why.push(`${ob.key} covers this event but is status "${s(ob.status) || "(none)"}" → not bindable`);
+      continue;
+    }
+
+    const specificity = (wantKind !== null ? 2 : 0) + (trig.predicate ? 1 : 0);
+    hits.push({ ob, specificity });
+  }
+
+  if (hits.length === 0) {
+    why.push(
+      suspended.length
+        ? `no bindable REACT obligation (${suspended.length} matched but suspended)`
+        : `no REACT obligation covers topic "${topic}"/surface "${surface}" kind ${JSON.stringify(aliases)}`,
+    );
+    return { obligation: null, why, considered: reacts.length, suspended };
+  }
+
+  hits.sort((a, b) => (b.specificity - a.specificity) || (s(a.ob.key) < s(b.ob.key) ? -1 : 1));
+  const winner = hits[0].ob;
+  why.push(`bound to ${winner.key} (specificity ${hits[0].specificity} of ${hits.length} match(es))`);
+  for (const h of hits.slice(1)) why.push(`also matched, less specific: ${h.ob.key}`);
+  return { obligation: winner, why, considered: reacts.length, suspended };
+}
+
+/**
+ * The proposed REACT obligation an uncovered event should generate.
+ *
+ * §6.1: a T0/T1 event with no matching obligation is handled once at rung ≤1
+ * **and** emits both a drift record and a proposed obligation. The drift half
+ * already exists in `disposition.finish`; this is the half that lets the plan
+ * actually learn — a human reviewing `state/plan/proposed.jsonl` sees a
+ * ready-to-adopt obligation rather than a complaint.
+ *
+ * Emitted with `status:"proposed"` and an EMPTY `uses[]`: the capability law
+ * (§5.1) says an obligation may not cite a capability without a reachable
+ * manifest entry, and nothing here has probed one. It is validated against the
+ * real schema before being returned, so an invalid proposal is dropped loudly
+ * rather than written to the proposal file for a human to trip over.
+ *
+ * @param {object} o { candidate, verdict, tier }
+ * @returns {{obligation:object|null, errors:string[], why:string}}
+ */
+export function proposeReact(o = {}) {
+  const candidate = o.candidate && typeof o.candidate === "object" ? o.candidate : {};
+  const verdict = o.verdict && typeof o.verdict === "object" ? o.verdict : {};
+  const surface = s(verdict.surface);
+  const topic = s(candidate.topic) || surface;
+  if (!topic) {
+    return { obligation: null, errors: ["no topic or surface to propose against"], why: "unclassified event" };
+  }
+  const kind = s(candidate.kind) || surface || null;
+  const slug = (v) => s(v).toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  const key = `react.${slug(topic)}${kind ? `.${slug(kind)}` : ""}`;
+  const policy = policyFor(surface);
+
+  const obligation = {
+    key,
+    kind: "REACT",
+    source: { origin: "react-standard", ref: null, proposed_from: { surface, reason: s(verdict.reason), tier: s(o.tier) } },
+    trigger: { topic, kind, predicate: surface ? { surface } : null },
+    status: "proposed",
+    uses: [],
+    allowed_tools: [],
+    action_classes: Array.from(policy.actionClasses || []),
+    offline_safe: policy.offlineSafe !== false,
+    budget_cents_per_period: null,
+  };
+
+  const errors = validateObligation(obligation);
+  if (errors.length) {
+    return { obligation: null, errors, why: `proposal failed schema validation: ${errors.join("; ")}` };
+  }
+  return { obligation, errors: [], why: `proposing ${key} to cover the uncovered ${surface || topic} event` };
+}
+
+/**
+ * Load the REACT obligations from `config/plan.yaml`.
+ *
+ * Async only because the YAML loader is a dynamic import — `lib/plan/explain.mjs`
+ * takes the same approach so there is one plan-reading path, not two. Never
+ * throws: a missing or unparseable plan returns an empty list WITH a reason, and
+ * an agent with no compiled plan legitimately has none (§5.9 — until a human
+ * adopts, the agent runs standard cadences only).
+ *
+ * @param {string} agentRoot
+ * @param {object} [deps]
+ * @returns {Promise<{obligations:object[], enforcement:string|null, degraded:boolean, reason:string|null}>}
+ */
+export async function loadReactObligations(agentRoot, deps = {}) {
+  let yaml = deps.yaml || null;
+  if (!yaml) {
+    try {
+      yaml = (await import("js-yaml")).default;
+    } catch (err) {
+      return {
+        obligations: [],
+        enforcement: null,
+        degraded: true,
+        reason: `js-yaml unavailable: ${err && err.message ? err.message : String(err)}`,
+      };
+    }
+  }
+  const plan = (deps.readPlan || readPlan)(agentRoot, { ...deps, yaml });
+  if (!plan) {
+    return { obligations: [], enforcement: null, degraded: true, reason: "config/plan.yaml absent or unparseable" };
+  }
+  return {
+    obligations: reactObligations(plan),
+    enforcement: plan.enforcement ? s(plan.enforcement) : null,
+    degraded: false,
+    reason: null,
+  };
+}
+
+export default {
+  matchObligation,
+  proposeReact,
+  reactObligations,
+  loadReactObligations,
+  kindAliases,
+  predicateView,
+  evalPredicate,
+  BINDABLE_STATUSES,
+  PREDICATE_FIELDS,
+};

package/lib/execution/match.test.mjs

@@ -0,0 +1,235 @@
+/**
+ * lib/execution/match.test.mjs — binding events to the compiled plan.
+ *
+ * The negatives here are the ones that keep the plan honest: a suspended
+ * obligation must NOT bind (and must not look like a coverage gap either), an
+ * unparseable predicate must fail closed rather than matching everything, and an
+ * event genuinely nobody planned for must produce a proposal the schema accepts.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  matchObligation,
+  proposeReact,
+  reactObligations,
+  kindAliases,
+  evalPredicate,
+  predicateView,
+  loadReactObligations,
+  PREDICATE_FIELDS,
+} from "./match.mjs";
+import { validateObligation } from "../plan/schema.mjs";
+import { fromInboxItem } from "./intake.mjs";
+import { decide } from "./disposition.mjs";
+
+const ME = "mem_self";
+
+function ob(over = {}) {
+  return {
+    key: "react.task.assigned",
+    kind: "REACT",
+    source: { origin: "react-standard" },
+    trigger: { topic: "task", kind: "assigned", predicate: null },
+    status: "active",
+    uses: [],
+    allowed_tools: [],
+    action_classes: [],
+    offline_safe: true,
+    ...over,
+  };
+}
+
+function boardEvent() {
+  return {
+    candidate: {
+      seq: 90,
+      family: "board",
+      kind: "assigned",
+      entityId: "task_1",
+      actor: "mem_peer",
+      at: "2026-08-11T09:00:00.000Z",
+      topic: "task",
+      surfaces: ["task_assigned"],
+      ids: { taskId: "task_1", channelId: "chan_1" },
+      directTo: [ME],
+      payload: {},
+    },
+    verdict: { directed: true, surface: "task_assigned", reason: "assignee" },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// aliases + predicates
+// ---------------------------------------------------------------------------
+
+test("kind aliases bridge chain coordinates and surface names", () => {
+  const a = kindAliases({ kind: "assigned" }, { surface: "task_assigned" });
+  assert.ok(a.includes("assigned"));
+  assert.ok(a.includes("task_assigned"));
+  // The reconstructed-from-disk form must reach the same obligation.
+  const b = kindAliases({ kind: "task_assigned" }, { surface: "task_assigned" });
+  assert.ok(b.includes("assigned"), "an event rebuilt from a flattened item must still bind");
+});
+
+test("a predicate matches on a known field, including any-of lists", () => {
+  const view = predicateView({ actor: "mem_peer", topic: "task" }, { surface: "task_assigned", reason: "assignee" });
+  assert.equal(evalPredicate(null, view).ok, true);
+  assert.equal(evalPredicate({}, view).ok, true);
+  assert.equal(evalPredicate({ surface: "task_assigned" }, view).ok, true);
+  assert.equal(evalPredicate({ reason: ["assignee", "reviewer"] }, view).ok, true);
+  assert.equal(evalPredicate({ reason: "reviewer" }, view).ok, false);
+});
+
+test("NEGATIVE: a predicate this module cannot evaluate FAILS CLOSED", () => {
+  const view = predicateView({}, {});
+  const unknown = evalPredicate({ mood: "urgent" }, view);
+  assert.equal(unknown.ok, false, "an unknown field must not be ignored — that would widen the obligation");
+  assert.ok(unknown.why.includes("mood"));
+  assert.equal(evalPredicate("reason=mention", view).ok, false, "a string predicate is not a field map");
+  assert.equal(evalPredicate([{ surface: "dm" }], view).ok, false);
+  for (const f of PREDICATE_FIELDS) assert.equal(evalPredicate({ [f]: "" }, view).ok, true, `${f} should compare blank-to-blank`);
+});
+
+// ---------------------------------------------------------------------------
+// matching
+// ---------------------------------------------------------------------------
+
+test("an event binds the obligation whose trigger covers it", () => {
+  const r = matchObligation({ ...boardEvent(), plan: [ob()] });
+  assert.equal(r.obligation.key, "react.task.assigned");
+  assert.ok(r.why.join(" ").includes("bound to react.task.assigned"));
+});
+
+test("a trigger may be written against the surface as well as the coarse topic", () => {
+  const r = matchObligation({ ...boardEvent(), plan: [ob({ key: "react.surface", trigger: { topic: "task_assigned", kind: null } })] });
+  assert.equal(r.obligation.key, "react.surface");
+});
+
+test("the most specific match wins, deterministically", () => {
+  const broad = ob({ key: "react.task.any", trigger: { topic: "task", kind: null, predicate: null } });
+  const narrow = ob({ key: "react.task.assigned", trigger: { topic: "task", kind: "assigned", predicate: { reason: "assignee" } } });
+  const a = matchObligation({ ...boardEvent(), plan: [broad, narrow] });
+  const b = matchObligation({ ...boardEvent(), plan: [narrow, broad] });
+  assert.equal(a.obligation.key, "react.task.assigned");
+  assert.equal(b.obligation.key, a.obligation.key, "input order must not change the binding");
+  assert.ok(a.why.some((w) => w.includes("also matched, less specific")));
+});
+
+test("NEGATIVE: a suspended obligation does not bind, and does not read as a coverage gap", () => {
+  const r = matchObligation({ ...boardEvent(), plan: [ob({ status: "suspended" })] });
+  assert.equal(r.obligation, null);
+  assert.deepEqual(r.suspended.map((x) => x.key), ["react.task.assigned"]);
+  assert.ok(r.why.join(" ").includes('status "suspended"'), "the reason must distinguish suspended from uncovered");
+});
+
+test("NEGATIVE: a proposed obligation is not bindable either", () => {
+  const r = matchObligation({ ...boardEvent(), plan: [ob({ status: "proposed" })] });
+  assert.equal(r.obligation, null);
+});
+
+test("NEGATIVE: an undirected event is never matched", () => {
+  const r = matchObligation({
+    candidate: boardEvent().candidate,
+    verdict: { directed: false, reason: "ambient_channel", surface: null },
+    plan: [ob({ trigger: { topic: "task", kind: null } })],
+  });
+  assert.equal(r.obligation, null);
+  assert.ok(r.why[0].includes("no directed event"));
+});
+
+test("NEGATIVE: a plan with no REACT obligations says so rather than failing silently", () => {
+  const r = matchObligation({ ...boardEvent(), plan: [{ key: "schedule.x", kind: "SCHEDULE" }] });
+  assert.equal(r.obligation, null);
+  assert.ok(r.why.join(" ").includes("no REACT obligations"));
+});
+
+test("SCHEDULE and OUTCOME obligations are never considered for an inbound event", () => {
+  const list = reactObligations({ obligations: [ob(), { key: "outcome.x", kind: "OUTCOME" }, { key: "schedule.x", kind: "SCHEDULE" }] });
+  assert.deepEqual(list.map((x) => x.key), ["react.task.assigned"]);
+});
+
+// ---------------------------------------------------------------------------
+// binding changes the decision
+// ---------------------------------------------------------------------------
+
+test("binding an obligation lifts the rung cap the uncovered path imposes", () => {
+  const ev = boardEvent();
+  const need = { steps: 8, filesystem: true };
+  const uncovered = decide({ ...ev, me: ME, history: null, need });
+  const covered = decide({
+    ...ev,
+    me: ME,
+    history: null,
+    need,
+    obligation: ob({ objective_id: "obj_1" }),
+  });
+  assert.ok(uncovered.rung <= 1, "an uncovered event must be capped at rung ≤1");
+  assert.ok(covered.rung > uncovered.rung, "a planned event may route to the rung the work actually needs");
+  assert.equal(covered.obligationKey, "react.task.assigned");
+  assert.ok(uncovered.drift && uncovered.drift.kind === "uncovered_event");
+});
+
+// ---------------------------------------------------------------------------
+// proposals
+// ---------------------------------------------------------------------------
+
+test("an uncovered event proposes a schema-valid REACT obligation", () => {
+  const ev = boardEvent();
+  const p = proposeReact({ ...ev, tier: "T0" });
+  assert.ok(p.obligation, p.why);
+  assert.deepEqual(validateObligation(p.obligation), [], "the proposal must satisfy the real schema");
+  assert.equal(p.obligation.status, "proposed", "nothing an agent proposes is active");
+  assert.deepEqual(p.obligation.uses, [], "an unprobed proposal may not cite a capability (§5.1)");
+  assert.equal(p.obligation.trigger.topic, "task");
+});
+
+test("a proposal inherits the surface's blast radius, so email proposals are external", () => {
+  const norm = fromInboxItem(
+    { raw_ref: "cohort:email:mail_1:5", kind: "email", service: "cohort", timestamp: "2026-08-11T09:00:00.000Z", content: "hi", priority_signals: {} },
+    { me: ME },
+  );
+  const p = proposeReact({ candidate: norm.candidate, verdict: norm.verdict, tier: "T0" });
+  assert.ok(p.obligation.action_classes.includes("external"));
+  assert.equal(p.obligation.offline_safe, false);
+});
+
+test("a proposal that would be invalid is dropped loudly, never written", () => {
+  const p = proposeReact({ candidate: {}, verdict: {} });
+  assert.equal(p.obligation, null);
+  assert.ok(p.errors.length > 0);
+});
+
+test("proposed keys are stable slugs, so the same gap proposes the same obligation twice", () => {
+  const ev = boardEvent();
+  const a = proposeReact({ ...ev, tier: "T0" });
+  const b = proposeReact({ ...ev, tier: "T1" });
+  assert.equal(a.obligation.key, b.obligation.key);
+  assert.match(a.obligation.key, /^[a-z0-9][a-z0-9._-]*$/);
+});
+
+// ---------------------------------------------------------------------------
+// loading
+// ---------------------------------------------------------------------------
+
+test("a missing plan.yaml degrades with a reason instead of throwing", async () => {
+  const r = await loadReactObligations("/nonexistent/agent/root");
+  assert.deepEqual(r.obligations, []);
+  assert.equal(r.degraded, true);
+  assert.ok(r.reason, "a degradation must always carry a reason");
+});
+
+test("a plan is read through the one loader, and its REACT obligations come back", async () => {
+  const plan = {
+    enforcement: "observe_only",
+    obligations: [ob(), { key: "schedule.a", kind: "SCHEDULE" }],
+  };
+  const r = await loadReactObligations("/anywhere", {
+    readPlan: () => plan,
+    yaml: { load: () => plan },
+  });
+  assert.equal(r.degraded, false);
+  assert.equal(r.enforcement, "observe_only");
+  assert.deepEqual(r.obligations.map((x) => x.key), ["react.task.assigned"]);
+});