voratiq 0.1.0-beta.2 → 0.1.0-beta.21

package/package.json

@@ -1,15 +1,21 @@
 {
   "name": "voratiq",
-  "version": "0.1.0-beta.2",
-  "description": "Run multiple AI coding agents in parallel, compare their results, and apply the best solution.",
+  "version": "0.1.0-beta.21",
+  "description": "Agent ensembles to design, generate, and select the best code for every task.",
   "keywords": [
-    "ai",
+    "agent-ensembles",
+    "agent-orchestration",
+    "ai-coding",
+    "claude-code",
     "cli",
-    "multi-agent",
-    "spec-driven",
     "code-generation",
+    "codex",
     "evals",
-    "sandboxing"
+    "gemini",
+    "multi-agent",
+    "sandboxing",
+    "spec-driven-development",
+    "verification"
   ],
   "homepage": "https://github.com/voratiq/voratiq#readme",
   "bugs": {
@@ -43,37 +49,37 @@
     "prepare": "npm run build",
     "build": "tsc && node scripts/build-run-agent-shim.mjs",
     "lint": "eslint . --max-warnings=0",
-    "format": "prettier --write .",
-    "format:check": "prettier --check .",
+    "typecheck": "tsc -p tsconfig.typecheck.json",
+    "format": "prettier --cache --write .",
+    "format:check": "prettier --cache --check .",
     "test": "./scripts/run-tests.sh",
     "test:sandbox": "./scripts/run-tests.sh --sandbox-only",
-    "check": "npm run lint && npm run format:check && npm run build && npm test"
+    "check": "npm run lint && npm run typecheck && npm run format:check && npm run build && npm test"
   },
   "dependencies": {
-    "@voratiq/sandbox-runtime": "^0.7.0-voratiq1",
+    "@voratiq/sandbox-runtime": "0.0.29-voratiq2",
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
     "js-yaml": "^4.1.0",
-    "zod": "^4.0.0"
+    "zod": "^4.3.6"
   },
   "devDependencies": {
-    "@eslint/js": "^9.29.0",
-    "@jest/globals": "^30.2.0",
+    "@eslint/js": "^9.39.4",
+    "@jest/globals": "^30.3.0",
     "@types/jest": "^30.0.0",
     "@types/js-yaml": "^4.0.9",
-    "@types/node": "^20.19.17",
-    "@typescript-eslint/eslint-plugin": "^8.12.1",
-    "@typescript-eslint/parser": "^8.12.1",
-    "depcheck": "^1.4.7",
-    "eslint": "^9.29.0",
-    "eslint-plugin-jest": "^29.0.1",
+    "@types/node": "^20.19.39",
+    "@typescript-eslint/eslint-plugin": "^8.58.0",
+    "@typescript-eslint/parser": "^8.58.0",
+    "eslint": "^9.39.4",
+    "eslint-plugin-jest": "^29.15.1",
     "eslint-plugin-simple-import-sort": "^12.1.1",
     "globals": "^16.4.0",
-    "jest": "^30.0.0",
-    "jest-resolve": "^30.2.0",
-    "memfs": "^4.48.1",
-    "prettier": "^3.6.2",
-    "ts-jest": "^29.4.2",
+    "jest": "^30.3.0",
+    "jest-resolve": "^30.3.0",
+    "memfs": "^4.57.1",
+    "prettier": "^3.8.1",
+    "ts-jest": "^29.4.9",
     "typescript": "^5.9.2"
   },
   "engines": {

package/dist/cli/review.d.ts

@@ -1,12 +0,0 @@
-import { Command } from "commander";
-import { type ReviewCommandResult as ReviewExecutionResult } from "../commands/review/command.js";
-export interface ReviewCommandOptions {
-    runId: string;
-}
-export interface ReviewCommandResult extends ReviewExecutionResult {
-    body: string;
-    stderr?: string;
-    exitCode?: number;
-}
-export declare function runReviewCommand(options: ReviewCommandOptions): Promise<ReviewCommandResult>;
-export declare function createReviewCommand(): Command;

package/dist/cli/review.js

@@ -1,33 +0,0 @@
-import { Command } from "commander";
-import { executeReviewCommand, } from "../commands/review/command.js";
-import { resolveCliContext } from "../preflight/index.js";
-import { renderReviewTranscript } from "../render/transcripts/review.js";
-import { writeCommandOutput } from "./output.js";
-export async function runReviewCommand(options) {
-    const { runId } = options;
-    const { root, workspacePaths } = await resolveCliContext();
-    const execution = await executeReviewCommand({
-        root,
-        runsFilePath: workspacePaths.runsFile,
-        runId,
-    });
-    const body = renderReviewTranscript(execution.runRecord);
-    return {
-        ...execution,
-        body,
-    };
-}
-export function createReviewCommand() {
-    return new Command("review")
-        .description("Summarize artifacts from a completed run")
-        .requiredOption("--run <run-id>", "Identifier of the recorded run")
-        .allowExcessArguments(false)
-        .action(async (options) => {
-        const result = await runReviewCommand({ runId: options.run });
-        writeCommandOutput({
-            body: result.body,
-            stderr: result.stderr,
-            exitCode: result.exitCode,
-        });
-    });
-}

package/dist/commands/errors.d.ts

@@ -1,4 +0,0 @@
-import { CliError } from "../cli/errors.js";
-export declare class RunNotFoundCliError extends CliError {
-    constructor(runId: string);
-}

package/dist/commands/errors.js

@@ -1,7 +0,0 @@
-import { CliError } from "../cli/errors.js";
-export class RunNotFoundCliError extends CliError {
-    constructor(runId) {
-        super(`Run ${runId} not found.`, ["To review past runs: voratiq list"]);
-        this.name = "RunNotFoundCliError";
-    }
-}

package/dist/commands/init/evals.d.ts

@@ -1,4 +0,0 @@
-import { type EnvironmentConfig } from "../../configs/environment/types.js";
-import type { EvalInitSummary, InitConfigureOptions } from "./types.js";
-export declare const EVALS_CONFIG_DISPLAY_PATH: string;
-export declare function configureEvals(root: string, options: InitConfigureOptions, environment: EnvironmentConfig): Promise<EvalInitSummary>;

package/dist/commands/init/evals.js

@@ -1,219 +0,0 @@
-import { CANONICAL_EVAL_SLUGS, detectEvalSuggestions, } from "../../configs/evals/detect.js";
-import { readEvalsConfig } from "../../configs/evals/loader.js";
-import { normalizeEvalCommand } from "../../configs/evals/types.js";
-import { renderEvalCommandPreface } from "../../render/transcripts/init.js";
-import { isDefaultYamlTemplate, loadYamlConfig, persistYamlConfig, } from "../../utils/yaml.js";
-import { formatWorkspacePath, resolveWorkspacePath, VORATIQ_EVALS_FILE, } from "../../workspace/structure.js";
-import { buildDefaultEvalsTemplate } from "../../workspace/templates.js";
-export const EVALS_CONFIG_DISPLAY_PATH = formatWorkspacePath(VORATIQ_EVALS_FILE);
-const PLACEHOLDER_TEMPLATE = 'echo "configure %slug% eval"';
-export async function configureEvals(root, options, environment) {
-    const filePath = resolveWorkspacePath(root, VORATIQ_EVALS_FILE);
-    const defaultTemplate = buildDefaultEvalsTemplate();
-    const loadResult = await loadYamlConfig(filePath, readEvalsConfig);
-    const defaultStatus = isDefaultYamlTemplate(loadResult.snapshot, defaultTemplate);
-    const configCreated = !loadResult.snapshot.exists;
-    const suggestions = await detectEvalSuggestions(root, environment);
-    const shouldSeed = configCreated || defaultStatus || loadResult.config.length === 0;
-    const refreshPlaceholders = !shouldSeed && isPlaceholderConfig(loadResult.config);
-    let nextEntries = loadResult.config;
-    let configUpdated = false;
-    if (shouldSeed) {
-        const seededEntries = await buildSeedEntries(suggestions, options);
-        const hasConfiguredEntries = seededEntries.some((entry) => Boolean(normalizeEvalCommand(entry.command)));
-        const hasExistingContent = loadResult.snapshot.exists && loadResult.snapshot.normalized.length > 0;
-        if (!hasConfiguredEntries && hasExistingContent) {
-            nextEntries = loadResult.config;
-        }
-        else {
-            const serialized = hasConfiguredEntries
-                ? serializeEvalConfig(seededEntries)
-                : defaultTemplate;
-            configUpdated = await persistYamlConfig({
-                filePath,
-                serialized,
-                original: loadResult.snapshot,
-                defaultTemplate,
-                isDefaultTemplate: defaultStatus,
-            });
-            nextEntries = seededEntries;
-        }
-    }
-    else if (refreshPlaceholders) {
-        const refreshed = await refreshExistingEntries(loadResult.config, suggestions, options);
-        if (refreshed.changed) {
-            const serialized = serializeEvalConfig(refreshed.entries);
-            configUpdated = await persistYamlConfig({
-                filePath,
-                serialized,
-                original: loadResult.snapshot,
-                defaultTemplate,
-                isDefaultTemplate: defaultStatus,
-            });
-            nextEntries = refreshed.entries;
-        }
-    }
-    return buildEvalSummary(nextEntries, configCreated, configUpdated);
-}
-function buildEvalSummary(entries, configCreated, configUpdated) {
-    const enabled = entries
-        .filter((entry) => {
-        const normalized = normalizeEvalCommand(entry.command);
-        if (!normalized) {
-            return false;
-        }
-        return normalized !== buildPlaceholderCommand(entry.slug);
-    })
-        .map((entry) => entry.slug);
-    return {
-        configPath: EVALS_CONFIG_DISPLAY_PATH,
-        configuredEvals: enabled,
-        configCreated,
-        configUpdated,
-    };
-}
-async function buildSeedEntries(suggestions, options) {
-    const combined = combineSuggestionCommands(suggestions);
-    const firstPrompt = { value: true };
-    const entries = [];
-    for (const slug of CANONICAL_EVAL_SLUGS) {
-        const proposed = combined.get(slug);
-        const command = await resolveCommandChoice({
-            slug,
-            proposed,
-            options,
-            firstPrompt,
-        });
-        entries.push({ slug, command });
-    }
-    return entries;
-}
-async function refreshExistingEntries(entries, suggestions, options) {
-    const existingBySlug = new Map();
-    const extras = [];
-    for (const entry of entries) {
-        if (CANONICAL_EVAL_SLUGS.includes(entry.slug)) {
-            existingBySlug.set(entry.slug, { ...entry });
-        }
-        else {
-            extras.push({ ...entry });
-        }
-    }
-    const combined = combineSuggestionCommands(suggestions);
-    const firstPrompt = { value: true };
-    let changed = false;
-    const updatedCanonical = [];
-    for (const slug of CANONICAL_EVAL_SLUGS) {
-        const prior = existingBySlug.get(slug);
-        const proposed = combined.get(slug);
-        const resolved = await resolveCommandChoice({
-            slug,
-            proposed,
-            options,
-            firstPrompt,
-            existing: prior?.command,
-        });
-        if (!prior || prior.command !== resolved) {
-            changed = true;
-        }
-        updatedCanonical.push({ slug, command: resolved });
-    }
-    const resultEntries = [...updatedCanonical, ...extras];
-    return { entries: resultEntries, changed };
-}
-function combineSuggestionCommands(suggestions) {
-    const combined = new Map();
-    for (const suggestion of suggestions) {
-        for (const [slug, command] of suggestion.commands) {
-            const list = combined.get(slug);
-            if (!list) {
-                combined.set(slug, [command]);
-                continue;
-            }
-            if (!list.includes(command)) {
-                list.push(command);
-            }
-        }
-    }
-    const resolved = new Map();
-    for (const slug of CANONICAL_EVAL_SLUGS) {
-        const entries = combined.get(slug);
-        if (!entries || entries.length === 0) {
-            resolved.set(slug, undefined);
-            continue;
-        }
-        resolved.set(slug, entries.join(" && "));
-    }
-    return resolved;
-}
-async function resolveCommandChoice(params) {
-    const { slug, proposed, options, firstPrompt, existing } = params;
-    const normalizedExisting = normalizeEvalCommand(existing);
-    const normalizedProposed = normalizeEvalCommand(proposed);
-    if (!normalizedProposed) {
-        return normalizedExisting;
-    }
-    if (!options.interactive || !options.confirm) {
-        return normalizedProposed;
-    }
-    const prefaceLines = renderEvalCommandPreface({
-        commandName: slug,
-        commandText: normalizedProposed,
-        firstPrompt: firstPrompt.value,
-    });
-    const defaultValue = normalizedExisting !== undefined
-        ? normalizedExisting === normalizedProposed
-        : true;
-    const accepted = await options.confirm({
-        message: "Enable?",
-        defaultValue,
-        prefaceLines,
-    });
-    firstPrompt.value = false;
-    return accepted ? normalizedProposed : normalizedExisting;
-}
-function isPlaceholderConfig(entries) {
-    if (entries.length === 0) {
-        return true;
-    }
-    const canonical = entries.filter((entry) => CANONICAL_EVAL_SLUGS.includes(entry.slug));
-    if (canonical.length !== CANONICAL_EVAL_SLUGS.length) {
-        return false;
-    }
-    const nonCanonical = entries.some((entry) => !CANONICAL_EVAL_SLUGS.includes(entry.slug));
-    if (nonCanonical) {
-        return false;
-    }
-    return canonical.every((entry) => {
-        const normalized = normalizeEvalCommand(entry.command);
-        return (normalized === undefined ||
-            normalized === buildPlaceholderCommand(entry.slug));
-    });
-}
-function serializeEvalConfig(entries) {
-    const lines = [];
-    for (const entry of entries) {
-        const command = normalizeEvalCommand(entry.command);
-        if (!command) {
-            lines.push(`${entry.slug}:`);
-            continue;
-        }
-        if (command.includes("#") ||
-            command.includes(": ") ||
-            command.includes('"')) {
-            const escaped = command.replace(/"/g, '\\"');
-            lines.push(`${entry.slug}: "${escaped}"`);
-        }
-        else if (command.includes(" ") || command.includes(":")) {
-            lines.push(`${entry.slug}: "${command}"`);
-        }
-        else {
-            lines.push(`${entry.slug}: ${command}`);
-        }
-    }
-    lines.push("");
-    return lines.join("\n");
-}
-function buildPlaceholderCommand(slug) {
-    return PLACEHOLDER_TEMPLATE.replace("%slug%", slug);
-}

package/dist/commands/review/command.d.ts

@@ -1,10 +0,0 @@
-import type { RunRecordEnhanced } from "../../records/enhanced.js";
-export interface ReviewCommandInput {
-    root: string;
-    runsFilePath: string;
-    runId: string;
-}
-export interface ReviewCommandResult {
-    runRecord: RunRecordEnhanced;
-}
-export declare function executeReviewCommand(input: ReviewCommandInput): Promise<ReviewCommandResult>;

package/dist/commands/review/command.js

@@ -1,26 +0,0 @@
-import { buildRunRecordView } from "../../records/enhanced.js";
-import { RunRecordNotFoundError } from "../../records/errors.js";
-import { fetchRunsSafely } from "../../records/persistence.js";
-import { RunNotFoundCliError } from "../errors.js";
-export async function executeReviewCommand(input) {
-    const { root, runsFilePath, runId } = input;
-    const { records } = await fetchRunsSafely({
-        root,
-        runsFilePath,
-        runId,
-        filters: { includeDeleted: true },
-    }).catch((error) => {
-        if (error instanceof RunRecordNotFoundError) {
-            throw new RunNotFoundCliError(runId);
-        }
-        throw error;
-    });
-    const runRecord = records[0];
-    if (!runRecord) {
-        throw new RunNotFoundCliError(runId);
-    }
-    const enhanced = await buildRunRecordView(runRecord, {
-        workspaceRoot: root,
-    });
-    return { runRecord: enhanced };
-}

package/dist/commands/run/agent-execution.d.ts

@@ -1,19 +0,0 @@
-import type { AgentDefinition } from "../../configs/agents/types.js";
-import type { EnvironmentConfig } from "../../configs/environment/types.js";
-import type { EvalDefinition } from "../../configs/evals/types.js";
-import type { AgentRecordMutators } from "../../records/mutators.js";
-import type { AgentExecutionPhaseResult } from "./phases.js";
-export interface AgentExecutionInput {
-    readonly agents: readonly AgentDefinition[];
-    readonly baseRevisionSha: string;
-    readonly runId: string;
-    readonly root: string;
-    readonly evalPlan: readonly EvalDefinition[];
-    readonly effectiveMaxParallel: number;
-    readonly mutators: AgentRecordMutators;
-    readonly environment: EnvironmentConfig;
-}
-/**
- * Execute all agents and aggregate results.
- */
-export declare function executeAgents(input: AgentExecutionInput): Promise<AgentExecutionPhaseResult>;

package/dist/commands/run/agent-execution.js

@@ -1,63 +0,0 @@
-import { toError } from "../../utils/errors.js";
-import { prepareAgents, runAgentsWithLimit } from "./agents.js";
-import { hasEvalFailures } from "./reports.js";
-/**
- * Execute all agents and aggregate results.
- */
-export async function executeAgents(input) {
-    const { agents, baseRevisionSha, runId, root, evalPlan, effectiveMaxParallel, mutators, environment, } = input;
-    let executionError;
-    let phaseResult;
-    try {
-        for (const agent of agents) {
-            await mutators.recordAgentQueued(agent);
-        }
-        const { ready: preparedAgents, failures: preparationFailures } = await prepareAgents({
-            agents,
-            baseRevisionSha,
-            runId,
-            root,
-            evalPlan,
-            environment,
-        });
-        for (const failure of preparationFailures) {
-            await mutators.recordAgentSnapshot(failure.record);
-        }
-        for (const execution of preparedAgents) {
-            execution.progress = {
-                onRunning: mutators.recordAgentSnapshot,
-                onCompleted: async (result) => {
-                    await mutators.recordAgentSnapshot(result.record);
-                },
-            };
-        }
-        const executionResults = preparedAgents.length > 0 && effectiveMaxParallel > 0
-            ? await runAgentsWithLimit(preparedAgents, effectiveMaxParallel)
-            : [];
-        const agentExecutions = [...preparationFailures, ...executionResults];
-        const sortedExecutions = sortExecutions(agentExecutions);
-        const agentRecords = sortedExecutions.map((execution) => execution.record);
-        const agentReports = sortedExecutions.map((execution) => execution.report);
-        const hadAgentFailure = agentReports.some((report) => report.status === "failed");
-        const hadEvalFailure = hasEvalFailures(agentReports);
-        phaseResult = {
-            agentRecords,
-            agentReports,
-            hadAgentFailure,
-            hadEvalFailure,
-        };
-    }
-    catch (error) {
-        executionError = error;
-    }
-    if (executionError) {
-        throw toError(executionError);
-    }
-    if (!phaseResult) {
-        throw new Error(`Agent execution did not produce a result for run ${runId}`);
-    }
-    return phaseResult;
-}
-function sortExecutions(executions) {
-    return [...executions].sort((a, b) => a.record.agentId.localeCompare(b.record.agentId));
-}

package/dist/commands/run/agents/auth-stage.d.ts

@@ -1,23 +0,0 @@
-import type { AuthProvider, AuthRuntimeContext } from "../../../auth/providers/types.js";
-import type { AgentDefinition } from "../../../configs/agents/types.js";
-export interface StagedAuthContext {
-    provider: AuthProvider;
-    sandboxPath: string;
-    runtime: AuthRuntimeContext;
-    agentId: string;
-    runId: string;
-}
-export interface StageAuthOptions {
-    agent: AgentDefinition;
-    agentRoot: string;
-    runId: string;
-    root: string;
-    runtime?: AuthRuntimeContext;
-}
-export interface StageAuthResult {
-    env: Record<string, string>;
-    context: StagedAuthContext;
-}
-export declare function verifyAgentProviders(agents: readonly AgentDefinition[]): Promise<void>;
-export declare function stageAgentAuth(options: StageAuthOptions): Promise<StageAuthResult>;
-export declare function teardownAuthContext(context: StagedAuthContext | undefined): Promise<void>;

package/dist/commands/run/agents/auth-stage.js

@@ -1,108 +0,0 @@
-import { rm } from "node:fs/promises";
-import { resolveAuthProvider } from "../../../auth/providers/index.js";
-import { buildAuthRuntimeContext } from "../../../auth/runtime.js";
-import { toErrorMessage } from "../../../utils/errors.js";
-import { isFileSystemError } from "../../../utils/fs.js";
-import { AuthProviderStageError, AuthProviderVerificationError, MissingAgentProviderError, RunCommandError, UnknownAuthProviderError, } from "../errors.js";
-import { getRunCommand } from "./sandbox-launcher.js";
-export async function verifyAgentProviders(agents) {
-    if (agents.length === 0) {
-        return;
-    }
-    await getRunCommand();
-    const runtime = buildAuthRuntimeContext();
-    for (const agent of agents) {
-        const provider = resolveAgentProvider(agent);
-        try {
-            await provider.verify({
-                agentId: agent.id,
-                runtime,
-            });
-        }
-        catch (error) {
-            throw new AuthProviderVerificationError(extractAuthProviderMessage(error));
-        }
-    }
-}
-export async function stageAgentAuth(options) {
-    const { agent, agentRoot, runId } = options;
-    const provider = resolveAgentProvider(agent);
-    const runtime = options.runtime ?? buildAuthRuntimeContext();
-    try {
-        const stageResult = await provider.stage({
-            agentId: agent.id,
-            agentRoot,
-            runtime,
-            runId,
-            root: options.root,
-        });
-        return {
-            env: stageResult.env,
-            context: {
-                provider,
-                sandboxPath: stageResult.sandboxPath,
-                runtime,
-                agentId: agent.id,
-                runId,
-            },
-        };
-    }
-    catch (error) {
-        throw new AuthProviderStageError(extractAuthProviderMessage(error));
-    }
-}
-export async function teardownAuthContext(context) {
-    if (!context) {
-        return;
-    }
-    if (tornDownContexts.has(context)) {
-        return;
-    }
-    tornDownContexts.add(context);
-    try {
-        if (context.provider.teardown) {
-            try {
-                await context.provider.teardown({
-                    sandboxPath: context.sandboxPath,
-                });
-            }
-            catch (error) {
-                if (!isIgnorableTeardownError(error)) {
-                    throw error;
-                }
-            }
-        }
-        await rm(context.sandboxPath, { recursive: true, force: true });
-    }
-    catch (error) {
-        tornDownContexts.delete(context);
-        throw error;
-    }
-}
-const tornDownContexts = new WeakSet();
-function isIgnorableTeardownError(error) {
-    if (!isFileSystemError(error)) {
-        return false;
-    }
-    return error.code === "ENOENT";
-}
-function resolveAgentProvider(agent) {
-    const providerId = agent.provider;
-    if (!providerId) {
-        throw new MissingAgentProviderError(agent.id);
-    }
-    const provider = resolveAuthProvider(providerId);
-    if (!provider) {
-        throw new UnknownAuthProviderError(providerId);
-    }
-    return provider;
-}
-function extractAuthProviderMessage(error) {
-    if (error instanceof RunCommandError) {
-        return error.messageForDisplay();
-    }
-    if (error instanceof Error && error.message) {
-        return error.message;
-    }
-    return toErrorMessage(error);
-}

package/dist/commands/run/agents/chat-preserver.d.ts

@@ -1,9 +0,0 @@
-import type { AgentDefinition } from "../../../configs/agents/types.js";
-import { AgentRunContext } from "./run-context.js";
-export interface CaptureChatOptions {
-    agent: AgentDefinition;
-    agentContext: AgentRunContext;
-    agentRoot: string;
-    reason?: string;
-}
-export declare function captureAgentChatTranscripts(options: CaptureChatOptions): Promise<void>;

package/dist/commands/run/agents/chat-preserver.js

@@ -1,35 +0,0 @@
-import { toErrorMessage } from "../../../utils/errors.js";
-import { preserveProviderChatTranscripts } from "../../../workspace/chat/artifacts.js";
-export async function captureAgentChatTranscripts(options) {
-    const providerId = options.agent.provider;
-    if (!providerId) {
-        return;
-    }
-    const result = await preserveProviderChatTranscripts({
-        providerId,
-        agentRoot: options.agentRoot,
-    });
-    const format = result.format;
-    if ((result.status === "captured" || result.status === "already-exists") &&
-        format) {
-        options.agentContext.markChatArtifact(format);
-        if (result.status === "captured" &&
-            format === "json" &&
-            (result.sourceCount ?? 0) > 1) {
-            // Intentionally silent: avoid noisy warnings during routine runs.
-        }
-        return;
-    }
-    if (result.status === "not-found") {
-        return;
-    }
-    if (result.status === "error") {
-        throw new Error(formatChatWarning(options, `Failed to preserve ${providerId} transcripts: ${toErrorMessage(result.error)}`));
-    }
-}
-function formatChatWarning(options, message) {
-    const prefix = options.reason
-        ? `[voratiq] (${options.agent.id}, ${options.reason})`
-        : `[voratiq] (${options.agent.id})`;
-    return `${prefix} ${message}`;
-}