byterover-cli 3.2.0 → 3.4.0

package/dist/agent/infra/swarm/swarm-merger.js

@@ -0,0 +1,66 @@
+/**
+ * Fuse results from multiple providers using Weighted Reciprocal Rank Fusion.
+ *
+ * Algorithm:
+ *   RRF_score(r) = Σᵢ wᵢ / (K + rankᵢ(r))
+ *   where wᵢ is the provider weight and rankᵢ(r) is the 0-based rank.
+ *
+ * Deduplication: results with identical content are merged (highest provider weight kept).
+ *
+ * @param resultSets - Map of provider ID → ranked results
+ * @param providerWeights - Map of provider ID → weight (0-1)
+ * @param options - Merger options
+ * @returns Fused, ranked, deduplicated results
+ */
+export function mergeResults(resultSets, providerWeights, options) {
+    const K = options?.K ?? 60;
+    const maxResults = options?.maxResults ?? 10;
+    const minRRFScore = options?.minRRFScore;
+    const rrfGapRatio = options?.rrfGapRatio;
+    const deduped = new Map();
+    for (const [providerId, results] of resultSets) {
+        const weight = providerWeights.get(providerId) ?? 0.5;
+        const seenContent = new Set();
+        for (const [rank, result] of results.entries()) {
+            if (seenContent.has(result.content)) {
+                continue;
+            }
+            seenContent.add(result.content);
+            const existing = deduped.get(result.content) ?? [];
+            existing.push({ rank, result, weight });
+            deduped.set(result.content, existing);
+        }
+    }
+    const scored = [];
+    for (const [, occurrences] of deduped) {
+        let rrfScore = 0;
+        let bestContribution = -1;
+        let representative = occurrences[0]?.result;
+        for (const occurrence of occurrences) {
+            const contribution = occurrence.weight / (K + occurrence.rank);
+            rrfScore += contribution;
+            if (contribution > bestContribution ||
+                (contribution === bestContribution && occurrence.result.score > (representative?.score ?? -1))) {
+                bestContribution = contribution;
+                representative = occurrence.result;
+            }
+        }
+        if (representative) {
+            scored.push({ result: { ...representative, score: rrfScore }, rrfScore });
+        }
+    }
+    // Sort descending by RRF score
+    scored.sort((a, b) => b.rrfScore - a.rrfScore);
+    // T4: Absolute RRF score floor
+    let filtered = scored;
+    if (minRRFScore !== undefined) {
+        filtered = filtered.filter((s) => s.rrfScore >= minRRFScore);
+    }
+    // T5: Relative RRF gap ratio (topRRF = best remaining score after T4)
+    if (rrfGapRatio !== undefined && filtered.length > 0) {
+        const topRRF = filtered[0].rrfScore;
+        const floor = topRRF * rrfGapRatio;
+        filtered = filtered.filter((s) => s.rrfScore >= floor);
+    }
+    return filtered.slice(0, maxResults).map((s) => s.result);
+}

package/dist/agent/infra/swarm/swarm-router.d.ts

@@ -0,0 +1,12 @@
+import type { QueryType } from '../../core/domain/swarm/types.js';
+/**
+ * Classify a natural language query into a query type.
+ * Uses lightweight regex rules — no LLM call needed.
+ */
+export declare function classifyQuery(query: string): QueryType;
+/**
+ * Select which providers to activate for a given query type.
+ * Only returns providers that are in the available list.
+ * Matches by prefix so `local-markdown:notes` matches the `local-markdown` selector.
+ */
+export declare function selectProviders(queryType: QueryType, availableProviderIds: string[]): string[];

package/dist/agent/infra/swarm/swarm-router.js

@@ -0,0 +1,40 @@
+const TEMPORAL_SIGNALS = /\b(after|before|last week|recently|since|today|this month|when did|yesterday)\b/i;
+const PERSONAL_SIGNALS = /\b(how do I usually|I like|I prefer|I tend to|my opinion|my style)\b/i;
+const RELATIONAL_SIGNALS = /\b(connected|depends? on|links to|mentioned in|related to|see also)\b/i;
+/**
+ * Classify a natural language query into a query type.
+ * Uses lightweight regex rules — no LLM call needed.
+ */
+export function classifyQuery(query) {
+    if (TEMPORAL_SIGNALS.test(query))
+        return 'temporal';
+    if (PERSONAL_SIGNALS.test(query))
+        return 'personal';
+    if (RELATIONAL_SIGNALS.test(query))
+        return 'relational';
+    return 'factual';
+}
+/**
+ * Provider selection matrix per query type.
+ * ByteRover is always included. Other providers are conditionally active.
+ */
+/**
+ * Provider selection matrix per query type.
+ * Honcho and Hindsight are temporarily disabled — adapters coming in Phase 3.
+ * When re-enabled, add 'honcho' to personal and 'hindsight' to temporal/relational.
+ */
+const SELECTION_MATRIX = {
+    factual: ['byterover', 'obsidian', 'local-markdown', 'gbrain', 'memory-wiki'],
+    personal: ['byterover', 'obsidian', 'local-markdown'],
+    relational: ['byterover', 'obsidian', 'local-markdown', 'gbrain', 'memory-wiki'],
+    temporal: ['byterover', 'obsidian', 'local-markdown', 'gbrain', 'memory-wiki'],
+};
+/**
+ * Select which providers to activate for a given query type.
+ * Only returns providers that are in the available list.
+ * Matches by prefix so `local-markdown:notes` matches the `local-markdown` selector.
+ */
+export function selectProviders(queryType, availableProviderIds) {
+    const selectors = SELECTION_MATRIX[queryType];
+    return availableProviderIds.filter((id) => selectors.some((selector) => id === selector || id.startsWith(`${selector}:`)));
+}

package/dist/agent/infra/swarm/swarm-write-router.d.ts

@@ -0,0 +1,23 @@
+import type { IMemoryProvider } from '../../core/interfaces/i-memory-provider.js';
+/**
+ * Write type classification for routing store operations.
+ */
+export type WriteType = 'entity' | 'general' | 'note';
+/**
+ * Classify content into a write type using lightweight regex rules.
+ * Same pattern as classifyQuery() for reads.
+ */
+export declare function classifyWrite(content: string): WriteType;
+/**
+ * Select the best writable provider for a given write type.
+ *
+ * Filters providers to writable + healthy candidates internally.
+ *
+ * Priority:
+ * - entity → GBrain > first writable
+ * - note → first local-markdown > first writable
+ * - general → first writable (config order)
+ *
+ * @returns null if no writable+healthy provider is available
+ */
+export declare function selectWriteTarget(writeType: WriteType, providers: IMemoryProvider[], healthCache: Map<string, boolean>): IMemoryProvider | null;

package/dist/agent/infra/swarm/swarm-write-router.js

@@ -0,0 +1,45 @@
+const ENTITY_SIGNALS = /\b(CEO of|CTO of|co-founded|founded|founded by|is a .{0,20} at|president of|VP of|works at)\b/i;
+const NOTE_SIGNALS = /\b(action items?|draft|idea|meeting notes?|minutes|standup|TODO)\b/i;
+/**
+ * Classify content into a write type using lightweight regex rules.
+ * Same pattern as classifyQuery() for reads.
+ */
+export function classifyWrite(content) {
+    if (ENTITY_SIGNALS.test(content))
+        return 'entity';
+    if (NOTE_SIGNALS.test(content))
+        return 'note';
+    return 'general';
+}
+/**
+ * Select the best writable provider for a given write type.
+ *
+ * Filters providers to writable + healthy candidates internally.
+ *
+ * Priority:
+ * - entity → GBrain > first writable
+ * - note → first local-markdown > first writable
+ * - general → first writable (config order)
+ *
+ * @returns null if no writable+healthy provider is available
+ */
+export function selectWriteTarget(writeType, providers, healthCache) {
+    // Filter to writable + healthy
+    const candidates = providers.filter((p) => p.capabilities.writeSupported && healthCache.get(p.id) !== false);
+    if (candidates.length === 0) {
+        return null;
+    }
+    // Type-specific preference
+    if (writeType === 'entity') {
+        const gbrain = candidates.find((p) => p.type === 'gbrain');
+        if (gbrain)
+            return gbrain;
+    }
+    if (writeType === 'note') {
+        const localMd = candidates.find((p) => p.type === 'local-markdown');
+        if (localMd)
+            return localMd;
+    }
+    // Fallback: first writable candidate (deterministic by config order)
+    return candidates[0];
+}

package/dist/agent/infra/swarm/validation/config-validator.d.ts

@@ -0,0 +1,16 @@
+import type { SwarmConfig } from '../config/swarm-config-schema.js';
+import type { ValidationIssue } from './memory-swarm-validation-error.js';
+/**
+ * Result of runtime provider validation.
+ */
+export type ProviderValidationResult = {
+    cascadeNote?: string;
+    errors: ValidationIssue[];
+    warnings: ValidationIssue[];
+};
+/**
+ * Run runtime validation on all enabled providers.
+ * Checks paths exist, env vars are resolved, connections are reachable.
+ * Returns accumulated errors and warnings (never throws).
+ */
+export declare function validateSwarmProviders(config: SwarmConfig): Promise<ProviderValidationResult>;

package/dist/agent/infra/swarm/validation/config-validator.js

@@ -0,0 +1,402 @@
+import { execFile } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+import { join } from 'node:path';
+/**
+ * Check if a string value looks like an unresolved env var reference.
+ */
+function isUnresolvedEnvVar(value) {
+    return /^\$\{\w+\}$/.test(value);
+}
+/**
+ * Check if a credential string is effectively unusable:
+ * empty, whitespace-only, or an unresolved env var placeholder.
+ */
+function isInvalidCredential(value) {
+    if (value.trim().length === 0)
+        return 'empty';
+    if (isUnresolvedEnvVar(value))
+        return 'unresolved';
+    return undefined;
+}
+/**
+ * Validate obsidian provider config at runtime.
+ */
+function validateObsidian(config, errors, warnings) {
+    const { vaultPath } = config;
+    if (!existsSync(vaultPath)) {
+        errors.push({
+            field: 'vault_path',
+            message: `Obsidian vault not found at ${vaultPath}`,
+            provider: 'obsidian',
+            suggestion: `Verify the path exists or run \`brv swarm onboard\` to reconfigure.`,
+        });
+        return;
+    }
+    if (!existsSync(join(vaultPath, '.obsidian'))) {
+        warnings.push({
+            field: 'vault_path',
+            message: `Path ${vaultPath} exists but has no .obsidian/ directory. It may not be an Obsidian vault.`,
+            provider: 'obsidian',
+            suggestion: `Ensure this is the correct vault path.`,
+        });
+    }
+}
+/**
+ * Validate local-markdown provider config at runtime.
+ */
+function validateLocalMarkdown(config, errors) {
+    for (const folder of config.folders) {
+        if (!existsSync(folder.path)) {
+            errors.push({
+                field: 'folders.path',
+                message: `Folder ${folder.path} (${folder.name}) not found`,
+                provider: 'local-markdown',
+                suggestion: `Create the folder or update the path in config.`,
+            });
+        }
+    }
+}
+/**
+ * Validate honcho provider config at runtime.
+ */
+function validateHoncho(config, errors) {
+    const keyReason = isInvalidCredential(config.apiKey);
+    if (keyReason === 'empty') {
+        errors.push({
+            field: 'api_key',
+            message: `Honcho API key is empty`,
+            provider: 'honcho',
+            suggestion: `Set the HONCHO_API_KEY environment variable or provide a valid key.`,
+        });
+    }
+    else if (keyReason === 'unresolved') {
+        errors.push({
+            field: 'api_key',
+            message: `Honcho API key is unresolved: ${config.apiKey}`,
+            provider: 'honcho',
+            suggestion: `Set the HONCHO_API_KEY environment variable.`,
+        });
+    }
+    if (config.appId.trim().length === 0) {
+        errors.push({
+            field: 'app_id',
+            message: `Honcho app_id is empty`,
+            provider: 'honcho',
+            suggestion: `Provide a valid Honcho app ID in config.`,
+        });
+    }
+}
+/**
+ * Validate hindsight provider config at runtime.
+ */
+function validateHindsight(config, errors) {
+    const reason = isInvalidCredential(config.connectionString);
+    if (reason) {
+        errors.push({
+            field: 'connection_string',
+            message: reason === 'empty'
+                ? `Hindsight connection string is empty`
+                : `Hindsight connection string is unresolved: ${config.connectionString}`,
+            provider: 'hindsight',
+            suggestion: `Set the HINDSIGHT_DB_URL environment variable.`,
+        });
+        return;
+    }
+    // Validate it looks like a postgres:// URL
+    if (!config.connectionString.startsWith('postgres://') && !config.connectionString.startsWith('postgresql://')) {
+        errors.push({
+            field: 'connection_string',
+            message: `Hindsight connection string does not look like a valid Postgres URL: ${config.connectionString}`,
+            provider: 'hindsight',
+            suggestion: `Expected format: postgres://user:password@host:port/database`,
+        });
+    }
+}
+/**
+ * Validate gbrain provider config at runtime.
+ */
+async function validateGBrain(config, errors) {
+    if (!existsSync(config.repoPath)) {
+        errors.push({
+            field: 'repo_path',
+            message: `GBrain repo not found at ${config.repoPath}`,
+            provider: 'gbrain',
+            suggestion: `Verify the path or run \`brv swarm onboard\` to reconfigure.`,
+        });
+        return;
+    }
+    // Verify gbrain CLI is invokable.
+    // Check: is `gbrain` in PATH, or does src/cli.ts exist in repo/workspace (Bun fallback)?
+    let gbrainReachable = false;
+    // Option A: gbrain globally installed
+    try {
+        await execFileAsync('gbrain', ['--version'], { encoding: 'utf8', timeout: 5000 });
+        gbrainReachable = true;
+    }
+    catch {
+        // Not in PATH
+    }
+    // Option B: local Bun script (repoPath or workspace sibling)
+    if (!gbrainReachable) {
+        const candidates = [
+            join(config.repoPath, 'src', 'cli.ts'),
+            join(process.cwd(), '..', 'gbrain', 'src', 'cli.ts'),
+        ];
+        const scriptFound = candidates.some((p) => existsSync(p));
+        if (scriptFound) {
+            // Script exists — verify bun is available to run it
+            try {
+                await execFileAsync('bun', ['--version'], { encoding: 'utf8', timeout: 5000 });
+                gbrainReachable = true;
+            }
+            catch {
+                errors.push({
+                    field: 'gbrain',
+                    message: `GBrain source found but \`bun\` is not installed. GBrain requires Bun to run from source.`,
+                    provider: 'gbrain',
+                    suggestion: `Install Bun: https://bun.sh/docs/installation`,
+                });
+                return;
+            }
+        }
+    }
+    if (!gbrainReachable) {
+        errors.push({
+            field: 'gbrain',
+            message: `GBrain CLI not found. Not in PATH and no src/cli.ts in ${config.repoPath}`,
+            provider: 'gbrain',
+            suggestion: `Install globally with \`bun add -g gbrain\`, or set repo_path to the gbrain source directory.`,
+        });
+    }
+}
+/**
+ * Collect the set of provider IDs that are enabled in config.
+ * Uses prefix matching (e.g., `local-markdown` matches if any local-markdown folder exists).
+ */
+function getEnabledProviderIds(providers) {
+    const ids = new Set();
+    if (providers.byterover.enabled)
+        ids.add('byterover');
+    if (providers.obsidian?.enabled)
+        ids.add('obsidian');
+    if (providers.localMarkdown?.enabled) {
+        ids.add('local-markdown');
+        for (const folder of providers.localMarkdown.folders) {
+            ids.add(`local-markdown:${folder.name}`);
+        }
+    }
+    if (providers.honcho?.enabled)
+        ids.add('honcho');
+    if (providers.hindsight?.enabled)
+        ids.add('hindsight');
+    if (providers.gbrain?.enabled)
+        ids.add('gbrain');
+    if (providers.memoryWiki?.enabled)
+        ids.add('memory-wiki');
+    return ids;
+}
+/**
+ * Check if a provider ID matches an enabled provider (with prefix matching).
+ */
+function matchesEnabledProvider(edgeEndpoint, enabledIds) {
+    if (enabledIds.has(edgeEndpoint))
+        return true;
+    // Prefix match: "local-markdown" matches "local-markdown:notes"
+    for (const id of enabledIds) {
+        if (id.startsWith(`${edgeEndpoint}:`))
+            return true;
+    }
+    return false;
+}
+/**
+ * Check if a provider ID references a configured (but possibly disabled) provider.
+ */
+function isConfiguredProvider(edgeEndpoint, providers) {
+    if (edgeEndpoint === 'byterover')
+        return true;
+    if (edgeEndpoint === 'obsidian')
+        return providers.obsidian !== undefined;
+    if (edgeEndpoint === 'honcho')
+        return providers.honcho !== undefined;
+    if (edgeEndpoint === 'hindsight')
+        return providers.hindsight !== undefined;
+    if (edgeEndpoint === 'gbrain')
+        return providers.gbrain !== undefined;
+    if (edgeEndpoint === 'memory-wiki')
+        return providers.memoryWiki !== undefined;
+    // Generic "local-markdown" — valid if the section exists
+    if (edgeEndpoint === 'local-markdown')
+        return providers.localMarkdown !== undefined;
+    // Folder-scoped "local-markdown:<name>" — must match an actual configured folder
+    if (edgeEndpoint.startsWith('local-markdown:')) {
+        const folderName = edgeEndpoint.slice('local-markdown:'.length);
+        return providers.localMarkdown?.folders.some((f) => f.name === folderName) ?? false;
+    }
+    return false;
+}
+/**
+ * Detect cycles in enrichment edges using DFS.
+ */
+function hasCycle(edges) {
+    const adjacency = new Map();
+    for (const edge of edges) {
+        const existing = adjacency.get(edge.from) ?? [];
+        existing.push(edge.to);
+        adjacency.set(edge.from, existing);
+    }
+    const visited = new Set();
+    const inStack = new Set();
+    function dfs(node) {
+        if (inStack.has(node))
+            return true;
+        if (visited.has(node))
+            return false;
+        visited.add(node);
+        inStack.add(node);
+        for (const neighbor of adjacency.get(node) ?? []) {
+            if (dfs(neighbor))
+                return true;
+        }
+        inStack.delete(node);
+        return false;
+    }
+    const allNodes = new Set([...edges.map((e) => e.from), ...edges.map((e) => e.to)]);
+    for (const node of allNodes) {
+        if (dfs(node))
+            return true;
+    }
+    return false;
+}
+/**
+ * Expand a config edge endpoint to concrete provider IDs.
+ * "local-markdown" → ["local-markdown:notes", "local-markdown:docs"]
+ * "obsidian" → ["obsidian"]
+ *
+ * Prefers prefix expansion: if "local-markdown" has folder-scoped children,
+ * expand to those children rather than treating the generic ID as concrete.
+ */
+function resolveEndpoint(endpoint, enabledIds) {
+    // Prefer prefix expansion over exact match — generic IDs like "local-markdown"
+    // should expand to their concrete folder IDs, not stay as the generic form.
+    const prefixMatches = [...enabledIds].filter((id) => id.startsWith(`${endpoint}:`));
+    if (prefixMatches.length > 0)
+        return prefixMatches;
+    if (enabledIds.has(endpoint))
+        return [endpoint];
+    return [endpoint];
+}
+/**
+ * Validate enrichment edges: no self-edges, no cycles, endpoints must exist.
+ * Validates against the EXPANDED graph (generic endpoints resolved to concrete IDs)
+ * so that expansion-induced cycles and self-edges are caught at config time.
+ */
+function validateEnrichmentEdges(config, errors, warnings) {
+    const configEdges = config.enrichment?.edges ?? [];
+    if (configEdges.length === 0)
+        return;
+    const enabledIds = getEnabledProviderIds(config.providers);
+    // 1. Check raw endpoint existence/enabled status
+    for (const edge of configEdges) {
+        for (const endpoint of [edge.from, edge.to]) {
+            if (!isConfiguredProvider(endpoint, config.providers)) {
+                errors.push({
+                    field: 'enrichment.edges',
+                    message: `Enrichment edge references unknown provider '${endpoint}'`,
+                    provider: 'enrichment',
+                });
+            }
+            else if (!matchesEnabledProvider(endpoint, enabledIds)) {
+                warnings.push({
+                    field: 'enrichment.edges',
+                    message: `Enrichment edge references disabled provider '${endpoint}'`,
+                    provider: 'enrichment',
+                });
+            }
+        }
+    }
+    // 2. Expand only edges where BOTH endpoints are enabled.
+    // Disabled endpoints already produced warnings above — don't let them
+    // create phantom cycles or self-edges in the expanded graph.
+    const seen = new Set();
+    const expanded = [];
+    for (const edge of configEdges) {
+        if (!matchesEnabledProvider(edge.from, enabledIds) || !matchesEnabledProvider(edge.to, enabledIds)) {
+            continue;
+        }
+        const fromIds = resolveEndpoint(edge.from, enabledIds);
+        const toIds = resolveEndpoint(edge.to, enabledIds);
+        for (const from of fromIds) {
+            for (const to of toIds) {
+                const key = `${from}->${to}`;
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    expanded.push({ from, to });
+                }
+            }
+        }
+    }
+    // 3. Self-edge check on expanded graph
+    for (const edge of expanded) {
+        if (edge.from === edge.to) {
+            errors.push({
+                field: 'enrichment.edges',
+                message: `Enrichment self-edge after expansion: '${edge.from}' cannot enrich itself`,
+                provider: 'enrichment',
+                suggestion: `The generic endpoint expands to the same concrete provider on both sides.`,
+            });
+        }
+    }
+    // 4. Cycle detection on expanded graph
+    if (hasCycle(expanded)) {
+        errors.push({
+            field: 'enrichment.edges',
+            message: `Enrichment edges contain a cycle after expansion. The topology must be a directed acyclic graph (DAG).`,
+            provider: 'enrichment',
+            suggestion: `Generic endpoints like 'local-markdown' expand to concrete folder IDs, which may create cycles with specific endpoints. Remove one edge to break the cycle.`,
+        });
+    }
+}
+/**
+ * Run runtime validation on all enabled providers.
+ * Checks paths exist, env vars are resolved, connections are reachable.
+ * Returns accumulated errors and warnings (never throws).
+ */
+export async function validateSwarmProviders(config) {
+    const errors = [];
+    const warnings = [];
+    const { providers } = config;
+    // ByteRover is always valid (built-in)
+    if (providers.obsidian?.enabled) {
+        validateObsidian(providers.obsidian, errors, warnings);
+    }
+    if (providers.localMarkdown?.enabled) {
+        validateLocalMarkdown(providers.localMarkdown, errors);
+    }
+    if (providers.honcho?.enabled) {
+        validateHoncho(providers.honcho, errors);
+    }
+    if (providers.hindsight?.enabled) {
+        validateHindsight(providers.hindsight, errors);
+    }
+    if (providers.gbrain?.enabled) {
+        await validateGBrain(providers.gbrain, errors);
+    }
+    if (providers.memoryWiki?.enabled && !existsSync(providers.memoryWiki.vaultPath)) {
+        errors.push({
+            field: 'providers.memory_wiki.vault_path',
+            message: `Memory Wiki vault not found at ${providers.memoryWiki.vaultPath}`,
+            provider: 'memory-wiki',
+        });
+    }
+    // Validate enrichment edges
+    validateEnrichmentEdges(config, errors, warnings);
+    // Generate cascade note if cloud providers failed (exclude enrichment errors)
+    const CLOUD_PROVIDER_IDS = new Set(['gbrain', 'hindsight', 'honcho']);
+    const cloudErrors = errors.filter((e) => e.provider && CLOUD_PROVIDER_IDS.has(e.provider));
+    const cascadeNote = cloudErrors.length > 0
+        ? `${cloudErrors.length} cloud provider(s) failed validation. Routing will use local providers only until resolved.`
+        : undefined;
+    return { cascadeNote, errors, warnings };
+}

package/dist/agent/infra/swarm/validation/memory-swarm-validation-error.d.ts

@@ -0,0 +1,33 @@
+/**
+ * A single validation issue (error or warning) for a swarm provider.
+ */
+export type ValidationIssue = {
+    /** Config field that caused the issue */
+    field?: string;
+    /** Human-readable description of the issue */
+    message: string;
+    /** Which provider this issue relates to */
+    provider?: string;
+    /** Actionable fix hint */
+    suggestion?: string;
+};
+/**
+ * Error that accumulates all validation issues instead of failing on the first one.
+ * Contains both hard errors (blocking) and soft warnings (informational).
+ */
+export declare class MemorySwarmValidationError extends Error {
+    readonly errors: ValidationIssue[];
+    readonly warnings: ValidationIssue[];
+    readonly cascadeNote?: string | undefined;
+    readonly name = "MemorySwarmValidationError";
+    constructor(errors: ValidationIssue[], warnings: ValidationIssue[], cascadeNote?: string | undefined);
+    /**
+     * Serialize to a plain JSON object for CLI output or logging.
+     */
+    toJSON(): {
+        cascadeNote?: string;
+        errors: ValidationIssue[];
+        message: string;
+        warnings: ValidationIssue[];
+    };
+}

package/dist/agent/infra/swarm/validation/memory-swarm-validation-error.js

@@ -0,0 +1,27 @@
+/**
+ * Error that accumulates all validation issues instead of failing on the first one.
+ * Contains both hard errors (blocking) and soft warnings (informational).
+ */
+export class MemorySwarmValidationError extends Error {
+    errors;
+    warnings;
+    cascadeNote;
+    name = 'MemorySwarmValidationError';
+    constructor(errors, warnings, cascadeNote) {
+        super(`Memory swarm validation failed with ${errors.length} error(s)`);
+        this.errors = errors;
+        this.warnings = warnings;
+        this.cascadeNote = cascadeNote;
+    }
+    /**
+     * Serialize to a plain JSON object for CLI output or logging.
+     */
+    toJSON() {
+        return {
+            cascadeNote: this.cascadeNote,
+            errors: this.errors,
+            message: this.message,
+            warnings: this.warnings,
+        };
+    }
+}