memorix 1.5.1 → 1.6.0

package/src/cli/commands/poll.ts

@@ -1,32 +1,32 @@
-import { defineCommand } from 'citty';
-import { computePoll, computeWatermark } from '../../team/poll.js';
-import { getObservationStore } from '../../store/obs-store.js';
+import { defineCommand } from 'citty';
+import { computePoll, computeWatermark } from '../../team/poll.js';
+import { getObservationStore } from '../../store/obs-store.js';
 import { getAllObservations } from '../../memory/observations.js';
 import { withFreshIndex } from '../../memory/freshness.js';
 import { filterReadableObservations } from '../../memory/visibility.js';
 import { emitError, emitResult, getCliProjectContext, resolveCliActorId, shortId } from './operator-shared.js';
-
-export default defineCommand({
-  meta: {
-    name: 'poll',
-    description: 'Get a full project coordination snapshot for an agent',
-  },
-  args: {
-    agentId: { type: 'string', description: 'Agent ID for personalized situational awareness' },
-    markInboxRead: { type: 'boolean', description: 'Mark all inbox messages as read after returning them' },
-    json: { type: 'boolean', description: 'Emit machine-readable JSON output' },
-  },
-  run: async ({ args }) => {
-    const asJson = !!args.json;
-
-    try {
+
+export default defineCommand({
+  meta: {
+    name: 'poll',
+    description: 'Get a full project coordination snapshot for an agent',
+  },
+  args: {
+    agentId: { type: 'string', description: 'Agent ID for personalized situational awareness' },
+    markInboxRead: { type: 'boolean', description: 'Mark all inbox messages as read after returning them' },
+    json: { type: 'boolean', description: 'Emit machine-readable JSON output' },
+  },
+  run: async ({ args }) => {
+    const asJson = !!args.json;
+
+    try {
       const { project, teamStore, identity, reader: activeReader } = await getCliProjectContext();
       const agentId = resolveCliActorId(args.agentId, identity);
       let reader = activeReader;
-
-      let watermark = computeWatermark(0, 0, 0);
-      if (agentId) {
-        const agent = teamStore.getAgent(agentId);
+
+      let watermark = computeWatermark(0, 0, 0);
+      if (agentId) {
+        const agent = teamStore.getAgent(agentId);
         if (!agent || agent.project_id !== project.id) {
           emitError(`Unknown agent "${agentId}"`, asJson);
           return;
@@ -36,45 +36,45 @@ export default defineCommand({
           agentId,
           isTeamMember: agent.status === 'active',
         };
-
-        const lastSeen = agent.last_seen_obs_generation;
-        const currentGen = getObservationStore().getGeneration();
-        const projectObs = await withFreshIndex(() =>
+
+        const lastSeen = agent.last_seen_obs_generation;
+        const currentGen = getObservationStore().getGeneration();
+        const projectObs = await withFreshIndex(() =>
           filterReadableObservations(
             getAllObservations().filter(
               (obs) => obs.projectId === project.id && (obs.writeGeneration ?? 0) > lastSeen,
             ),
             reader,
           ),
-        );
-        watermark = computeWatermark(lastSeen, currentGen, projectObs.length);
-        teamStore.updateWatermark(agentId, currentGen);
-        teamStore.heartbeat(agentId);
-      }
-
-      const poll = computePoll(teamStore, project.id, agentId ?? null, watermark);
-      if (args.markInboxRead && agentId) {
-        teamStore.markAllRead(project.id, agentId);
-      }
-
-      const text = [
-        poll.agent ? `You: ${shortId(poll.agent.agentId)} (${poll.agent.status})` : 'Project-level overview',
-        poll.watermark.newObservationCount > 0
-          ? `${poll.watermark.newObservationCount} new observation(s)`
-          : 'No unseen observations',
-        poll.inbox.unreadCount > 0 ? `${poll.inbox.unreadCount} unread message(s)` : 'Inbox clear',
-        poll.tasks.myInProgress.length > 0
-          ? `${poll.tasks.myInProgress.length} in-progress task(s)`
-          : 'No in-progress tasks',
-        poll.tasks.availableToClaim.length > 0
-          ? `${poll.tasks.availableToClaim.length} task(s) available to claim`
-          : 'No claimable tasks',
-        `Team: ${poll.team.activeAgents.length} active / ${poll.team.totalAgents} total`,
-      ].join('\n');
-
-      emitResult({ project, poll }, text, asJson);
-    } catch (error) {
-      emitError(error instanceof Error ? error.message : String(error), asJson);
-    }
-  },
-});
+        );
+        watermark = computeWatermark(lastSeen, currentGen, projectObs.length);
+        teamStore.updateWatermark(agentId, currentGen);
+        teamStore.heartbeat(agentId);
+      }
+
+      const poll = computePoll(teamStore, project.id, agentId ?? null, watermark);
+      if (args.markInboxRead && agentId) {
+        teamStore.markAllRead(project.id, agentId);
+      }
+
+      const text = [
+        poll.agent ? `You: ${shortId(poll.agent.agentId)} (${poll.agent.status})` : 'Project-level overview',
+        poll.watermark.newObservationCount > 0
+          ? `${poll.watermark.newObservationCount} new observation(s)`
+          : 'No unseen observations',
+        poll.inbox.unreadCount > 0 ? `${poll.inbox.unreadCount} unread message(s)` : 'Inbox clear',
+        poll.tasks.myInProgress.length > 0
+          ? `${poll.tasks.myInProgress.length} in-progress task(s)`
+          : 'No in-progress tasks',
+        poll.tasks.availableToClaim.length > 0
+          ? `${poll.tasks.availableToClaim.length} task(s) available to claim`
+          : 'No claimable tasks',
+        `Team: ${poll.team.activeAgents.length} active / ${poll.team.totalAgents} total`,
+      ].join('\n');
+
+      emitResult({ project, poll }, text, asJson);
+    } catch (error) {
+      emitError(error instanceof Error ? error.message : String(error), asJson);
+    }
+  },
+});

package/src/cli/commands/reasoning.ts

@@ -1,6 +1,6 @@
-import { defineCommand } from 'citty';
-import { compactSearch } from '../../compact/engine.js';
-import { storeObservation } from '../../memory/observations.js';
+import { defineCommand } from 'citty';
+import { compactSearch } from '../../compact/engine.js';
+import { storeObservation } from '../../memory/observations.js';
 import {
   emitError,
   emitResult,
@@ -9,65 +9,65 @@ import {
   parsePositiveInt,
   resolveCliWriteScope,
 } from './operator-shared.js';
-
-export default defineCommand({
-  meta: {
-    name: 'reasoning',
-    description: 'Store and search decision rationale from the operator CLI',
-  },
-  args: {
-    entity: { type: 'string', description: 'Entity this reasoning applies to' },
-    decision: { type: 'string', description: 'Decision that was made' },
-    rationale: { type: 'string', description: 'Why this approach was chosen' },
-    alternatives: { type: 'string', description: 'Comma-separated alternatives that were considered' },
-    constraints: { type: 'string', description: 'Comma-separated constraints' },
-    expectedOutcome: { type: 'string', description: 'Expected outcome from this decision' },
-    risks: { type: 'string', description: 'Comma-separated risks or downsides' },
-    concepts: { type: 'string', description: 'Comma-separated related concepts' },
-    files: { type: 'string', description: 'Comma-separated file list' },
-    relatedCommits: { type: 'string', description: 'Comma-separated related commit hashes' },
+
+export default defineCommand({
+  meta: {
+    name: 'reasoning',
+    description: 'Store and search decision rationale from the operator CLI',
+  },
+  args: {
+    entity: { type: 'string', description: 'Entity this reasoning applies to' },
+    decision: { type: 'string', description: 'Decision that was made' },
+    rationale: { type: 'string', description: 'Why this approach was chosen' },
+    alternatives: { type: 'string', description: 'Comma-separated alternatives that were considered' },
+    constraints: { type: 'string', description: 'Comma-separated constraints' },
+    expectedOutcome: { type: 'string', description: 'Expected outcome from this decision' },
+    risks: { type: 'string', description: 'Comma-separated risks or downsides' },
+    concepts: { type: 'string', description: 'Comma-separated related concepts' },
+    files: { type: 'string', description: 'Comma-separated file list' },
+    relatedCommits: { type: 'string', description: 'Comma-separated related commit hashes' },
     relatedEntities: { type: 'string', description: 'Comma-separated related entity names' },
     visibility: { type: 'string', description: 'Reasoning visibility: project (default), personal, or team' },
-    query: { type: 'string', description: 'Search query for reasoning traces' },
-    limit: { type: 'string', description: 'Search result limit' },
-    scope: { type: 'string', description: 'project or global scope for search' },
-    json: { type: 'boolean', description: 'Emit machine-readable JSON output' },
-  },
-  run: async ({ args }) => {
-    const action = (args._ as string[])?.[0] || '';
-    const asJson = !!args.json;
-
-    try {
+    query: { type: 'string', description: 'Search query for reasoning traces' },
+    limit: { type: 'string', description: 'Search result limit' },
+    scope: { type: 'string', description: 'project or global scope for search' },
+    json: { type: 'boolean', description: 'Emit machine-readable JSON output' },
+  },
+  run: async ({ args }) => {
+    const action = (args._ as string[])?.[0] || '';
+    const asJson = !!args.json;
+
+    try {
       const { project, reader, identity } = await getCliProjectContext({ searchIndex: action === 'search' });
-
-      switch (action) {
-        case 'store': {
-          const entityName = (args.entity as string | undefined)?.trim();
-          const decision = (args.decision as string | undefined)?.trim();
-          const rationale = (args.rationale as string | undefined)?.trim();
-          if (!entityName || !decision || !rationale) {
-            emitError('entity, decision, and rationale are required for "memorix reasoning store"', asJson);
-            return;
-          }
-
-          const alternatives = parseCsvList(args.alternatives as string | undefined);
-          const constraints = parseCsvList(args.constraints as string | undefined);
-          const risks = parseCsvList(args.risks as string | undefined);
-          const concepts = parseCsvList(args.concepts as string | undefined);
-          const filesModified = parseCsvList(args.files as string | undefined);
-          const relatedCommits = parseCsvList(args.relatedCommits as string | undefined);
-          const relatedEntities = parseCsvList(args.relatedEntities as string | undefined);
-
-          const narrativeParts: string[] = [rationale];
-          if (alternatives.length > 0) {
-            narrativeParts.push(`Alternatives considered: ${alternatives.join('; ')}`);
-          }
-          if (constraints.length > 0) {
-            narrativeParts.push(`Constraints: ${constraints.join('; ')}`);
-          }
-          if (args.expectedOutcome) {
-            narrativeParts.push(`Expected outcome: ${String(args.expectedOutcome).trim()}`);
-          }
+
+      switch (action) {
+        case 'store': {
+          const entityName = (args.entity as string | undefined)?.trim();
+          const decision = (args.decision as string | undefined)?.trim();
+          const rationale = (args.rationale as string | undefined)?.trim();
+          if (!entityName || !decision || !rationale) {
+            emitError('entity, decision, and rationale are required for "memorix reasoning store"', asJson);
+            return;
+          }
+
+          const alternatives = parseCsvList(args.alternatives as string | undefined);
+          const constraints = parseCsvList(args.constraints as string | undefined);
+          const risks = parseCsvList(args.risks as string | undefined);
+          const concepts = parseCsvList(args.concepts as string | undefined);
+          const filesModified = parseCsvList(args.files as string | undefined);
+          const relatedCommits = parseCsvList(args.relatedCommits as string | undefined);
+          const relatedEntities = parseCsvList(args.relatedEntities as string | undefined);
+
+          const narrativeParts: string[] = [rationale];
+          if (alternatives.length > 0) {
+            narrativeParts.push(`Alternatives considered: ${alternatives.join('; ')}`);
+          }
+          if (constraints.length > 0) {
+            narrativeParts.push(`Constraints: ${constraints.join('; ')}`);
+          }
+          if (args.expectedOutcome) {
+            narrativeParts.push(`Expected outcome: ${String(args.expectedOutcome).trim()}`);
+          }
           if (risks.length > 0) {
             narrativeParts.push(`Risks: ${risks.join('; ')}`);
           }
@@ -77,70 +77,70 @@ export default defineCommand({
           );
 
           const result = await storeObservation({
-            entityName,
-            type: 'reasoning',
-            title: decision,
-            narrative: narrativeParts.join('. '),
-            facts: [
-              `Decision: ${decision}`,
-              ...alternatives.map((item) => `Alternative: ${item}`),
-              ...constraints.map((item) => `Constraint: ${item}`),
-              ...(args.expectedOutcome ? [`Expected outcome: ${String(args.expectedOutcome).trim()}`] : []),
-              ...risks.map((item) => `Risk: ${item}`),
-              ...relatedCommits.map((item) => `Commit: ${item}`),
-              ...relatedEntities.map((item) => `Related entity: ${item}`),
-            ],
-            concepts,
-            filesModified,
-            relatedCommits,
-            relatedEntities,
+            entityName,
+            type: 'reasoning',
+            title: decision,
+            narrative: narrativeParts.join('. '),
+            facts: [
+              `Decision: ${decision}`,
+              ...alternatives.map((item) => `Alternative: ${item}`),
+              ...constraints.map((item) => `Constraint: ${item}`),
+              ...(args.expectedOutcome ? [`Expected outcome: ${String(args.expectedOutcome).trim()}`] : []),
+              ...risks.map((item) => `Risk: ${item}`),
+              ...relatedCommits.map((item) => `Commit: ${item}`),
+              ...relatedEntities.map((item) => `Related entity: ${item}`),
+            ],
+            concepts,
+            filesModified,
+            relatedCommits,
+            relatedEntities,
             projectId: project.id,
             source: 'manual',
             ...writeScope,
-          });
-
-          emitResult(
-            { project, observation: result.observation, upserted: result.upserted },
-            `${result.upserted ? 'Updated' : 'Stored'} reasoning trace #${result.observation.id}: ${decision}`,
-            asJson,
-          );
-          return;
-        }
-
-        case 'search': {
-          const query = (args.query as string | undefined)?.trim();
-          if (!query) {
-            emitError('query is required for "memorix reasoning search"', asJson);
-            return;
-          }
-          const scope = (args.scope as string | undefined) === 'global' ? 'global' : 'project';
-          const limit = parsePositiveInt(args.limit as string | undefined, 10);
-          const result = await compactSearch({
-            query,
-            limit,
+          });
+
+          emitResult(
+            { project, observation: result.observation, upserted: result.upserted },
+            `${result.upserted ? 'Updated' : 'Stored'} reasoning trace #${result.observation.id}: ${decision}`,
+            asJson,
+          );
+          return;
+        }
+
+        case 'search': {
+          const query = (args.query as string | undefined)?.trim();
+          if (!query) {
+            emitError('query is required for "memorix reasoning search"', asJson);
+            return;
+          }
+          const scope = (args.scope as string | undefined) === 'global' ? 'global' : 'project';
+          const limit = parsePositiveInt(args.limit as string | undefined, 10);
+          const result = await compactSearch({
+            query,
+            limit,
             type: 'reasoning',
             projectId: scope === 'global' ? undefined : project.id,
             status: 'active',
             reader: scope === 'global' ? {} : reader,
-          });
-          emitResult(
-            { project, scope, entries: result.entries },
-            result.entries.length === 0 ? 'No reasoning traces found.' : `[REASONING] Reasoning traces\n${result.formatted}`,
-            asJson,
-          );
-          return;
-        }
-
-        default:
-          console.log('Memorix Reasoning Commands');
-          console.log('');
-          console.log('Usage:');
+          });
+          emitResult(
+            { project, scope, entries: result.entries },
+            result.entries.length === 0 ? 'No reasoning traces found.' : `[REASONING] Reasoning traces\n${result.formatted}`,
+            asJson,
+          );
+          return;
+        }
+
+        default:
+          console.log('Memorix Reasoning Commands');
+          console.log('');
+          console.log('Usage:');
           console.log('  memorix reasoning store --entity auth --decision "Use SQLite" --rationale "..." [--visibility project|personal|team]');
-          console.log('  memorix reasoning search --query "why sqlite" [--scope project|global --limit 10]');
-      }
-    } catch (error) {
-      emitError(error instanceof Error ? error.message : String(error), asJson);
-    }
-  },
-});
-
+          console.log('  memorix reasoning search --query "why sqlite" [--scope project|global --limit 10]');
+      }
+    } catch (error) {
+      emitError(error instanceof Error ? error.message : String(error), asJson);
+    }
+  },
+});
+

package/src/cli/commands/resume.ts

@@ -13,7 +13,9 @@ export default defineCommand({
   args: {
     task: { type: 'positional', description: 'Current continuation task', required: false },
     refresh: { type: 'string', description: 'Project scan policy: auto, always, or never' },
+    agent: { type: 'string', description: 'Optional target agent for compatible workflow selection' },
     json: { type: 'boolean', description: 'Emit machine-readable JSON output' },
+    briefJson: { type: 'boolean', description: 'Emit only the bounded agent brief and receipt JSON' },
   },
   async run({ args }) {
     await contextCommand.run?.({
@@ -21,7 +23,9 @@ export default defineCommand({
         _: [],
         input: args.task,
         refresh: args.refresh,
+        agent: args.agent,
         json: args.json,
+        briefJson: args.briefJson,
         resume: true,
       },
       rawArgs: [],

package/src/cli/commands/skills.ts

@@ -1,128 +1,128 @@
-import { defineCommand } from 'citty';
+import { defineCommand } from 'citty';
 import type { AgentTarget } from '../../types.js';
 import { getObservationStore } from '../../store/obs-store.js';
 import { filterReadableObservations, resolveObservationVisibility } from '../../memory/visibility.js';
-import { emitError, emitResult, getCliProjectContext } from './operator-shared.js';
-
-export default defineCommand({
-  meta: {
-    name: 'skills',
-    description: 'Discover, generate, and inspect project skills from the CLI',
-  },
-  args: {
-    name: { type: 'string', description: 'Skill name for "show"' },
-    target: { type: 'string', description: 'Target agent for generated skills' },
-    write: { type: 'boolean', description: 'Write generated skills to disk' },
-    json: { type: 'boolean', description: 'Emit machine-readable JSON output' },
-  },
-  run: async ({ args }) => {
-    const action = (args._ as string[])?.[0] || '';
-    const asJson = !!args.json;
-
-    try {
+import { emitError, emitResult, getCliProjectContext } from './operator-shared.js';
+
+export default defineCommand({
+  meta: {
+    name: 'skills',
+    description: 'Discover, generate, and inspect project skills from the CLI',
+  },
+  args: {
+    name: { type: 'string', description: 'Skill name for "show"' },
+    target: { type: 'string', description: 'Target agent for generated skills' },
+    write: { type: 'boolean', description: 'Write generated skills to disk' },
+    json: { type: 'boolean', description: 'Emit machine-readable JSON output' },
+  },
+  run: async ({ args }) => {
+    const action = (args._ as string[])?.[0] || '';
+    const asJson = !!args.json;
+
+    try {
       const { project, reader } = await getCliProjectContext();
-      const { SkillsEngine } = await import('../../skills/engine.js');
-      const engine = new SkillsEngine(project.rootPath);
-
-      switch (action) {
-        case 'list': {
-          const skills = engine.listSkills();
-          emitResult(
-            { project, skills },
-            skills.length === 0
-              ? 'No skills found in project or global agent directories.'
-              : skills.map((skill) => `- ${skill.name} (${skill.sourceAgent})`).join('\n'),
-            asJson,
-          );
-          return;
-        }
-
-        case 'generate': {
+      const { SkillsEngine } = await import('../../skills/engine.js');
+      const engine = new SkillsEngine(project.rootPath);
+
+      switch (action) {
+        case 'list': {
+          const skills = engine.listSkills();
+          emitResult(
+            { project, skills },
+            skills.length === 0
+              ? 'No skills found in project or global agent directories.'
+              : skills.map((skill) => `- ${skill.name} (${skill.sourceAgent})`).join('\n'),
+            asJson,
+          );
+          return;
+        }
+
+        case 'generate': {
           const observations = filterReadableObservations(
             await getObservationStore().loadAll(),
             reader,
           ).filter((observation) => resolveObservationVisibility(observation) === 'project')
             .map((obs) => ({
-              id: obs.id,
-              entityName: obs.entityName,
-              type: obs.type,
-              title: obs.title,
-              narrative: obs.narrative,
-              facts: obs.facts,
-              concepts: obs.concepts,
-              filesModified: obs.filesModified,
-              createdAt: obs.createdAt,
-              status: obs.status,
-              source: obs.source,
-            }));
-          const skills = engine.generateFromObservations(observations);
-          const written: string[] = [];
-          if (args.write && args.target) {
-            for (const skill of skills) {
-              const writtenPath = engine.writeSkill(skill, args.target as AgentTarget);
-              if (writtenPath) written.push(writtenPath);
-            }
-          }
-          emitResult(
-            { project, skills, written },
-            skills.length === 0
-              ? 'No skill-worthy patterns found yet.'
-              : skills.map((skill) => `- ${skill.name}: ${skill.description}`).join('\n'),
-            asJson,
-          );
-          return;
-        }
-
-        case 'show': {
-          const name = (args.name as string | undefined)?.trim();
-          if (!name) {
-            emitError('name is required for "memorix skills show"', asJson);
-            return;
-          }
-          const direct = engine.injectSkill(name);
-          if (direct) {
-            emitResult({ project, skill: direct }, direct.content, asJson);
-            return;
-          }
-
+              id: obs.id,
+              entityName: obs.entityName,
+              type: obs.type,
+              title: obs.title,
+              narrative: obs.narrative,
+              facts: obs.facts,
+              concepts: obs.concepts,
+              filesModified: obs.filesModified,
+              createdAt: obs.createdAt,
+              status: obs.status,
+              source: obs.source,
+            }));
+          const skills = engine.generateFromObservations(observations);
+          const written: string[] = [];
+          if (args.write && args.target) {
+            for (const skill of skills) {
+              const writtenPath = engine.writeSkill(skill, args.target as AgentTarget);
+              if (writtenPath) written.push(writtenPath);
+            }
+          }
+          emitResult(
+            { project, skills, written },
+            skills.length === 0
+              ? 'No skill-worthy patterns found yet.'
+              : skills.map((skill) => `- ${skill.name}: ${skill.description}`).join('\n'),
+            asJson,
+          );
+          return;
+        }
+
+        case 'show': {
+          const name = (args.name as string | undefined)?.trim();
+          if (!name) {
+            emitError('name is required for "memorix skills show"', asJson);
+            return;
+          }
+          const direct = engine.injectSkill(name);
+          if (direct) {
+            emitResult({ project, skill: direct }, direct.content, asJson);
+            return;
+          }
+
           const observations = filterReadableObservations(
             await getObservationStore().loadAll(),
             reader,
           ).filter((observation) => resolveObservationVisibility(observation) === 'project')
             .map((obs) => ({
-              id: obs.id,
-              entityName: obs.entityName,
-              type: obs.type,
-              title: obs.title,
-              narrative: obs.narrative,
-              facts: obs.facts,
-              concepts: obs.concepts,
-              filesModified: obs.filesModified,
-              createdAt: obs.createdAt,
-              status: obs.status,
-              source: obs.source,
-            }));
-          const generated = engine.generateFromObservations(observations);
-          const skill = generated.find((entry) => entry.name.toLowerCase() === name.toLowerCase());
-          if (!skill) {
-            emitError(`Skill "${name}" not found`, asJson);
-            return;
-          }
-          emitResult({ project, skill }, skill.content, asJson);
-          return;
-        }
-
-        default:
-          console.log('Memorix Skills Commands');
-          console.log('');
-          console.log('Usage:');
-          console.log('  memorix skills list');
-          console.log('  memorix skills generate [--write --target codex]');
-          console.log('  memorix skills show --name <skill>');
-      }
-    } catch (error) {
-      emitError(error instanceof Error ? error.message : String(error), asJson);
-    }
-  },
-});
-
+              id: obs.id,
+              entityName: obs.entityName,
+              type: obs.type,
+              title: obs.title,
+              narrative: obs.narrative,
+              facts: obs.facts,
+              concepts: obs.concepts,
+              filesModified: obs.filesModified,
+              createdAt: obs.createdAt,
+              status: obs.status,
+              source: obs.source,
+            }));
+          const generated = engine.generateFromObservations(observations);
+          const skill = generated.find((entry) => entry.name.toLowerCase() === name.toLowerCase());
+          if (!skill) {
+            emitError(`Skill "${name}" not found`, asJson);
+            return;
+          }
+          emitResult({ project, skill }, skill.content, asJson);
+          return;
+        }
+
+        default:
+          console.log('Memorix Skills Commands');
+          console.log('');
+          console.log('Usage:');
+          console.log('  memorix skills list');
+          console.log('  memorix skills generate [--write --target codex]');
+          console.log('  memorix skills show --name <skill>');
+      }
+    } catch (error) {
+      emitError(error instanceof Error ? error.message : String(error), asJson);
+    }
+  },
+});
+