atris 3.30.1 → 3.30.3

package/commands/log-sync.js

@@ -8,6 +8,34 @@ const { ensureValidCredentials } = require('../utils/auth');
 const { apiRequestJson } = require('../utils/api');
 const { promptUser } = require('../utils/auth');
 
+class LogSyncWriteError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'LogSyncWriteError';
+  }
+}
+
+function formatWriteError(error) {
+  return error && error.message ? error.message : String(error);
+}
+
+function writeLogFile(logFile, content) {
+  try {
+    fs.writeFileSync(logFile, content, 'utf8');
+  } catch (error) {
+    const relativePath = path.relative(process.cwd(), logFile);
+    throw new LogSyncWriteError(`Could not write local journal "${relativePath}": ${formatWriteError(error)}. Check disk space and file permissions.`);
+  }
+}
+
+function saveLogSyncStateSafely(state) {
+  try {
+    saveLogSyncState(state);
+  } catch (error) {
+    throw new LogSyncWriteError(`Could not save log sync state: ${formatWriteError(error)}. Check disk space and file permissions.`);
+  }
+}
+
 async function logSyncAtris() {
   const targetDir = path.join(process.cwd(), 'atris');
 
@@ -110,7 +138,7 @@ async function logSyncAtris() {
               updated_at: remoteUpdatedAt,
               hash: remoteHash || knownRemoteHash || computeContentHash(remoteContent || ''),
             };
-            saveLogSyncState(state);
+            saveLogSyncStateSafely(state);
           }
           console.log('✓ Already synced (timestamps aligned with web)');
           return;
@@ -124,7 +152,7 @@ async function logSyncAtris() {
           if (conflicts.length === 0) {
             // Clean merge - auto-merge and continue
             const mergedContent = reconstructJournal(merged);
-            fs.writeFileSync(logFile, mergedContent, 'utf8');
+            writeLogFile(logFile, mergedContent);
             console.log('✓ Auto-merged web and local changes');
             console.log(`   Merged sections: ${Object.keys(merged).filter(k => k !== '__header__').join(', ')}`);
             finalLocalContent = mergedContent;
@@ -143,7 +171,7 @@ async function logSyncAtris() {
                 updated_at: remoteUpdatedAt,
                 hash: computeContentHash(mergedContent),
               };
-              saveLogSyncState(state);
+              saveLogSyncStateSafely(state);
               return;
             }
           } else {
@@ -168,7 +196,7 @@ async function logSyncAtris() {
             if (answer === '1') {
               // Use web version
               const pulledContent = existing.data?.content || '';
-              fs.writeFileSync(logFile, pulledContent, 'utf8');
+              writeLogFile(logFile, pulledContent);
               remoteHash = computeContentHash(pulledContent);
               finalLocalContent = pulledContent;
               console.log('✓ Local journal updated from web');
@@ -183,7 +211,7 @@ async function logSyncAtris() {
                   updated_at: remoteUpdatedAt,
                   hash: remoteHash || computeContentHash(pulledContent),
                 };
-                saveLogSyncState(state);
+                saveLogSyncStateSafely(state);
               }
               // Don't push - web already has the correct version
               shouldPush = false;
@@ -194,7 +222,7 @@ async function logSyncAtris() {
             } else if (answer === '3') {
               // Merge both
               const mergedContent = reconstructJournal(merged);
-              fs.writeFileSync(logFile, mergedContent, 'utf8');
+              writeLogFile(logFile, mergedContent);
               finalLocalContent = mergedContent;
               console.log('✓ Merged both versions (check for duplicates)');
               console.log(`   Merged sections: ${Object.keys(merged).filter(k => k !== '__header__').join(', ')}`);
@@ -205,6 +233,9 @@ async function logSyncAtris() {
             }
           }
         } catch (parseError) {
+          if (parseError instanceof LogSyncWriteError) {
+            throw parseError;
+          }
           // Fallback to simple prompt
           console.log('⚠️  Web version is newer than local version');
           console.log(`   Remote updated: ${remoteUpdatedAt}`);
@@ -223,7 +254,7 @@ async function logSyncAtris() {
 
           if (answer === '1') {
             const pulledContent = existing.data?.content || '';
-            fs.writeFileSync(logFile, pulledContent, 'utf8');
+            writeLogFile(logFile, pulledContent);
             remoteHash = computeContentHash(pulledContent);
             finalLocalContent = pulledContent;
             console.log('✓ Local journal updated from web');
@@ -238,7 +269,7 @@ async function logSyncAtris() {
                 updated_at: remoteUpdatedAt,
                 hash: remoteHash || computeContentHash(pulledContent),
               };
-              saveLogSyncState(state);
+              saveLogSyncStateSafely(state);
             }
             // Don't push - web already has the correct version
             shouldPush = false;
@@ -265,14 +296,14 @@ async function logSyncAtris() {
             updated_at: remoteUpdatedAt,
             hash: remoteHash || knownRemoteHash || computeContentHash(remoteContent || ''),
           };
-          saveLogSyncState(state);
+          saveLogSyncStateSafely(state);
         }
         return;
       } else if (localMatchesKnown && !remoteMatchesKnown) {
         // Local unchanged, web has updates - just pull
         console.log('📥 Web has updates, local unchanged - pulling...');
         const pulledContent = existing.data?.content || '';
-        fs.writeFileSync(logFile, pulledContent, 'utf8');
+        writeLogFile(logFile, pulledContent);
         const pulledHash = computeContentHash(pulledContent);
         if (remoteUpdatedAt) {
           const remoteDate = new Date(remoteUpdatedAt);
@@ -284,7 +315,7 @@ async function logSyncAtris() {
             updated_at: remoteUpdatedAt,
             hash: pulledHash,
           };
-          saveLogSyncState(state);
+          saveLogSyncStateSafely(state);
         }
         console.log('✓ Local journal updated from web');
         console.log(`🗒️  File: ${path.relative(process.cwd(), logFile)}`);
@@ -304,7 +335,7 @@ async function logSyncAtris() {
 
   // Update local file with final content if it changed
   if (finalLocalContent !== localContent) {
-    fs.writeFileSync(logFile, finalLocalContent, 'utf8');
+    writeLogFile(logFile, finalLocalContent);
   }
 
   const payload = {
@@ -350,7 +381,7 @@ async function logSyncAtris() {
     updated_at: updatedAt,
     hash: finalHash,
   };
-  saveLogSyncState(finalState);
+  saveLogSyncStateSafely(finalState);
 }
 
 module.exports = { logSyncAtris };

package/commands/loop-front.js

@@ -0,0 +1,290 @@
+'use strict';
+
+// `atris loop` is the single front door to the self-improvement loop.
+//
+// Before this, "start a loop" meant guessing between six commands: run,
+// autopilot, mission, improve, pulse, and the old wiki `loop`. This collapses
+// the ENTRY to one plain-English verb and delegates to the engines that already
+// exist. It does not add a seventh engine.
+//
+//   atris loop                    home: status + the next moves
+//   atris loop start              run it now, here (local)      -> run.js
+//   atris loop start --once       one cycle, then stop          -> run.js
+//   atris loop start --overnight  durable heartbeat (~15m)      -> pulse.js
+//   atris loop status             liveness, last tick, reward   -> pulse.js
+//   atris loop stop               remove the durable heartbeat  -> pulse.js
+//   atris loop wiki               wiki upkeep (the old `loop`)  -> loop.js
+//
+// The loop reads ROADMAP.md for what to pursue.
+
+function isFlag(arg) {
+  return typeof arg === 'string' && arg.startsWith('-');
+}
+
+// Pure router: decide what `atris loop ...` means without executing anything.
+// Kept side-effect-free so it is trivially testable.
+function routeLoop(argv = []) {
+  const positional = argv.filter((a) => !isFlag(a));
+  const sub = (positional[0] || '').toLowerCase();
+  const cloud = argv.includes('--cloud') || argv.includes('--overnight');
+  const once = argv.includes('--once');
+
+  switch (sub) {
+    case 'start':
+      return { action: cloud ? 'start-overnight' : 'start-local', once };
+    case 'status':
+      return { action: 'status' };
+    case 'stop':
+      return { action: 'stop' };
+    case 'wiki':
+      // Forward the remaining args (e.g. --json, --limit=) to wiki upkeep.
+      return { action: 'wiki', rest: argv.filter((a) => a.toLowerCase() !== 'wiki') };
+    case 'add': {
+      // Everything after `add` (minus flags) is the item text.
+      const i = argv.findIndex((a) => a.toLowerCase() === 'add');
+      const text = argv.slice(i + 1).filter((a) => !isFlag(a)).join(' ').trim();
+      return { action: 'add', text };
+    }
+    case 'report':
+      return { action: 'report' };
+    case '': {
+      // A start flag with no `start` verb does nothing on its own; nudge.
+      const stray = ['--overnight', '--cloud', '--once'].find((f) => argv.includes(f));
+      return stray ? { action: 'home', strayStartFlag: stray } : { action: 'home' };
+    }
+    default:
+      return { action: 'home', unknown: sub };
+  }
+}
+
+function renderLoopHome(route = { action: 'home' }) {
+  const lines = [
+    '',
+    'atris loop: the self-improvement loop',
+    '',
+    '  one loop: plan, do, review, verify, commit. it ships one small',
+    '  verifiable change at a time, then goes again. it reads ROADMAP.md',
+    '  for what to pursue.',
+    '',
+    '  feed it',
+    '    atris loop add "<task>"        put a bounded task into the queue',
+    '',
+    '  start it',
+    '    atris loop start              run it now, here (local)',
+    '    atris loop start --once       one cycle, then stop',
+    '    atris loop start --overnight  install the durable heartbeat (~15m)',
+    '',
+    '  watch it',
+    '    atris loop status             liveness, last tick, reward',
+    '    atris loop report             what the loop has handled and what is next',
+    '    atris run logs                read each phase (local runs)',
+    '',
+    '  stop it',
+    '    atris loop stop               remove the durable heartbeat',
+    '',
+    '  wiki upkeep is at: atris loop wiki',
+    '',
+  ];
+  if (route && route.unknown) {
+    lines.splice(1, 0, `  (unknown: "${route.unknown}". here is the loop:)`);
+  }
+  if (route && route.strayStartFlag) {
+    lines.splice(1, 0, `  (did you mean: atris loop start ${route.strayStartFlag}?)`);
+  }
+  return lines.join('\n');
+}
+
+function printLoopHome(route) {
+  console.log(renderLoopHome(route));
+}
+
+// Parse the handful of local-run flags `atris loop start` forwards to run.js.
+function startLocalOptions(argv = []) {
+  const opts = {
+    once: argv.includes('--once'),
+    verbose: argv.includes('--verbose') || argv.includes('-v'),
+    dryRun: argv.includes('--dry-run'),
+    push: !argv.includes('--no-push'),
+  };
+  const cyclesArg = argv.find((a) => a.startsWith('--cycles='));
+  if (cyclesArg) {
+    const n = parseInt(cyclesArg.split('=')[1], 10);
+    if (!Number.isNaN(n)) opts.maxCycles = n;
+  }
+  const timeoutArg = argv.find((a) => a.startsWith('--timeout='));
+  if (timeoutArg) {
+    const n = parseInt(timeoutArg.split('=')[1], 10);
+    if (!Number.isNaN(n)) opts.timeout = n * 1000;
+  }
+  return opts;
+}
+
+// Summarize the local plan/do/review run logs (run.js writes these). Pure of
+// console, takes the dir, so it is testable.
+function localRunSummary(dir) {
+  const fs = require('fs');
+  let files;
+  try {
+    files = fs.readdirSync(dir).filter((f) => f.endsWith('.md')).sort();
+  } catch {
+    return { count: 0, latest: null };
+  }
+  if (!files.length) return { count: 0, latest: null };
+  return { count: files.length, latest: files[files.length - 1] };
+}
+
+function printLocalRunSummary() {
+  try {
+    const { getRunLogDir } = require('./run');
+    const s = localRunSummary(getRunLogDir());
+    if (!s.count) {
+      console.log('local runs: none yet. start one with `atris loop start`.');
+      return;
+    }
+    console.log(`local runs: ${s.count} logged, latest ${s.latest}. read them: atris run logs`);
+  } catch { /* best-effort: never block status */ }
+}
+
+// Combined machine-readable status: the overnight pulse heartbeat and the local
+// runs in one object. Best-effort per engine so a missing one does not fail it.
+function loopStatusJson(root = process.cwd()) {
+  const out = { ok: true, action: 'loop_status', pulse: null, local_runs: { count: 0, latest: null } };
+  try {
+    const lp = require('../lib/pulse');
+    const { cronInstalled } = require('./pulse');
+    const summary = lp.summarizePulse(lp.readPulseReceipts(root));
+    out.pulse = { cron_installed: cronInstalled(), ...summary };
+  } catch { /* pulse optional */ }
+  try {
+    out.local_runs = localRunSummary(require('./run').getRunLogDir());
+  } catch { /* runs optional */ }
+  return out;
+}
+
+// The evidence that the loop is improving things: ROADMAP items it has handled,
+// what is in flight and queued, and the heartbeat's reward/verify trend. Pure of
+// console so it is testable.
+function loopReport(root = process.cwd()) {
+  const status = loopStatusJson(root);
+  let roadmap = { open: [], claimed: [], done: [] };
+  try {
+    roadmap = require('../lib/next-moves').roadmapItemsByState(root);
+  } catch { /* roadmap optional */ }
+  return { ok: true, action: 'loop_report', roadmap, pulse: status.pulse, local_runs: status.local_runs };
+}
+
+function renderLoopReport(rep) {
+  const r = rep.roadmap;
+  const lines = ['', 'loop report: what the self-improvement loop has done', ''];
+  lines.push(`  roadmap: ${r.done.length} done, ${r.claimed.length} in flight, ${r.open.length} queued`);
+  if (r.done.length) {
+    lines.push('');
+    lines.push('  handled:');
+    r.done.slice(0, 6).forEach((t) => lines.push(`    [x] ${t}`));
+    if (r.done.length > 6) lines.push(`    ... and ${r.done.length - 6} more`);
+  }
+  if (r.claimed.length) {
+    lines.push('');
+    lines.push('  in flight:');
+    r.claimed.slice(0, 4).forEach((t) => lines.push(`    [~] ${t}`));
+  }
+  if (r.open.length) {
+    lines.push('');
+    lines.push('  next up:');
+    r.open.slice(0, 4).forEach((t) => lines.push(`    [ ] ${t}`));
+  }
+  if (rep.pulse) {
+    lines.push('');
+    lines.push(`  heartbeat: ${rep.pulse.total_ticks} ticks, reward ${rep.pulse.reward_sum}, verify ${rep.pulse.verify_pass}/${rep.pulse.verify_fail}`);
+  }
+  lines.push(`  local runs: ${rep.local_runs.count}`);
+  lines.push('');
+  return lines.join('\n');
+}
+
+// Executor. Returns a Promise resolving to an exit code (0 = ok).
+function loopFront(argv = []) {
+  const route = routeLoop(argv);
+  const jsonFlag = argv.includes('--json') ? ['--json'] : [];
+
+  switch (route.action) {
+    case 'home':
+      printLoopHome(route);
+      return Promise.resolve(0);
+
+    case 'wiki':
+      return Promise.resolve(require('./loop').loopAtris(route.rest)).then(() => 0);
+
+    case 'report': {
+      const rep = loopReport(process.cwd());
+      console.log(jsonFlag.length ? JSON.stringify(rep, null, 2) : renderLoopReport(rep));
+      return Promise.resolve(0);
+    }
+
+    case 'add': {
+      if (!route.text) {
+        console.log('usage: atris loop add "<one bounded task the loop should pursue>"');
+        return Promise.resolve(0);
+      }
+      const res = require('../lib/next-moves').addRoadmapItem(process.cwd(), route.text);
+      if (res.added) {
+        console.log(`added to the loop: ${res.title}`);
+        console.log('see it: atris moves   |   run it: atris loop start');
+      } else {
+        console.log(`not added (${res.reason}${res.title ? `: ${res.title}` : ''})`);
+      }
+      return Promise.resolve(0);
+    }
+
+    case 'status': {
+      if (jsonFlag.length) {
+        // One machine-readable object covering BOTH engines (overnight pulse
+        // heartbeat + local runs), for headless agents and web status.
+        const out = loopStatusJson(process.cwd());
+        console.log(JSON.stringify(out, null, 2));
+        return Promise.resolve(out.ok === false ? 1 : 0);
+      }
+      return Promise.resolve(require('./pulse').pulseCommand(['status']))
+        .then((res) => {
+          // Pulse covers the overnight heartbeat; also surface local runs so
+          // `atris loop status` reflects both engines, not just pulse.
+          printLocalRunSummary();
+          return res && res.ok === false ? 1 : 0;
+        });
+    }
+
+    case 'stop':
+      return Promise.resolve(require('./pulse').pulseCommand(['uninstall', ...jsonFlag]))
+        .then((res) => (res && res.ok === false ? 1 : 0));
+
+    case 'start-overnight': {
+      // Durable heartbeat via the pulse OS-cron installer. Pass through any
+      // pulse install flags the operator added (e.g. --cadence).
+      const passthrough = argv.filter((a) => a !== 'start' && a !== '--overnight' && a !== '--cloud');
+      return Promise.resolve(require('./pulse').pulseCommand(['install', ...passthrough]))
+        .then((res) => {
+          const failed = res && res.ok === false;
+          // Keep the front door consistent: the stop verb is `atris loop stop`,
+          // not the underlying pulse command.
+          if (!failed && !argv.includes('--json')) console.log('to stop: atris loop stop');
+          return failed ? 1 : 0;
+        });
+    }
+
+    case 'start-local':
+    default:
+      return Promise.resolve(require('./run').runAtris(startLocalOptions(argv))).then(() => 0);
+  }
+}
+
+module.exports = {
+  routeLoop,
+  renderLoopHome,
+  printLoopHome,
+  startLocalOptions,
+  localRunSummary,
+  loopStatusJson,
+  loopReport,
+  renderLoopReport,
+  loopFront,
+};

package/commands/member.js

@@ -946,6 +946,92 @@ function readTaskProjectionEvidence(name) {
   };
 }
 
+function taskGoalId(task) {
+  return task?.metadata?.goal_id
+    || task?.metadata?.goalId
+    || task?.goal_id
+    || task?.goalId
+    || task?.atrisContext?.goalId
+    || '';
+}
+
+function missionTaskStatusRank(task) {
+  const status = lowerCompact(task?.status || task?.state || '');
+  if (['claimed', 'doing', 'in_progress', 'in-progress', 'working'].includes(status)) return 0;
+  if (['open', 'todo', 'plan', 'planned'].includes(status)) return 1;
+  if (['review', 'ready'].includes(status)) return 2;
+  if (status === 'blocked') return 3;
+  return 4;
+}
+
+function missionTaskUpdatedAt(task) {
+  const numeric = Number(task?.updated_at || task?.updatedAt || task?.created_at || task?.createdAt || 0);
+  if (Number.isFinite(numeric) && numeric > 0) return numeric;
+  const parsed = Date.parse(task?.updated_at || task?.updatedAt || task?.created_at || task?.createdAt || '');
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
+function taskOwnerLabel(task) {
+  return task?.claimed_by
+    || task?.claimedBy
+    || task?.assigned_to
+    || task?.assignedTo
+    || task?.metadata?.assigned_to
+    || task?.metadata?.owner
+    || task?.owner
+    || null;
+}
+
+function missionTaskContextForMember(name, missionId) {
+  const wanted = String(missionId || '').trim();
+  if (!wanted) return null;
+  const tasks = taskProjectionRows()
+    .filter((task) => String(taskGoalId(task) || '').trim() === wanted)
+    .filter((task) => !taskIsClosed(task));
+  if (!tasks.length) return null;
+  const selected = tasks.slice().sort((a, b) => {
+    const byOwner = (taskBelongsToMember(a, name) ? 0 : 1) - (taskBelongsToMember(b, name) ? 0 : 1);
+    if (byOwner) return byOwner;
+    const byStatus = missionTaskStatusRank(a) - missionTaskStatusRank(b);
+    if (byStatus) return byStatus;
+    const byUpdated = missionTaskUpdatedAt(a) - missionTaskUpdatedAt(b);
+    if (byUpdated) return byUpdated;
+    return String(a.title || '').localeCompare(String(b.title || ''));
+  })[0];
+  const ref = taskRef(selected);
+  return {
+    ref,
+    title: compactSentence(selected.title || selected.summary || ref || 'mission task', 140),
+    status: selected.status || selected.state || null,
+    owner: taskOwnerLabel(selected),
+    goal_id: wanted,
+    command: `atris task current-step --goal-id ${wanted} --as ${name} --proof "<proof>" --json`,
+  };
+}
+
+function nativeGoalFromMissionTask(name, goal, runtime, taskContext) {
+  const missionId = runtime?.id || goal?.mission_id || null;
+  const objective = taskContext
+    ? `${name}: complete ${taskContext.ref} - ${taskContext.title}`
+    : `${name}: ${goal.title}`;
+  return {
+    schema: 'atris.native_goal.v1',
+    owner: name,
+    runner: 'coding-agent',
+    objective,
+    slash_goal: objective,
+    member_goal_id: goal.id,
+    mission_id: missionId,
+    task: taskContext || null,
+    acceptance: taskContext ? [
+      `Move ${taskContext.ref} to Review with a human-readable Result receipt.`,
+      'Record the verifier/proof used to check the work.',
+      'Stop only when the task is in Review, blocked with a human ask, or accepted by a human.',
+    ] : goal.acceptance,
+    next_command: taskContext?.command || `atris member tick ${name} --goal ${goal.id}`,
+  };
+}
+
 function listThreadJsonFiles(root) {
   if (!root || !fs.existsSync(root)) return [];
   const out = [];
@@ -3099,6 +3185,9 @@ skills: []
 
 permissions:
   can-read: true
+  can-execute: true
+  can-approve: false
+  can-accept-task: false
   approval-required: []
 
 tools: []
@@ -3116,6 +3205,29 @@ tools: []
 2. Step two
 3. Step three
 
+## Cadence
+
+- Wake cadence: define when this member may run unattended.
+- Lease: define the maximum time one tick may hold a task or worktree.
+- Stop condition: define the state that pauses the loop.
+
+## Ownership Contract
+
+- Own tasks by function or feature, never by execution engine.
+- If no existing member fits, create a member-creation task before assigning broad work.
+- Put coding agent models like Codex and Claude in the executed_by section.
+
+## Proof Standard
+
+- Move proof-backed work to Review with verifier output, receipt path, or concrete artifact proof.
+- Never run human accept or claim AgentXP without human approval.
+
+## Cleanup Contract
+
+- Use isolated worktrees for parallel work.
+- Ship or archive worktrees before the lease ends.
+- Leave task notes another member can resume without chat context.
+
 ## Rules
 
 1. Rule one
@@ -3693,6 +3805,10 @@ function memberGoalFromMission(name, ...args) {
   goal.now_file = fs.existsSync(path.join(paths.memberDir, 'now.md')) ? path.relative(process.cwd(), path.join(paths.memberDir, 'now.md')) : null;
   goal.mission_id = runtime.id || goal.mission_id || null;
   goal.mission_north_star = purpose.northStar;
+  const taskContext = missionTaskContextForMember(name, goal.mission_id);
+  const nativeGoal = nativeGoalFromMissionTask(name, goal, runtime, taskContext);
+  goal.task_context = taskContext;
+  goal.native_goal = nativeGoal;
   goal.history = Array.isArray(goal.history) ? goal.history : [];
   const historyEntry = {
     at: stampIso(),
@@ -3718,7 +3834,9 @@ function memberGoalFromMission(name, ...args) {
     goal: goal.title,
     north_star: purpose.northStar,
     runtime_mission: runtime.id || '',
-    next: `atris member tick ${name} --goal ${goal.id}`,
+    current_task: taskContext?.ref || '',
+    native_goal: nativeGoal.objective,
+    next: nativeGoal.next_command,
   });
   printJsonOrText(
     {
@@ -3732,15 +3850,18 @@ function memberGoalFromMission(name, ...args) {
         runtime_status: runtime.status || null,
         runtime_next: runtime.next || null,
       },
+      task: taskContext,
+      native_goal: nativeGoal,
       goals_path: paths.goalsJson,
       goals_md_path: paths.goalsMd,
       log_path: logPath,
-      next_command: `atris member tick ${name} --goal ${goal.id}`,
+      next_command: nativeGoal.next_command,
     },
     [
       `${existing ? 'Reused' : 'Created'} mission-derived goal for ${name}: ${goal.title}`,
       `Mission: ${purpose.northStar}`,
-      `Next: atris member tick ${name} --goal ${goal.id}`,
+      `Native goal: ${nativeGoal.slash_goal}`,
+      `Next: ${nativeGoal.next_command}`,
     ],
     asJson,
   );