@alisio/core 0.1.0-alpha.18 → 0.1.0-alpha.19

package/dist/application.d.ts

@@ -13,6 +13,7 @@ import { Skills } from "./resources/skills.ts";
 import { type ExternalDirectoryHandler, PathAccess } from "./runtime/access.ts";
 import { BlobStore } from "./runtime/blobs.ts";
 import { SQLiteStore } from "./runtime/store.ts";
+import { SideQuestions } from "./sessions/side-questions.ts";
 export interface AppOptions {
     cwd?: string;
     config?: string;
@@ -209,6 +210,8 @@ export declare function createApplication(options?: AppOptions): Promise<{
         profileName: undefined;
     } | undefined;
     runner: AgentRunner;
+    /** `/btw` side questions: tool-less answers about a session outside its conversation. */
+    sideQuestions: SideQuestions;
     herdr: HerdrBridge;
     contextWindow: (model: string) => number | undefined;
     /** Effective context budget + compaction point shared by the runner and the TUI bar. */

package/dist/application.js

@@ -20,6 +20,7 @@ import { isPathSpec } from "./runtime/modules.js";
 import { findWorkspace } from "./runtime/paths.js";
 import { SQLiteStore } from "./runtime/store.js";
 import { ChildSessions } from "./sessions/children.js";
+import { SideQuestions } from "./sessions/side-questions.js";
 const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 /**
  * Cap per teardown stage of `app.close()`: exit must never wait longer than this on a hanging
@@ -859,6 +860,8 @@ export async function createApplication(options = {}) {
                 return providerInfo;
             },
             runner,
+            /** `/btw` side questions: tool-less answers about a session outside its conversation. */
+            sideQuestions: new SideQuestions({ runner, state: store }),
             herdr,
             contextWindow,
             /** Effective context budget + compaction point shared by the runner and the TUI bar. */

package/dist/commands/builtins.js

@@ -105,6 +105,13 @@ export const BUILTIN_COMMANDS = [
         surfaces: INTERACTIVE,
         execution: "surface",
     },
+    {
+        name: "btw",
+        description: "Ask a side question about the session without adding to the conversation",
+        argumentHint: "[question]",
+        surfaces: ALL,
+        execution: "core",
+    },
     {
         name: "exit",
         description: "Exit Alisio",

package/dist/commands/catalog.d.ts

@@ -11,6 +11,7 @@ import type { AgentRunner } from "../core/runner.ts";
 import type { McpServerInfo } from "../mcp/connector.ts";
 import type { PromptTemplate } from "../resources/prompts.ts";
 import type { SkillCatalogEntry } from "../resources/skills.ts";
+import { type SideQuestions } from "../sessions/side-questions.ts";
 import { BUILTIN_COMMANDS, type BuiltinCommand } from "./builtins.ts";
 export { BUILTIN_COMMANDS, type BuiltinCommand };
 export type CommandSurface = CommandDescriptor["surfaces"][number];
@@ -55,6 +56,8 @@ export interface CommandHost {
         };
     };
     updateSetting?(key: "agents.effort", value: unknown): Promise<string>;
+    /** `/btw` side questions (tool-less, outside the conversation). */
+    sideQuestions?: Pick<SideQuestions, "ask" | "history">;
 }
 export interface CommandExecutionContext {
     sessionId: string;

package/dist/commands/catalog.js

@@ -1,4 +1,5 @@
 import { agentCatalogFromState, resolveActiveAgent } from "../agents/active.js";
+import { formatSideQuestion, SIDE_QUESTION_DESCRIPTION, SIDE_QUESTION_USAGE, } from "../sessions/side-questions.js";
 import { BUILTIN_COMMANDS } from "./builtins.js";
 export { BUILTIN_COMMANDS };
 const builtinDescriptor = (c) => ({
@@ -159,6 +160,29 @@ const HANDLERS = {
             data: servers,
         };
     },
+    async btw(args, ctx, host) {
+        const question = args.trim();
+        const side = host.sideQuestions;
+        if (!question) {
+            const history = side?.history(ctx.sessionId) ?? [];
+            const latest = history.at(-1);
+            if (!latest)
+                return {
+                    text: `${SIDE_QUESTION_USAGE}\n${SIDE_QUESTION_DESCRIPTION}`,
+                    tone: "notice",
+                    data: { history },
+                };
+            return {
+                text: formatSideQuestion(latest, history.length, history.length),
+                data: { history, entry: latest },
+            };
+        }
+        if (!side)
+            throw new Error("Side questions are unavailable here");
+        const entry = await side.ask(ctx.sessionId, question, ctx.signal ? { signal: ctx.signal } : {});
+        const total = side.history(ctx.sessionId).length;
+        return { text: formatSideQuestion(entry, total, total), data: { entry } };
+    },
     async agents(args, ctx, host) {
         // With arguments, `/agents <verb>` belongs to the subagents plugin's own command (as in the
         // TUI); without them it lists the active-agent catalog.

package/dist/core/runner.d.ts

@@ -157,6 +157,23 @@ export declare class AgentRunner {
         basis: "window" | "unknown";
         compactionAt: number;
     };
+    /**
+     * What a tool-less side call about a session needs (for example a `/btw` side question): the
+     * session's provider and model, its system instructions, its ACTIVE history and the current
+     * limits. Claims no lock and writes nothing, so it is safe while a run is active.
+     */
+    sideContext(sessionId: string): Promise<{
+        provider: ModelProvider;
+        model: string;
+        instructions: string;
+        messages: Message[];
+        maxContextChars: number;
+        maxOutputTokens: number;
+        timeoutMs: number;
+        /** Context window of the model in tokens, when known and trusted. */
+        contextWindow?: number;
+        reasoningEffort?: string;
+    }>;
     /** Change the model used by subsequent turns of a session; recorded in the store. */
     setModel(sessionId: string, model: string): void;
     /** Manually compact a session outside a run. */

package/dist/core/runner.js

@@ -155,6 +155,30 @@ export class AgentRunner {
             };
         return { total: undefined, basis: "unknown", compactionAt: 100 };
     }
+    /**
+     * What a tool-less side call about a session needs (for example a `/btw` side question): the
+     * session's provider and model, its system instructions, its ACTIVE history and the current
+     * limits. Claims no lock and writes nothing, so it is safe while a run is active.
+     */
+    async sideContext(sessionId) {
+        const o = this.options;
+        const session = o.store.get(sessionId);
+        const provider = await (o.providerFor?.(session) ?? o.provider);
+        const window = o.contextWindow?.(session.model);
+        return {
+            provider,
+            model: session.model,
+            ...(window !== undefined && window > 0 && window <= MAX_TRUSTED_WINDOW
+                ? { contextWindow: window }
+                : {}),
+            instructions: await o.context.instructions(sessionId),
+            messages: o.store.messages(sessionId),
+            maxContextChars: o.maxContextChars ?? 800_000,
+            maxOutputTokens: o.maxOutputTokens ?? 4096,
+            timeoutMs: o.timeoutMs ?? 300_000,
+            ...(o.reasoningEffort ? { reasoningEffort: o.reasoningEffort } : {}),
+        };
+    }
     /** Change the model used by subsequent turns of a session; recorded in the store. */
     setModel(sessionId, model) {
         const id = model.trim();

package/dist/index.d.ts

@@ -29,6 +29,7 @@ export { isMissingCommand, type ProcessResult, RIPGREP_INSTALL_HINT, runProcess,
 export { isSqliteExperimentalWarning, openDatabase } from "./runtime/sqlite.ts";
 export { SQLiteStore } from "./runtime/store.ts";
 export { ChildSessions, type ChildSessionsOptions } from "./sessions/children.ts";
+export { formatSideQuestion, SIDE_QUESTION_DESCRIPTION, SIDE_QUESTION_HISTORY_LIMIT, SIDE_QUESTION_INSTRUCTIONS, SIDE_QUESTION_MAX_CHARS, SIDE_QUESTION_USAGE, SIDE_QUESTIONS_NAMESPACE, type SideQuestionEntry, SideQuestions, type SideQuestionsOptions, sideTranscript, } from "./sessions/side-questions.ts";
 export { composeSideBySide, DefaultAlisioMascot, DefaultStartupScreen, infoSection, mascotSection, padEnd, pluginsSection, renderStartup, type StartupDiagnostic, type StartupInput, type StartupResult, sanitizeLine, shortenPath, startupTips, stripAnsi, tipsSection, titleSection, truncate, visibleWidth, welcomeSection, } from "./startup/index.ts";
 export { hash, objectSchema, registerStandard } from "./tools/standard.ts";
 export { getTrust, hashProjectConfig, hasProjectResources, listTrust, resolveTrust, revokeTrust, setTrust, type TrustEntry, type TrustListing, type TrustResolution, trustStorePath, } from "./trust.ts";

package/dist/index.js

@@ -28,6 +28,7 @@ export { isMissingCommand, RIPGREP_INSTALL_HINT, runProcess, } from "./runtime/p
 export { isSqliteExperimentalWarning, openDatabase } from "./runtime/sqlite.js";
 export { SQLiteStore } from "./runtime/store.js";
 export { ChildSessions } from "./sessions/children.js";
+export { formatSideQuestion, SIDE_QUESTION_DESCRIPTION, SIDE_QUESTION_HISTORY_LIMIT, SIDE_QUESTION_INSTRUCTIONS, SIDE_QUESTION_MAX_CHARS, SIDE_QUESTION_USAGE, SIDE_QUESTIONS_NAMESPACE, SideQuestions, sideTranscript, } from "./sessions/side-questions.js";
 export { composeSideBySide, DefaultAlisioMascot, DefaultStartupScreen, infoSection, mascotSection, padEnd, pluginsSection, renderStartup, sanitizeLine, shortenPath, startupTips, stripAnsi, tipsSection, titleSection, truncate, visibleWidth, welcomeSection, } from "./startup/index.js";
 export { hash, objectSchema, registerStandard } from "./tools/standard.js";
 export { getTrust, hashProjectConfig, hasProjectResources, listTrust, resolveTrust, revokeTrust, setTrust, trustStorePath, } from "./trust.js";

package/dist/runtime/store.d.ts

@@ -71,20 +71,26 @@ export declare class SQLiteStore implements SessionStore {
     eventsPage(session: string, options?: PageOptions): EventPage;
     /**
      * Known workspaces for web clients: the workspaces of root sessions plus the ones recorded with
-     * `recordWorkspace` (v4 `workspaces` table), with their UI metadata and root-session count.
+     * `recordWorkspace` (v4 `workspaces` table), with their UI metadata (v5: `archivedAt`) and
+     * root-session count.
      */
     workspaces(): Array<{
         path: string;
         label?: string;
         pinned: boolean;
         lastOpenedAt?: number;
+        archivedAt?: number;
         sessions: number;
     }>;
-    /** Records a workspace and patches its UI metadata (`label: null` clears the label). */
+    /**
+     * Records (upserts) a workspace and patches its UI metadata (`label: null` clears the label;
+     * `archived` stamps or clears `archived_at` and never touches its sessions).
+     */
     recordWorkspace(path: string, patch?: {
         label?: string | null;
         pinned?: boolean;
         lastOpenedAt?: number;
+        archived?: boolean;
     }): void;
     /**
      * Patches web-facing session metadata: title, pin, archive flag and `options` (shallow-merged

package/dist/runtime/store.js

@@ -104,6 +104,14 @@ export class SQLiteStore {
           CREATE INDEX IF NOT EXISTS messages_session ON messages(session, seq);
           INSERT OR IGNORE INTO schema_migrations VALUES(4);`);
             });
+        if (!has(5))
+            this.db.transaction(() => {
+                // v5 (additive): archived workspaces (hidden from the default web list).
+                const columns = this.db.prepare("PRAGMA table_info(workspaces)").all();
+                if (!columns.some((c) => c.name === "archived_at"))
+                    this.db.exec("ALTER TABLE workspaces ADD COLUMN archived_at INTEGER");
+                this.db.exec("INSERT OR IGNORE INTO schema_migrations VALUES(5)");
+            });
     }
     create(workspace, provider, model) {
         const id = crypto.randomUUID();
@@ -461,11 +469,12 @@ export class SQLiteStore {
     }
     /**
      * Known workspaces for web clients: the workspaces of root sessions plus the ones recorded with
-     * `recordWorkspace` (v4 `workspaces` table), with their UI metadata and root-session count.
+     * `recordWorkspace` (v4 `workspaces` table), with their UI metadata (v5: `archivedAt`) and
+     * root-session count.
      */
     workspaces() {
         const rows = this.db
-            .prepare(`SELECT p.path, w.label, COALESCE(w.pinned, 0) AS pinned, w.last_opened_at,
+            .prepare(`SELECT p.path, w.label, COALESCE(w.pinned, 0) AS pinned, w.last_opened_at, w.archived_at,
            (SELECT count(*) FROM sessions s WHERE s.workspace=p.path AND s.parent_id IS NULL) AS sessions
          FROM (SELECT workspace AS path FROM sessions WHERE parent_id IS NULL AND workspace IS NOT NULL
                UNION SELECT path FROM workspaces) p
@@ -477,10 +486,14 @@ export class SQLiteStore {
             ...(r.label != null ? { label: String(r.label) } : {}),
             pinned: !!r.pinned,
             ...(r.last_opened_at != null ? { lastOpenedAt: Number(r.last_opened_at) } : {}),
+            ...(r.archived_at != null ? { archivedAt: Number(r.archived_at) } : {}),
             sessions: Number(r.sessions ?? 0),
         }));
     }
-    /** Records a workspace and patches its UI metadata (`label: null` clears the label). */
+    /**
+     * Records (upserts) a workspace and patches its UI metadata (`label: null` clears the label;
+     * `archived` stamps or clears `archived_at` and never touches its sessions).
+     */
     recordWorkspace(path, patch = {}) {
         this.db.transaction(() => {
             this.db.prepare("INSERT OR IGNORE INTO workspaces(path) VALUES(?)").run(path);
@@ -494,6 +507,10 @@ export class SQLiteStore {
                 this.db
                     .prepare("UPDATE workspaces SET last_opened_at=? WHERE path=?")
                     .run(patch.lastOpenedAt, path);
+            if (patch.archived !== undefined)
+                this.db
+                    .prepare("UPDATE workspaces SET archived_at=? WHERE path=?")
+                    .run(patch.archived ? Date.now() : null, path);
         });
     }
     /**

package/dist/sessions/side-questions.d.ts

@@ -0,0 +1,57 @@
+/**
+ * `/btw` side questions: a question about a session answered by one separate, tool-less model
+ * call that sees the session's active history, without becoming part of the conversation.
+ *
+ * Guarantees: nothing is written to `messages`, `tool_calls`, `runs`, the durable `events` or the
+ * session usage, and the session lock is never claimed, so a side question may run while a run
+ * is active (it has its own abort signal). The only thing persisted is this service's own
+ * history, in `plugin_state` under the reserved namespace `core:btw` (plugin ids cannot contain
+ * `:`, so no plugin can read or overwrite it), keyed by session id and capped to the newest
+ * `SIDE_QUESTION_HISTORY_LIMIT` entries.
+ */
+import type { Message, SideQuestionEntry } from "@alisio/sdk";
+import type { AgentRunner } from "../core/runner.ts";
+export type { SideQuestionEntry };
+/** `plugin_state.plugin` value of the side-question history (never a valid plugin id). */
+export declare const SIDE_QUESTIONS_NAMESPACE = "core:btw";
+export declare const SIDE_QUESTION_HISTORY_LIMIT = 20;
+export declare const SIDE_QUESTION_MAX_CHARS = 4000;
+/** The line every surface prints for `/btw` without a question and without any history. */
+export declare const SIDE_QUESTION_USAGE = "Usage: /btw <question>";
+export declare const SIDE_QUESTION_DESCRIPTION = "Ask a side question about the current session without adding to the conversation.";
+export declare const SIDE_QUESTION_INSTRUCTIONS: string;
+interface StateStore {
+    getState(plugin: string, key: string): unknown;
+    setState(plugin: string, key: string, value: unknown): void;
+}
+export interface SideQuestionsOptions {
+    runner: Pick<AgentRunner, "sideContext">;
+    /** Where the history lives (the SQLite store's `plugin_state`). */
+    state: StateStore;
+    now?: () => number;
+    id?: () => string;
+}
+/**
+ * The transcript lines for the side call, newest kept first: when the whole history does not fit
+ * `budget` characters, the oldest messages are dropped (and counted in a leading marker). The
+ * newest message alone is clipped from its start if it is still too large.
+ */
+export declare function sideTranscript(messages: Message[], budget: number): string;
+export declare class SideQuestions {
+    private readonly options;
+    private readonly now;
+    private readonly newId;
+    constructor(options: SideQuestionsOptions);
+    /** The session's side questions, oldest first (newest last). */
+    history(sessionId: string): SideQuestionEntry[];
+    /**
+     * Answers `question` about the session with one tool-less call of the session's model and
+     * records it in the history. Throws on an empty or oversized question, on cancellation (the
+     * signal's reason) and on provider failures (nothing is recorded then).
+     */
+    ask(sessionId: string, question: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<SideQuestionEntry>;
+}
+/** Plain Markdown for one entry (`position` is 1-based): readline, API callers and `/btw`. */
+export declare function formatSideQuestion(entry: SideQuestionEntry, position: number, total: number): string;

package/dist/sessions/side-questions.js

@@ -0,0 +1,161 @@
+import { serializeForSummary } from "../core/compaction.js";
+/** `plugin_state.plugin` value of the side-question history (never a valid plugin id). */
+export const SIDE_QUESTIONS_NAMESPACE = "core:btw";
+export const SIDE_QUESTION_HISTORY_LIMIT = 20;
+export const SIDE_QUESTION_MAX_CHARS = 4_000;
+/** The line every surface prints for `/btw` without a question and without any history. */
+export const SIDE_QUESTION_USAGE = "Usage: /btw <question>";
+export const SIDE_QUESTION_DESCRIPTION = "Ask a side question about the current session without adding to the conversation.";
+/** Per-message clip of the transcript the side call sees (as in compaction summaries). */
+const MAX_ITEM_CHARS = 4_000;
+export const SIDE_QUESTION_INSTRUCTIONS = [
+    "The user is asking a quick side question (/btw) about the session transcript below.",
+    "It is NOT part of the conversation: answer it directly and concisely from the transcript and",
+    "your general knowledge. You have no tools in this reply, so do not take or promise any",
+    "action, do not continue the task and do not call tools; if the transcript does not contain",
+    "the answer, say so briefly.",
+].join(" ");
+/**
+ * The transcript lines for the side call, newest kept first: when the whole history does not fit
+ * `budget` characters, the oldest messages are dropped (and counted in a leading marker). The
+ * newest message alone is clipped from its start if it is still too large.
+ */
+export function sideTranscript(messages, budget) {
+    const lines = [];
+    let used = 0;
+    let omitted = 0;
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const message = messages[i];
+        const text = serializeForSummary([message], MAX_ITEM_CHARS);
+        if (used + text.length + 1 > budget) {
+            if (lines.length)
+                omitted = i + 1;
+            else {
+                // Even the newest message alone is too large: keep its end (the most recent part).
+                lines.push(text.slice(Math.max(0, text.length - budget)));
+                omitted = i;
+            }
+            break;
+        }
+        lines.unshift(text);
+        used += text.length + 1;
+    }
+    if (omitted > 0)
+        lines.unshift(`[${omitted} earlier messages omitted to fit the context budget]`);
+    return lines.join("\n");
+}
+const isEntry = (value) => !!value &&
+    typeof value === "object" &&
+    typeof value.id === "string" &&
+    typeof value.question === "string" &&
+    typeof value.answer === "string";
+export class SideQuestions {
+    options;
+    now;
+    newId;
+    constructor(options) {
+        this.options = options;
+        this.now = options.now ?? Date.now;
+        this.newId = options.id ?? (() => crypto.randomUUID());
+    }
+    /** The session's side questions, oldest first (newest last). */
+    history(sessionId) {
+        let stored;
+        try {
+            stored = this.options.state.getState(SIDE_QUESTIONS_NAMESPACE, sessionId);
+        }
+        catch {
+            return [];
+        }
+        return Array.isArray(stored) ? stored.filter(isEntry) : [];
+    }
+    /**
+     * Answers `question` about the session with one tool-less call of the session's model and
+     * records it in the history. Throws on an empty or oversized question, on cancellation (the
+     * signal's reason) and on provider failures (nothing is recorded then).
+     */
+    async ask(sessionId, question, options = {}) {
+        const text = question.trim();
+        if (!text)
+            throw new Error(SIDE_QUESTION_USAGE);
+        if (text.length > SIDE_QUESTION_MAX_CHARS)
+            throw new Error(`Side questions are limited to ${SIDE_QUESTION_MAX_CHARS} characters`);
+        const side = await this.options.runner.sideContext(sessionId);
+        const signal = AbortSignal.any([
+            AbortSignal.timeout(side.timeoutMs),
+            ...(options.signal ? [options.signal] : []),
+        ]);
+        signal.throwIfAborted();
+        const instructions = `${side.instructions}\n\n${SIDE_QUESTION_INSTRUCTIONS}`;
+        // The request must fit both the char budget and (when known) the model window, leaving room
+        // for the answer; ~3 chars per token keeps a conservative margin over the usual ~4.
+        const windowChars = side.contextWindow
+            ? Math.max(0, side.contextWindow - side.maxOutputTokens) * 3
+            : Number.POSITIVE_INFINITY;
+        const budget = Math.max(2_000, Math.min(side.maxContextChars, windowChars) - instructions.length - text.length - 200);
+        const transcript = sideTranscript(side.messages, budget);
+        const prompt = transcript
+            ? `<transcript>\n${transcript}\n</transcript>\n\nSide question: ${text}`
+            : `(The session has no messages yet.)\n\nSide question: ${text}`;
+        let answer = "";
+        let completed = false;
+        let truncated = false;
+        let usage = { input: 0, output: 0 };
+        try {
+            for await (const event of side.provider.stream({
+                instructions,
+                messages: [{ role: "user", text: prompt }],
+                tools: [],
+                maxOutputTokens: side.maxOutputTokens,
+                signal,
+                model: side.model,
+                sessionId,
+                ...(side.reasoningEffort ? { reasoningEffort: side.reasoningEffort } : {}),
+            })) {
+                signal.throwIfAborted();
+                if (event.type === "text_delta")
+                    answer += event.delta;
+                else if (event.type === "completed") {
+                    completed = true;
+                    truncated = event.message.truncated === true;
+                    answer = event.message.text || answer;
+                    if (event.usage)
+                        usage = { input: event.usage.input, output: event.usage.output };
+                }
+            }
+        }
+        catch (error) {
+            if (signal.aborted)
+                throw signal.reason ?? error;
+            throw new Error(`Side question failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        signal.throwIfAborted();
+        if (!completed)
+            throw new Error("Side question failed: the provider did not complete");
+        answer = answer.trim();
+        if (!answer)
+            throw new Error("Side question failed: the model returned an empty answer");
+        const entry = {
+            id: this.newId(),
+            question: text,
+            answer,
+            model: side.model,
+            usage,
+            createdAt: this.now(),
+            ...(truncated ? { truncated: true } : {}),
+        };
+        const next = [...this.history(sessionId), entry].slice(-SIDE_QUESTION_HISTORY_LIMIT);
+        this.options.state.setState(SIDE_QUESTIONS_NAMESPACE, sessionId, next);
+        return entry;
+    }
+}
+/** Plain Markdown for one entry (`position` is 1-based): readline, API callers and `/btw`. */
+export function formatSideQuestion(entry, position, total) {
+    return [
+        `**btw ${position}/${total}** · ${entry.question.replace(/\s+/g, " ")}`,
+        "",
+        entry.answer,
+        "",
+        `_${entry.model} · ${entry.usage.input} in · ${entry.usage.output} out tokens${entry.truncated ? " · truncated" : ""}_`,
+    ].join("\n");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alisio/core",
-  "version": "0.1.0-alpha.18",
+  "version": "0.1.0-alpha.19",
   "description": "Embeddable provider-agnostic Alisio agent core: tool loop, context compaction, local tools, MCP, plugin host and SQLite session store. Runs on Node >=22.16 and Bun.",
   "author": "Gustavo Gutiérrez",
   "license": "MIT",
@@ -41,7 +41,7 @@
     "node": ">=22.16"
   },
   "dependencies": {
-    "@alisio/sdk": "0.1.0-alpha.15",
+    "@alisio/sdk": "0.1.0-alpha.16",
     "@mixmark-io/domino": "2.2.0",
     "@modelcontextprotocol/client": "2.1.0",
     "ajv": "8.20.0",