nexus-ai-pro 2.1.0 → 2.3.0

package/dist/deep-agent/index.js

@@ -0,0 +1,216 @@
+import { agentInput, createAgent, } from '../agent/create-agent.js';
+import { contextEditor } from '../agent/middleware/context-editor.js';
+import { filesystemContext } from '../agent/middleware/filesystem.js';
+import { toolSelector } from '../agent/middleware/tool-selector.js';
+import { permissionPolicy } from '../agent/permissions.js';
+import { sandboxTools } from '../agent/sandbox.js';
+import { tool } from '../agent/tool.js';
+const MOUNT = '/workspace';
+const CORE_TOOLS = [
+    'write_todos',
+    'delegate',
+    'load_skill',
+    'read_file',
+    'write_file',
+    'edit_file',
+    'list_files',
+    'run_command',
+];
+export function createDeepAgent(options) {
+    const { instructions, sandbox, commands = [], planning = true, subagents = [], skills = [], include = ['AGENTS.md'], offload, contextEditing, toolSelection, permissions, middleware = [], tools: extraTools = [], ...agentOptions } = options;
+    const workspace = sandbox
+        ? [...sandboxTools(sandbox, { shell: commands.length > 0, mount: MOUNT }), editFileTool(sandbox)]
+        : [];
+    const own = [
+        ...(planning ? [writeTodosTool()] : []),
+        ...(skills.length > 0 ? [loadSkillTool(skills, sandbox)] : []),
+        ...workspace,
+        ...extraTools,
+    ];
+    const helpers = new Map();
+    const approved = new Set(Object.keys(agentOptions.interruptOn ?? {}));
+    const { interruptOn: _approvals, ...helperOptions } = agentOptions;
+    for (const helper of subagents) {
+        const allowed = helper.tools ? new Set(helper.tools) : undefined;
+        helpers.set(helper.name, createAgent({
+            ...helperOptions,
+            name: `${options.name ?? 'deep-agent'}.${helper.name}`,
+            ...(helper.model ? { model: helper.model } : {}),
+            maxIterations: helper.maxIterations ?? 20,
+            systemPrompt: `${helper.instructions}\n\n${WORKSPACE_NOTE}`,
+            tools: own.filter((candidate) => !approved.has(candidate.name) && (allowed ? allowed.has(candidate.name) : true)),
+            ...(permissions === false ? {} : { permissions: permissions ?? defaultPolicy(commands) }),
+            checkpointer: false,
+        }));
+    }
+    const tools = [...own, ...(helpers.size > 0 ? [delegateTool(subagents, helpers)] : [])];
+    const kit = [
+        ...(sandbox && (include.length > 0 || offload !== false)
+            ? [
+                filesystemContext({
+                    source: sandbox,
+                    include,
+                    ...(offload === false ? {} : { offload: { overChars: 20_000, ...offload } }),
+                }),
+            ]
+            : []),
+        ...(contextEditing === false
+            ? []
+            : [
+                contextEditor({
+                    triggerTokens: 60_000,
+                    ...contextEditing,
+                    exclude: ['write_todos', ...(contextEditing?.exclude ?? [])],
+                }),
+            ]),
+        ...(toolSelection
+            ? [toolSelector({ ...toolSelection, always: [...CORE_TOOLS, ...(toolSelection.always ?? [])] })]
+            : []),
+    ];
+    return createAgent({
+        maxIterations: 40,
+        ...agentOptions,
+        systemPrompt: systemPrompt(instructions, { planning, sandbox: Boolean(sandbox), commands, subagents, skills }),
+        tools,
+        middleware: [...kit, ...middleware],
+        ...(permissions === false ? {} : { permissions: permissions ?? defaultPolicy(commands) }),
+    });
+}
+function defaultPolicy(commands) {
+    return permissionPolicy({
+        filesystem: { write: [`${MOUNT}/**`] },
+        shell: { allow: commands },
+        tools: { write_todos: 'allow', delegate: 'allow', load_skill: 'allow' },
+    });
+}
+const WORKSPACE_NOTE = `Files live in ${MOUNT}; paths are relative to it.`;
+function systemPrompt(instructions, parts) {
+    const lines = [];
+    if (instructions)
+        lines.push(instructions, '');
+    lines.push('Work through the task step by step, checking each step before the next.');
+    if (parts.planning) {
+        lines.push('For any task of more than two steps, first record a plan with write_todos, then keep it current: mark a step in_progress when you start it and completed when it is done.');
+    }
+    if (parts.sandbox) {
+        lines.push(`${WORKSPACE_NOTE} Read before you change a file; prefer edit_file to rewriting a whole file. A large result may be saved to a file and shown as a preview: read the file when you need the rest.`);
+        if (parts.commands.length > 0)
+            lines.push(`You may run these commands: ${parts.commands.join(', ')}.`);
+    }
+    if (parts.subagents.length > 0) {
+        lines.push('', 'Delegate a self-contained piece of work with delegate, to one of:');
+        for (const helper of parts.subagents)
+            lines.push(`- ${helper.name}: ${helper.description}`);
+    }
+    if (parts.skills.length > 0) {
+        lines.push('', 'Skills you can load with load_skill when a task calls for one:');
+        for (const skill of parts.skills)
+            lines.push(`- ${skill.name}: ${skill.description}`);
+    }
+    return lines.join('\n');
+}
+function writeTodosTool() {
+    return tool({
+        name: 'write_todos',
+        description: 'Records the plan for this task as a list of steps, each pending, in_progress, or completed. Send the whole list each time.',
+        parameters: {
+            type: 'object',
+            properties: {
+                todos: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            content: { type: 'string' },
+                            status: { type: 'string', enum: ['pending', 'in_progress', 'completed'] },
+                        },
+                        required: ['content', 'status'],
+                    },
+                },
+            },
+            required: ['todos'],
+        },
+        capabilities: [],
+        execute: ({ todos }) => {
+            const list = Array.isArray(todos) ? todos : [];
+            const mark = { pending: '[ ]', in_progress: '[~]', completed: '[x]' };
+            const done = list.filter((todo) => todo.status === 'completed').length;
+            return `Plan (${done}/${list.length} done):\n${list.map((todo) => `${mark[todo.status] ?? '[ ]'} ${todo.content}`).join('\n')}`;
+        },
+    });
+}
+function editFileTool(sandbox) {
+    const local = (file) => String(file ?? '')
+        .replace(/\\/g, '/')
+        .replace(new RegExp(`^${MOUNT}/`), '')
+        .replace(/^\/+/, '');
+    return tool({
+        name: 'edit_file',
+        description: `Replaces one exact occurrence of old_text with new_text in a file. Paths are relative to ${MOUNT}.`,
+        parameters: {
+            type: 'object',
+            properties: { path: { type: 'string' }, old_text: { type: 'string' }, new_text: { type: 'string' } },
+            required: ['path', 'old_text', 'new_text'],
+        },
+        capabilities: (args) => [`filesystem:write:${MOUNT}/${local(args.path)}`],
+        execute: async ({ path, old_text: oldText, new_text: newText }) => {
+            const file = local(path);
+            const text = await sandbox.readFile(file);
+            const count = text.split(String(oldText)).length - 1;
+            if (count === 0)
+                throw new Error(`old_text was not found in ${file}`);
+            if (count > 1)
+                throw new Error(`old_text appears ${count} times in ${file}; include more context so it appears once`);
+            await sandbox.writeFile(file, text.replace(String(oldText), () => String(newText)));
+            return { edited: file };
+        },
+    });
+}
+function loadSkillTool(skills, sandbox) {
+    const byName = new Map(skills.map((skill) => [skill.name, skill]));
+    return tool({
+        name: 'load_skill',
+        description: 'Loads the instructions of a skill by name.',
+        parameters: {
+            type: 'object',
+            properties: { name: { type: 'string', enum: skills.map((skill) => skill.name) } },
+            required: ['name'],
+        },
+        capabilities: [],
+        execute: async ({ name }) => {
+            const skill = byName.get(String(name));
+            if (!skill)
+                throw new Error(`No skill named "${String(name)}"`);
+            if (skill.instructions !== undefined)
+                return skill.instructions;
+            if (skill.file && sandbox)
+                return sandbox.readFile(skill.file);
+            throw new Error(`Skill "${skill.name}" has no instructions`);
+        },
+    });
+}
+function delegateTool(subagents, helpers) {
+    return tool({
+        name: 'delegate',
+        description: 'Hands a self-contained task to a helper, which works in a fresh context and returns its answer.',
+        parameters: {
+            type: 'object',
+            properties: {
+                agent: { type: 'string', enum: subagents.map((helper) => helper.name) },
+                task: { type: 'string', description: 'Everything the helper needs to know: it sees nothing else.' },
+            },
+            required: ['agent', 'task'],
+        },
+        capabilities: [],
+        execute: async ({ agent, task }, context) => {
+            const helper = helpers.get(String(agent));
+            if (!helper)
+                throw new Error(`No helper named "${String(agent)}"`);
+            const result = await helper.invoke(agentInput(String(task)), {
+                ...(context.principal ? { principal: context.principal } : {}),
+                ...(context.signal ? { signal: context.signal } : {}),
+            });
+            return (result.state.answer || `The ${String(agent)} helper finished without an answer (${result.state.stopReason}).`);
+        },
+    });
+}

package/dist/doctor/index.d.ts

@@ -0,0 +1,90 @@
+import type { SchemaMigration } from '../utils/schema-migrations.js';
+/** How one check came out: `fail` breaks the deployment, `warn` needs a look, `skip` had nothing to check. */
+export type DoctorStatus = 'ok' | 'warn' | 'fail' | 'skip';
+/** One check's result. */
+export interface DoctorCheck {
+    /** A stable id, such as `node` or `migrations`. */
+    id: string;
+    /** What was checked, in a few words. */
+    title: string;
+    /** How it came out. */
+    status: DoctorStatus;
+    /** What was found. Never a secret's value. */
+    detail: string;
+    /** What to do about a warning or a failure. */
+    hint?: string;
+}
+/** Every check's result, and whether the deployment can run. */
+export interface DoctorReport {
+    /** The checks, in the order they ran. */
+    checks: DoctorCheck[];
+    /** True when nothing failed. */
+    ok: boolean;
+    /** Checks that failed. */
+    failures: number;
+    /** Checks that warned. */
+    warnings: number;
+}
+/** A database for the doctor to reach, as `nexus db` reaches one. */
+export interface DoctorDatabase {
+    /** A Postgres client (`query`) or a SQLite handle or client. */
+    client: unknown;
+    /** Which kind it is. Detected from the client when omitted. */
+    dialect?: 'postgres' | 'sqlite';
+    /** The migrations it should have. Defaults to every bundled adapter's on its default tables. */
+    migrations?: readonly SchemaMigration[];
+    /** The table that records applied migrations. */
+    table?: string;
+}
+/** What the doctor knows about how the application is deployed. */
+export interface DoctorDeployment {
+    /** How many replicas run it. Settings that keep state in one process are checked only above 1. */
+    replicas: number;
+    /**
+     * The stores and shared state it uses, by any name: a checkpointer, the operation store, the
+     * server's state, tenant usage, a rate-limit store, a circuit store, a cache. Each is reported when
+     * it keeps its state in process memory, where each replica would see only its own.
+     */
+    stores?: Record<string, unknown>;
+}
+/** What `diagnose()` checks. Everything is optional; a check without its input is skipped. */
+export interface DoctorOptions {
+    /** The Node.js version to check. Defaults to the running one. */
+    nodeVersion?: string;
+    /** Where credentials are read from. Defaults to `process.env`. Only names are reported. */
+    env?: Record<string, string | undefined>;
+    /** Whether a package is installed. Defaults to resolving it from the working directory. */
+    resolvePackage?: (name: string) => boolean;
+    /** A database: connectivity, and migrations pending or changed. */
+    database?: DoctorDatabase;
+    /** A Redis client to ping. */
+    redis?: {
+        ping(): unknown;
+    };
+    /** An operation store, read for leases that lapsed and a queue nobody drains. */
+    operations?: {
+        stats?(now: string): unknown;
+        list?(): unknown;
+    };
+    /** How long the oldest queued operation may wait before the queue counts as stalled. Defaults to 15 minutes. */
+    maxQueueAgeMs?: number;
+    /** A client, read for provider health. */
+    ai?: {
+        getProviderHealth(): ReadonlyArray<{
+            providerName: string;
+            healthy: boolean;
+            stale?: boolean;
+        }>;
+    };
+    /** How old the bundled model registry may be, in days. Defaults to the registry's own window. */
+    registryMaxAgeDays?: number;
+    /** How the application is deployed. */
+    deployment?: DoctorDeployment;
+    /** Replaces the clock, for tests. */
+    now?: () => Date;
+}
+/**
+ * Runs every check its options allow and reports each, never throwing: a check that cannot run is a
+ * failure with the reason.
+ */
+export declare function diagnose(options?: DoctorOptions): Promise<DoctorReport>;

package/dist/doctor/index.js

@@ -0,0 +1,237 @@
+import { createRequire } from 'node:module';
+import path from 'node:path';
+const PEERS = {
+    openai: 'the OpenAI SDK, used only where an application passes one in',
+    '@anthropic-ai/sdk': 'the Anthropic SDK, likewise',
+    ollama: 'the Ollama client',
+    zod: 'zod schemas for tools and structured output',
+    ajv: 'JSON Schema validation of structured output',
+    'ajv-formats': 'formats for ajv',
+};
+const CREDENTIALS = {
+    openai: ['OPENAI_API_KEY'],
+    anthropic: ['ANTHROPIC_API_KEY'],
+    google: ['GOOGLE_API_KEY', 'GEMINI_API_KEY'],
+    'azure-openai': ['AZURE_OPENAI_API_KEY'],
+    groq: ['GROQ_API_KEY'],
+    mistral: ['MISTRAL_API_KEY'],
+    cohere: ['COHERE_API_KEY', 'CO_API_KEY'],
+    deepseek: ['DEEPSEEK_API_KEY'],
+    openrouter: ['OPENROUTER_API_KEY'],
+};
+const PROCESS_LOCAL = {
+    MemoryGraphCheckpointer: { status: 'fail', why: 'a thread started on one replica cannot be resumed on another' },
+    MemoryOperationStore: { status: 'fail', why: 'operations and server runs are invisible to other replicas' },
+    MemoryServerStore: { status: 'fail', why: 'threads and runs exist only on the replica that created them' },
+    MemoryRunEventLog: { status: 'fail', why: 'a client reconnecting to another replica cannot follow its run' },
+    MemoryTenantUsage: { status: 'fail', why: 'each replica counts its own tenant limits, multiplying them' },
+    MemoryRateLimitStore: { status: 'warn', why: 'each replica enforces its own limit, multiplying it' },
+    MemoryCircuitStateStore: { status: 'warn', why: 'a circuit opened on one replica stays closed on the others' },
+    MemoryStore: { status: 'warn', why: 'long-term memory written on one replica is missing on the others' },
+    MemoryTraceStore: { status: 'warn', why: 'each replica keeps only its own traces' },
+    MemoryPromptStore: { status: 'warn', why: 'a prompt promoted on one replica is not served by the others' },
+    MemoryCacheAdapter: { status: 'warn', why: 'each replica caches separately' },
+    MemoryRollupStore: { status: 'warn', why: 'each replica sums only its own runs' },
+};
+export async function diagnose(options = {}) {
+    const now = options.now ?? (() => new Date());
+    const checks = [];
+    const run = async (id, title, check) => {
+        try {
+            checks.push({ id, title, ...(await check()) });
+        }
+        catch (error) {
+            checks.push({ id, title, status: 'fail', detail: error instanceof Error ? error.message : String(error) });
+        }
+    };
+    await run('node', 'Node.js version', () => nodeCheck(options.nodeVersion ?? process.versions.node));
+    await run('peers', 'Optional packages', () => peersCheck(options.resolvePackage ?? defaultResolver()));
+    await run('credentials', 'Provider credentials', () => credentialsCheck(options.env ?? process.env));
+    await run('registry', 'Model registry age', () => registryCheck(now(), options.registryMaxAgeDays));
+    await run('database', 'Database connectivity', () => databaseCheck(options.database));
+    await run('migrations', 'Schema migrations', () => migrationsCheck(options.database));
+    await run('redis', 'Redis', () => redisCheck(options.redis));
+    await run('queue', 'Operation queue and leases', () => queueCheck(options.operations, now(), options.maxQueueAgeMs));
+    await run('health', 'Provider health', () => healthCheck(options.ai));
+    await run('topology', 'Settings that only work in one process', () => topologyCheck(options.deployment));
+    const failures = checks.filter((check) => check.status === 'fail').length;
+    const warnings = checks.filter((check) => check.status === 'warn').length;
+    return { checks, ok: failures === 0, failures, warnings };
+}
+function nodeCheck(version) {
+    const major = Number(version.replace(/^v/, '').split('.')[0]);
+    return major >= 22
+        ? { status: 'ok', detail: `Node.js ${version}` }
+        : { status: 'fail', detail: `Node.js ${version}; this package needs 22 or newer`, hint: 'Upgrade Node.js.' };
+}
+function defaultResolver() {
+    const resolve = createRequire(path.join(process.cwd(), 'package.json')).resolve;
+    return (name) => {
+        try {
+            resolve(name);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+}
+function peersCheck(resolve) {
+    const installed = Object.keys(PEERS).filter((name) => resolve(name));
+    const missing = Object.keys(PEERS).filter((name) => !installed.includes(name));
+    return {
+        status: 'ok',
+        detail: `Installed: ${installed.length ? installed.join(', ') : 'none'}. Not installed: ${missing.length ? missing.join(', ') : 'none'}. Every one is optional; install only what you use.`,
+    };
+}
+function credentialsCheck(env) {
+    const found = Object.entries(CREDENTIALS)
+        .filter(([, names]) => names.some((name) => Boolean(env[name]?.trim())))
+        .map(([provider]) => provider);
+    return found.length
+        ? { status: 'ok', detail: `Credentials found for ${found.join(', ')}.` }
+        : {
+            status: 'warn',
+            detail: 'No provider credential found in the environment.',
+            hint: 'Set the API key of each hosted provider you use, such as OPENAI_API_KEY. Local providers need none.',
+        };
+}
+async function registryCheck(now, maxAgeDays) {
+    const { checkRegistryFreshness } = await import('../models/registry.js');
+    const freshness = checkRegistryFreshness({ now, ...(maxAgeDays === undefined ? {} : { maxAgeDays }) });
+    return freshness.stale
+        ? {
+            status: 'warn',
+            detail: `The bundled registry was verified ${freshness.ageDays} days ago (${freshness.verifiedAt}), past its ${freshness.maxAgeDays}-day window.`,
+            hint: 'Upgrade nexus-ai-pro, or override stale entries with models.registry.',
+        }
+        : { status: 'ok', detail: `Verified ${freshness.ageDays} days ago (${freshness.verifiedAt}).` };
+}
+function dialectOf(database) {
+    if (database.dialect)
+        return database.dialect;
+    const client = database.client;
+    if (client && typeof client.query === 'function')
+        return 'postgres';
+    return 'sqlite';
+}
+async function databaseCheck(database) {
+    if (!database)
+        return { status: 'skip', detail: 'No database given.' };
+    const dialect = dialectOf(database);
+    if (dialect === 'postgres') {
+        await database.client.query('SELECT 1');
+    }
+    else {
+        const { toSqliteClient } = await import('../sqlite/client.js');
+        await toSqliteClient(database.client).all('SELECT 1', []);
+    }
+    return { status: 'ok', detail: `Reached the ${dialect === 'postgres' ? 'Postgres' : 'SQLite'} database.` };
+}
+async function migrationsCheck(database) {
+    if (!database)
+        return { status: 'skip', detail: 'No database given.' };
+    const dialect = dialectOf(database);
+    const options = database.table ? { table: database.table } : {};
+    let status;
+    if (dialect === 'postgres') {
+        const [{ postgresMigrations }, { postgresMigrationStatus }] = await Promise.all([
+            import('../postgres/index.js'),
+            import('../postgres/migrations.js'),
+        ]);
+        status = await postgresMigrationStatus(database.client, database.migrations ?? postgresMigrations(), options);
+    }
+    else {
+        const [{ sqliteMigrations }, { sqliteMigrationStatus }] = await Promise.all([
+            import('../sqlite/index.js'),
+            import('../sqlite/migrations.js'),
+        ]);
+        status = await sqliteMigrationStatus(database.client, database.migrations ?? sqliteMigrations(), options);
+    }
+    if (status.changed.length) {
+        return {
+            status: 'fail',
+            detail: `${status.changed.length} migration${status.changed.length === 1 ? '' : 's'} changed after running: ${status.changed.map(({ migration }) => `${migration.component} v${migration.version}`).join(', ')}.`,
+            hint: 'A migration never changes once applied. Check the adapter options match those it ran with.',
+        };
+    }
+    if (status.pending.length) {
+        return {
+            status: 'fail',
+            detail: `${status.pending.length} pending: ${status.pending.map((migration) => `${migration.component} v${migration.version}`).join(', ')}.`,
+            hint: 'Run: nexus db migrate --client db.mjs',
+        };
+    }
+    const newer = status.unknown.length ? ` ${status.unknown.length} recorded by a newer release.` : '';
+    return { status: 'ok', detail: `${status.applied.length} applied, none pending.${newer}` };
+}
+async function redisCheck(redis) {
+    if (!redis)
+        return { status: 'skip', detail: 'No Redis client given.' };
+    const reply = await redis.ping();
+    return { status: 'ok', detail: `PING answered ${String(reply)}.` };
+}
+async function queueCheck(operations, now, maxQueueAgeMs = 15 * 60_000) {
+    if (!operations)
+        return { status: 'skip', detail: 'No operation store given.' };
+    const { operationStats } = await import('../operations/stats.js');
+    const stats = await operationStats(operations, { now });
+    const problems = [];
+    if (stats.lapsedLeases > 0) {
+        problems.push(`${stats.lapsedLeases} running operation${stats.lapsedLeases === 1 ? '' : 's'} hold a lease that lapsed`);
+    }
+    const age = stats.oldestQueuedAt ? now.getTime() - Date.parse(stats.oldestQueuedAt) : 0;
+    if (age > maxQueueAgeMs)
+        problems.push(`the oldest queued operation has waited ${Math.round(age / 60_000)} minutes`);
+    const counts = Object.entries(stats.byStatus)
+        .map(([status, count]) => `${count} ${status}`)
+        .join(', ');
+    return problems.length
+        ? {
+            status: 'warn',
+            detail: `${problems.join('; ')}. (${counts || 'nothing unfinished'})`,
+            hint: 'Run recovery — OperationRunner.recover(), or the agent server with recoverEveryMs — and a worker that claims the queue.',
+        }
+        : { status: 'ok', detail: counts ? `Unfinished: ${counts}. No lapsed lease.` : 'Nothing unfinished.' };
+}
+function healthCheck(ai) {
+    if (!ai)
+        return { status: 'skip', detail: 'No client given.' };
+    const snapshots = ai.getProviderHealth();
+    if (snapshots.length === 0)
+        return { status: 'skip', detail: 'Health tracking is off, or no provider has been called.' };
+    const stale = snapshots.filter((item) => item.stale).map((item) => item.providerName);
+    const unhealthy = snapshots.filter((item) => !item.healthy && !item.stale).map((item) => item.providerName);
+    const issues = [
+        ...(stale.length ? [`stale: ${stale.join(', ')}`] : []),
+        ...(unhealthy.length ? [`unhealthy: ${unhealthy.join(', ')}`] : []),
+    ];
+    return issues.length
+        ? {
+            status: 'warn',
+            detail: `${issues.join('; ')}.`,
+            hint: 'Refresh stale entries with ai.checkProviders({ staleOnly: true }).',
+        }
+        : { status: 'ok', detail: `${snapshots.length} provider${snapshots.length === 1 ? '' : 's'} healthy.` };
+}
+function topologyCheck(deployment) {
+    if (!deployment)
+        return { status: 'skip', detail: 'No deployment described.' };
+    if (deployment.replicas <= 1)
+        return { status: 'ok', detail: 'One replica: in-process state is shared by everything.' };
+    const findings = [];
+    for (const [name, value] of Object.entries(deployment.stores ?? {})) {
+        const kind = value?.constructor?.name;
+        const known = kind ? PROCESS_LOCAL[kind] : undefined;
+        if (known)
+            findings.push({ status: known.status, text: `${name} is a ${kind}: ${known.why}` });
+    }
+    if (findings.length === 0) {
+        return { status: 'ok', detail: `${deployment.replicas} replicas, and nothing keeps its state in one process.` };
+    }
+    return {
+        status: findings.some((finding) => finding.status === 'fail') ? 'fail' : 'warn',
+        detail: `${deployment.replicas} replicas: ${findings.map((finding) => finding.text).join('; ')}.`,
+        hint: 'Use the Redis, Postgres, or SQLite adapter for each, or run one replica.',
+    };
+}