create-walle 0.10.1 → 0.10.2

package/template/wall-e/lib/helper-rules/grade.js

@@ -0,0 +1,277 @@
+'use strict';
+
+// Lead-cost routing WP-6 (design §6.5, D-19): the 1-in-EXPLORE_GRADE_EVERY spot-check grader
+// for exploration hand-offs. A pinned grader model — the brain setting
+// `helper_rules.grader_model`, seeded to the user's stated grader — reads the card (the brief the
+// helper was given, the report it wrote, the tools it touched) against the rubric committed
+// beside this file, and answers with one JSON object.
+//
+// Two properties are load-bearing (D-0/D-19):
+//
+//   1. NO FALLBACK. An unset pin or a failed call is a stored `{unavailable:true, error}` sample
+//      that the rules exclude from the sufficient rate. A cheaper judge is never substituted,
+//      because a cheaper judge's verdicts would silently move the cell's thresholds.
+//   2. NEVER THROWS. The caller (lib/helper-rules/lead-call-hook.js) runs on the lead's tool-call
+//      path and only ever fire-and-forgets this; every failure has to come back as a value.
+//
+// The reply is parsed field by field with a regex, never JSON.parse'd whole: a grader that wraps
+// its answer in prose (or in a fenced block) still yields its verdict, while a reply that never
+// states `sufficient` and `coverage` is `grade_unparsed` rather than a fabricated label.
+//
+// Round 2 WP-3 (§5 D-8, §6.6): three hardenings, none of which relaxes the pin.
+//   * the card's report TEXT is read HERE from `report_path` / `last_message_path` (the hook has
+//     no fs access, and the no-id wait never carried a report), so the grader sees the real report;
+//   * a reply wrapped in one Markdown fence is unwrapped before the field regexes run;
+//   * an unparsed first reply earns ONE re-ask of the same pinned model with the parse error
+//     appended, and a second failure stores the raw reply so the failure is visible on the panel.
+// A cheaper judge is still never substituted (D-19).
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const EXPLORE_GRADE_EVERY = 5; // D-12: one in five completed hand-offs per cell
+const GRADE_TASK = 'explore-handoff-grade';
+const GRADE_MAX_TOKENS = 400;
+const GRADE_TIMEOUT_MS = 120000;
+const CARD_MAX_CHARS = 12000;
+const BRIEF_MAX_CHARS = 4000; // the brief's share of the card; the report keeps the rest
+const REPORT_MAX_CHARS = CARD_MAX_CHARS - BRIEF_MAX_CHARS; // the report's share of the card
+const RAW_MAX_CHARS = 2048; // D-8: how much of an unparsed reply the stored sample keeps
+const DEFAULT_GRADER_MODEL_KV = 'helper_rules.grader_model';
+
+// The pilot's T2 rubric, verbatim, committed next to this module (design §6.5).
+const RUBRIC = fs.readFileSync(path.join(__dirname, 'explore-rubric.md'), 'utf8');
+
+const FIELD_PATTERNS = Object.freeze({
+  sufficient: /"sufficient"\s*:\s*(true|false)/,
+  coverage: /"coverage"\s*:\s*"(all|most|little)"/,
+  inaccuracies: /"inaccuracies"\s*:\s*(\d+)/,
+  why: /"why"\s*:\s*"([^"]{0,300})"/,
+});
+
+// A verdict without these two is not a verdict (D-19): the parse error names the missing ones.
+const REQUIRED_FIELDS = Object.freeze(['sufficient', 'coverage']);
+
+// One opening Markdown fence — ``` optionally followed by a language word (`json`) — plus its
+// line break; and the matching closing fence at the end of the text. The language word is a word,
+// never free text, so a single-line ```json {...}``` reply is left to the field regexes untouched.
+const OPEN_FENCE = /^\s*```[ \t]*[A-Za-z0-9_+-]*[ \t]*(?:\r?\n|$)/;
+const CLOSE_FENCE = /\r?\n[ \t]*```[ \t]*\s*$/;
+
+function _str(value) {
+  return typeof value === 'string' ? value : '';
+}
+
+function _errorCode(err) {
+  return String((err && (err.code || err.message)) || 'grade_failed');
+}
+
+/**
+ * The card as one text block: the brief, the report, then one `tool path` line per tool. Clipped
+ * to CARD_MAX_CHARS by keeping the head — the brief and the head of the report are what the
+ * grader's coverage question is about, and a report is ≤600 words by contract (D-10).
+ */
+// Lead review (WP-6 C-1): the hook (lib/helper-rules/lead-call-hook.js) has no fs access, so it
+// parks the delegation's rendered_brief_path; the brief TEXT is read here, bounded, and a missing or
+// unreadable file is an empty brief -- the grader then judges the report against nothing and says so.
+function _briefText(source) {
+  const direct = _str(source.brief);
+  if (direct) return direct;
+  const briefPath = _str(source.brief_path);
+  if (!briefPath) return '';
+  try {
+    return fs.readFileSync(briefPath, 'utf8').slice(0, BRIEF_MAX_CHARS);
+  } catch {
+    // expected: the rendered brief was purged or never written -- the card carries no brief
+    return '';
+  }
+}
+
+/**
+ * D-8: the report the grader judges. The hook has no fs access and the no-id wait never carried a
+ * report, so the grader reads the card's paths itself: `report` (back-compat, an inline string),
+ * else the file at `report_path`, else the worker's `last_message_path`. Missing, unreadable or
+ * empty falls through to the next source; nothing readable is ''. Bounded to the report's share of
+ * the card so a long report can never crowd out the brief.
+ */
+function _fileText(filePath) {
+  if (!filePath) return '';
+  try {
+    return fs.readFileSync(filePath, 'utf8').slice(0, REPORT_MAX_CHARS);
+  } catch {
+    // expected: the report (or last message) was purged or never written -- the card carries no report
+    return '';
+  }
+}
+
+function _reportText(source) {
+  const direct = _str(source.report);
+  if (direct) return direct.slice(0, REPORT_MAX_CHARS);
+  const fromReportPath = _fileText(_str(source.report_path));
+  if (fromReportPath) return fromReportPath;
+  return _fileText(_str(source.last_message_path));
+}
+
+function _cardText(card) {
+  const source = card && typeof card === 'object' ? card : {};
+  const toolLog = Array.isArray(source.toolLog) ? source.toolLog : [];
+  const toolLines = toolLog
+    .map((entry) => `${_str(entry && entry.tool)} ${_str(entry && entry.path)}`.trim())
+    .filter(Boolean)
+    .join('\n');
+  // Each half keeps its own head, so a long brief can never push the report off the card.
+  const text = [
+    '## Brief',
+    _briefText(source).slice(0, BRIEF_MAX_CHARS),
+    '',
+    '## Report',
+    _reportText(source),
+    '',
+    '## Tools used',
+    toolLines,
+  ].join('\n');
+  return text.slice(0, CARD_MAX_CHARS);
+}
+
+function _replyText(reply) {
+  if (typeof reply === 'string') return reply;
+  return _str(reply && reply.content);
+}
+
+/**
+ * D-8: a grader that wraps its JSON in one Markdown fence still yields its verdict. Only a fence
+ * the reply STARTS with is stripped, and only its matching close — prose around the block is left
+ * to the field regexes exactly as before.
+ */
+function _stripFence(text) {
+  const open = OPEN_FENCE.exec(text);
+  if (!open) return text;
+  return text.slice(open[0].length).replace(CLOSE_FENCE, '');
+}
+
+/** Parse one reply. `sufficient` and `coverage` are required; an unstated count/why reads as 0/' '. */
+function _parseReply(reply) {
+  const text = _stripFence(_replyText(reply));
+  const matched = {};
+  for (const name of REQUIRED_FIELDS) matched[name] = FIELD_PATTERNS[name].exec(text);
+  const missing = REQUIRED_FIELDS.filter((name) => !matched[name]);
+  if (missing.length) return { ok: false, error: 'grade_unparsed', missing };
+  const inaccuracies = FIELD_PATTERNS.inaccuracies.exec(text);
+  const why = FIELD_PATTERNS.why.exec(text);
+  return {
+    ok: true,
+    sufficient: matched.sufficient[1] === 'true',
+    coverage: matched.coverage[1],
+    // A field the grader did not state: 0 wrong claims, no reason given.
+    inaccuracies: inaccuracies ? Number.parseInt(inaccuracies[1], 10) : 0,
+    why: why ? why[1].trim() : '',
+  };
+}
+
+/**
+ * Grade one exploration hand-off. Never throws; returns { ok:false, error } on any failure, and
+ * re-asks the same pinned model once when the first reply does not parse (D-8).
+ * @param {{ brief?:string, brief_path?:string, report?:string, report_path?:string, last_message_path?:string, toolLog:[{tool:string, path:string}] }} card   clipped to CARD_MAX_CHARS (brief text, or read from brief_path; report text, or read from report_path/last_message_path)
+ * @param {{ completeForRole: Function, graderModel: string, brain?: object }} deps
+ * @returns {Promise<{ ok:true, sufficient:boolean, coverage:'all'|'most'|'little', inaccuracies:number, why:string } | { ok:false, error:string, raw?:string }>}
+ */
+async function gradeHandoff(card, deps = {}) {
+  const graderModel = _str(deps && deps.graderModel).trim();
+  // An unset pin is not a reason to grade with something else (D-0): the sample is unavailable.
+  if (!graderModel) return { ok: false, error: 'grader_model_unset' };
+  const ask = {
+    brain: deps.brain,
+    task: GRADE_TASK,
+    model: graderModel,
+    system: RUBRIC,
+    maxTokens: GRADE_MAX_TOKENS,
+    timeoutMs: GRADE_TIMEOUT_MS,
+    temperature: 0,
+  };
+  const userMessage = { role: 'user', content: _cardText(card) };
+  let reply;
+  try {
+    reply = await deps.completeForRole({ ...ask, messages: [userMessage] });
+  } catch (err) {
+    // REPORT: the caller stores this as an unavailable sample -- it is a value, never a throw.
+    // A call that never answered has no reply to re-ask about, so this is not retried.
+    return { ok: false, error: _errorCode(err) };
+  }
+  const first = _parseReply(reply);
+  if (first.ok) return first;
+  const firstRaw = _replyText(reply);
+  let raw = firstRaw;
+  try {
+    // D-8: ONE bounded retry, the SAME pinned model and parameters, with the raw reply and the
+    // parse error on the wire (the MLflow "single retry with a tightened prompt" form).
+    const retried = await deps.completeForRole({
+      ...ask,
+      messages: [
+        userMessage,
+        { role: 'assistant', content: firstRaw },
+        { role: 'user', content: `Reply with the JSON object only. Parse error: missing ${first.missing.join(', ')}` },
+      ],
+    });
+    const parsed = _parseReply(retried);
+    if (parsed.ok) return parsed;
+    raw = _replyText(retried);
+  } catch {
+    // REPORT: the retry itself failed -- the sample is still stored as an unparsed grade, carrying
+    // the first raw reply, so the failure is visible rather than a silent hole in the rate.
+    raw = firstRaw;
+  }
+  return { ok: false, error: 'grade_unparsed', raw: raw.slice(0, RAW_MAX_CHARS) };
+}
+
+/** D-12: every EXPLORE_GRADE_EVERY-th completed hand-off of a cell (its `helper_outcomes.seq`). */
+function shouldGrade(seq) {
+  return Number.isInteger(seq) && seq > 0 && seq % EXPLORE_GRADE_EVERY === 0;
+}
+
+/**
+ * The persisted `helper_outcomes.grade_json` value: the four verdict fields, or `unavailable`.
+ * D-8: an unparsed sample keeps the raw reply (≤ RAW_MAX_CHARS) so the panel can show WHY it
+ * failed instead of an empty cell.
+ */
+function gradeToJson(result) {
+  if (!result || result.ok !== true) {
+    const json = { unavailable: true, error: _str(result && result.error) || 'grade_failed' };
+    const raw = _str(result && result.raw);
+    if (raw) json.raw = raw.slice(0, RAW_MAX_CHARS);
+    return json;
+  }
+  return {
+    sufficient: result.sufficient === true,
+    coverage: result.coverage,
+    inaccuracies: Number.isInteger(result.inaccuracies) ? result.inaccuracies : 0,
+    why: _str(result.why),
+  };
+}
+
+/** The pinned grader model from kv_store; missing (or unreadable) is '' -> `grader_model_unset`. */
+function readGraderModel(db) {
+  if (!db || typeof db.prepare !== 'function') return '';
+  try {
+    const row = db.prepare('SELECT value FROM kv_store WHERE key = ?').get(DEFAULT_GRADER_MODEL_KV);
+    return _str(row && row.value).trim();
+  } catch {
+    // expected: kv_store is absent on a bare handle -- an unreadable pin reads as unset
+    return '';
+  }
+}
+
+module.exports = {
+  BRIEF_MAX_CHARS,
+  CARD_MAX_CHARS,
+  DEFAULT_GRADER_MODEL_KV,
+  EXPLORE_GRADE_EVERY,
+  GRADE_MAX_TOKENS,
+  GRADE_TASK,
+  GRADE_TIMEOUT_MS,
+  RAW_MAX_CHARS,
+  RUBRIC,
+  gradeHandoff,
+  gradeToJson,
+  readGraderModel,
+  shouldGrade,
+};

package/template/wall-e/lib/helper-rules/label.js

@@ -0,0 +1,247 @@
+'use strict';
+
+// Lead-cost routing WP-5a (design §6.7): the PURE labelling functions behind the two rule
+// cells. Nothing here reads a clock, a database or a transcript — every input is an
+// argument, so the whole file is unit-testable on fixtures and has no side effects.
+//
+// Round 2 (WP-1, D-1/D-2/D-4): the labeller no longer counts citations out of a result body.
+// The observed inputs arrive as a `facts` object (§6.2) produced by `factsFromPayload`, and
+// `labelFromFacts(kind, facts)` derives the decision from those facts alone. `LABEL_VERSION`
+// is the version of that rule; every row the hook writes carries it.
+//
+// Round 1 (D-12): `lead_usd` and `reread_rate` are deliberately NOT computed — the usage
+// ledger carries no per-call tool names, so both stay null and the evaluator simply skips
+// the two rules that read them.
+
+// D-3 (lead-cost-routing-round2-2026-10-24.html §5 D-3, §6.1): the citation regex moved to
+// shared/report-citations.js so CTM (the counter, delegate-worker.js's getWorkerStatus) and
+// this file (the labeller) cannot drift. `countReportRows` below stays the export name every
+// caller already uses; round 2 (D-3) makes CTM the only counter, so this is now the shared
+// implementation CTM calls rather than something the hook runs on a result body.
+const { countReportCitations } = require('../../../shared/report-citations');
+
+// D-1: the version of the label rule below. Bump it whenever the rule changes.
+const LABEL_VERSION = 2;
+
+// The tools that mean "the lead acted on that worker". walle_worker_wait / status are
+// excluded even when they name the session: another poll on the same set is exactly the
+// empty wake the rule exists to catch.
+const WAIT_TOOLS = new Set(['walle_worker_wait', 'walle_worker_status']);
+// S-9 (round 2): kept as the exported list of acting tools. Since round 2 an ACT tool counts
+// only when its args name THAT worker, exactly like every other non-wait tool — `ACT_TOOLS`
+// no longer short-circuits the judgement (see `_isUsefulNextCall`).
+const ACT_TOOLS = new Set(['walle_stop_worker', 'walle_resume_worker']);
+
+// D-4: the terminal statuses a payload may report and the report sources that can carry a
+// report. Anything else reads as unknown (null) so a malformed body can never be a hand-off.
+const TERMINAL_STATUSES = new Set(['report_ready', 'exited', 'failed']);
+const REPORT_SOURCES = new Set(['report', 'last_message', 'final_result']);
+
+function _toolOf(nextCall) {
+  return nextCall && typeof nextCall.tool === 'string' ? nextCall.tool : '';
+}
+
+function _argsOf(nextCall) {
+  const args = nextCall && nextCall.args;
+  return args && typeof args === 'object' ? args : {};
+}
+
+/** S-9: the lead's call acts on THIS worker only when its args name that worker. */
+function _namesWorker(nextCall, workerId) {
+  return Boolean(workerId) && _argsOf(nextCall).ctm_session_id === workerId;
+}
+
+/** True when the lead's next Wall-E call actually advanced the worker rather than polling it. */
+function _isUsefulNextCall(nextCall, workerId) {
+  const tool = _toolOf(nextCall);
+  if (!tool) return false;
+  if (WAIT_TOOLS.has(tool)) return false;
+  // S-9 (round 2): the round-1 `ACT_TOOLS.has(tool)` short-circuit is gone -- a stop/resume
+  // counts only when its args name THAT worker, the same test every other non-wait tool uses.
+  return _namesWorker(nextCall, workerId);
+}
+
+/**
+ * The label for a WAKE_LEAD tick: did the wake buy the lead anything?
+ * @returns {'useful'|'empty'}
+ */
+function labelWatcherWake({ nextCall, workerId } = {}) {
+  return _isUsefulNextCall(nextCall, workerId) ? 'useful' : 'empty';
+}
+
+/**
+ * The label for a tick the watcher kept silent, judged by the same rule with the silent
+ * prefix. A KEEP_WAITING tick draws no lead call of its own, so it is silent_empty unless
+ * the lead's next call for that set was a finish/resume — the silence was right, and that
+ * is the only way the evaluator's silent window can ever turn a cell back on.
+ * @returns {'silent_useful'|'silent_empty'}
+ */
+function labelSilentTick({ nextCall, workerId } = {}) {
+  return _isUsefulNextCall(nextCall, workerId) ? 'silent_useful' : 'silent_empty';
+}
+
+/**
+ * The positive control for silence: a worker that only ended after the watcher last chose
+ * to keep waiting was a wake the watcher missed.
+ * @returns {'late'|null}
+ */
+function labelLateEnd({ lastDecision, terminalStatus } = {}) {
+  return lastDecision === 'KEEP_WAITING' && terminalStatus === 'failed' ? 'late' : null;
+}
+
+/** Distinct `file:line` tokens cited by a report — the report's evidence count. */
+const countReportRows = countReportCitations;
+
+function _toMs(value) {
+  if (value == null) return null;
+  if (value instanceof Date) return Number.isFinite(value.getTime()) ? value.getTime() : null;
+  if (typeof value === 'number') return Number.isFinite(value) ? value : null;
+  const text = String(value).trim();
+  if (!text) return null;
+  // SQLite's datetime('now') is 'YYYY-MM-DD HH:MM:SS' in UTC — Date.parse reads that as local.
+  const iso = /^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}$/.test(text) ? `${text.replace(' ', 'T')}Z` : text;
+  const ms = Date.parse(iso);
+  return Number.isFinite(ms) ? ms : null;
+}
+
+function _strOrNull(value) {
+  return typeof value === 'string' && value ? value : null;
+}
+
+function _boolOrNull(value) {
+  return typeof value === 'boolean' ? value : null;
+}
+
+/** D-4: a citation count is a non-negative integer, or null when absent/unusable. */
+function _countOrNull(value) {
+  return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? Math.trunc(value) : null;
+}
+
+/**
+ * D-2: the one payload accessor. The recommended no-id wait nests the woken worker under
+ * `worker`; every other wait/status body carries its fields at the top level.
+ * @returns {object|null}
+ */
+function workerPayloadOf(res) {
+  if (!res || typeof res !== 'object') return null;
+  if (res.worker && typeof res.worker === 'object') return res.worker;
+  return res;
+}
+
+/**
+ * D-1/D-4: the observed facts of one explore hand-off (all keys present; null when unknown).
+ * @param {object|null} payload the wait/status body, already unwrapped by workerPayloadOf
+ * @param {{opened_at?:number|string|Date|null, terminal_at?:number|string|Date|null,
+ *          wait_variant?:string|null, woke_on?:string|null}} meta
+ */
+function factsFromPayload(payload, { opened_at, terminal_at, wait_variant, woke_on } = {}) {
+  const p = payload && typeof payload === 'object' ? payload : null;
+  const status = p ? _strOrNull(p.status) : null;
+  const source = p ? _strOrNull(p.report_source) : null;
+  const spend = p && p.spend && typeof p.spend === 'object' ? p.spend.usd : null;
+  return {
+    terminal_status: TERMINAL_STATUSES.has(status) ? status : null,
+    report_source: REPORT_SOURCES.has(source) ? source : null,
+    report_present: p ? _boolOrNull(p.report_present) : null,
+    report_citation_rows: p ? _countOrNull(p.report_citation_rows) : null,
+    report_chars: p ? _countOrNull(p.report_chars) : null,
+    report_path: p ? _strOrNull(p.report_path) : null,
+    last_message_path: p ? _strOrNull(p.last_message_path) : null,
+    worker_spend_usd: typeof spend === 'number' && Number.isFinite(spend) ? spend : null,
+    harness: p ? _strOrNull(p.harness) : null,
+    wait_variant: _strOrNull(wait_variant),
+    woke_on: _strOrNull(woke_on),
+    opened_at: _toMs(opened_at),
+    terminal_at: _toMs(terminal_at),
+    abandoned_at: null,
+  };
+}
+
+function _secondsBetween(openedAt, terminalAt) {
+  return Number.isFinite(openedAt) && Number.isFinite(terminalAt) ? (terminalAt - openedAt) / 1000 : null;
+}
+
+/** D-4: the explore decision, exactly as written in the design. */
+function _labelExplore(facts) {
+  const t = facts.terminal_status;
+  const s = facts.report_source;
+  const c = facts.report_citation_rows;
+  let decision;
+  if (facts.abandoned_at != null) decision = 'abandoned';
+  else if (t == null || c == null) decision = 'unmeasured';
+  else if (t === 'failed') decision = 'fallback';
+  else if ((t === 'report_ready' || t === 'exited') && REPORT_SOURCES.has(s) && c >= 1) decision = 'handoff';
+  else decision = 'fallback';
+  return {
+    decision,
+    label: null,
+    report_rows: decision === 'unmeasured' ? null : c,
+    helper_usd: facts.worker_spend_usd,
+    seconds_to_report: _secondsBetween(facts.opened_at, facts.terminal_at),
+  };
+}
+
+/** The same ACT_TOOLS rule as `_isUsefulNextCall`, applied to pre-computed next-call facts. */
+function _usefulFromFacts(nextCall, workerId) {
+  const tool = nextCall && typeof nextCall.tool === 'string' ? nextCall.tool : '';
+  if (!tool) return false;
+  if (WAIT_TOOLS.has(tool)) return false;
+  return Boolean(workerId) && nextCall.names_worker === true;
+}
+
+/** §6.4: a wait-watch row's label — late beats dropped beats the useful/empty judgement. */
+function _labelWaitWatch(facts) {
+  const f = facts && typeof facts === 'object' ? facts : {};
+  const silent = f.silent === true;
+  let label;
+  if (f.late === true) label = 'late';
+  else if (f.dropped === true) label = silent ? 'silent_empty' : 'empty';
+  else if (_usefulFromFacts(f.next_call, f.worker_id)) label = silent ? 'silent_useful' : 'useful';
+  else label = silent ? 'silent_empty' : 'empty';
+  return {
+    decision: typeof f.decision === 'string' ? f.decision : null,
+    label,
+    report_rows: null,
+    helper_usd: null,
+    seconds_to_report: null,
+  };
+}
+
+/**
+ * D-1/D-4: derive the row's label from its stored facts. Pure and total — a malformed facts
+ * object reads as `unmeasured`, never a throw on the lead's tool-call path.
+ * @param {'explore'|'wait-watch'} kind
+ * @param {object} facts
+ * @returns {{decision:string|null, label:string|null, report_rows:number|null,
+ *            helper_usd:number|null, seconds_to_report:number|null}}
+ */
+/** The one answer for "this row cannot be measured": D-7 excludes it from `closed`. */
+const UNMEASURED = Object.freeze({
+  decision: 'unmeasured', label: null, report_rows: null, helper_usd: null, seconds_to_report: null,
+});
+
+function labelFromFacts(kind, facts) {
+  try {
+    if (kind === 'explore') return _labelExplore(facts);
+    if (kind === 'wait-watch') return _labelWaitWatch(facts);
+  } catch {
+    // HANDLE: a facts object the rule cannot read is unmeasured, never a failed tool call.
+    return UNMEASURED;
+  }
+  // HANDLE: an unknown kind has no rule -- unmeasured is the honest reading, never a throw.
+  return UNMEASURED;
+}
+
+module.exports = {
+  ACT_TOOLS,
+  LABEL_VERSION,
+  TERMINAL_STATUSES,
+  WAIT_TOOLS,
+  countReportRows,
+  factsFromPayload,
+  labelFromFacts,
+  labelLateEnd,
+  labelSilentTick,
+  labelWatcherWake,
+  workerPayloadOf,
+};