monomind 1.11.13 → 1.11.14

package/packages/@monomind/cli/bundled-graph/dist/src/cluster.js

@@ -0,0 +1,120 @@
+import Graph from 'graphology';
+export async function detectCommunities(graph) {
+    let louvainFn = null;
+    try {
+        const mod = await import('graphology-communities-louvain');
+        louvainFn = mod.default;
+    }
+    catch { /* louvain not available */ }
+    if (louvainFn) {
+        try {
+            const assignment = louvainFn(graph);
+            for (const [nodeId, communityId] of Object.entries(assignment)) {
+                graph.setNodeAttribute(nodeId, 'community', communityId);
+            }
+            const communities = {};
+            for (const [nodeId, communityId] of Object.entries(assignment)) {
+                if (!communities[communityId])
+                    communities[communityId] = [];
+                communities[communityId].push(nodeId);
+            }
+            return splitOversizedCommunities(graph, communities, 0.25, louvainFn);
+        }
+        catch { /* fall through */ }
+    }
+    return splitOversizedCommunities(graph, fallbackCluster(graph), 0.25, louvainFn);
+}
+function fallbackCluster(graph) {
+    const dirMap = new Map();
+    let nextId = 0;
+    const communities = {};
+    graph.forEachNode((id, attrs) => {
+        const file = attrs.sourceFile || '';
+        const parts = file.split('/');
+        const dir = parts.length > 1 ? parts.slice(0, -1).join('/') : 'root';
+        if (!dirMap.has(dir))
+            dirMap.set(dir, nextId++);
+        const cid = dirMap.get(dir);
+        graph.setNodeAttribute(id, 'community', cid);
+        if (!communities[cid])
+            communities[cid] = [];
+        communities[cid].push(id);
+    });
+    return communities;
+}
+export function cohesionScore(graph, communityNodes) {
+    const memberSet = new Set(communityNodes);
+    let totalEdges = 0;
+    let internalEdges = 0;
+    graph.forEachEdge((_edge, _attrs, source, target) => {
+        const srcIn = memberSet.has(source);
+        const tgtIn = memberSet.has(target);
+        if (srcIn || tgtIn) {
+            totalEdges++;
+            if (srcIn && tgtIn)
+                internalEdges++;
+        }
+    });
+    return totalEdges === 0 ? 1.0 : internalEdges / totalEdges;
+}
+export function splitOversizedCommunities(graph, communities, threshold = 0.25, louvainFn = null) {
+    const maxSize = threshold * graph.order;
+    const allIds = Object.keys(communities).map(Number);
+    let nextId = allIds.length > 0 ? Math.max(...allIds) + 1 : 0;
+    for (const [cidStr, members] of Object.entries(communities)) {
+        if (members.length <= maxSize)
+            continue;
+        const cid = Number(cidStr);
+        // Attempt topology-based second pass via Louvain on the community subgraph
+        if (louvainFn && members.length >= 10) {
+            try {
+                const memberSet = new Set(members);
+                const subG = new Graph({ type: 'undirected', multi: false });
+                for (const nodeId of members)
+                    subG.addNode(nodeId);
+                graph.forEachEdge((_e, _a, source, target) => {
+                    if (memberSet.has(source) && memberSet.has(target) && source !== target && !subG.hasEdge(source, target))
+                        subG.addEdge(source, target);
+                });
+                const subAssignment = louvainFn(subG);
+                const subCommunityCount = new Set(Object.values(subAssignment)).size;
+                if (subCommunityCount > 1 && subCommunityCount <= Math.ceil(members.length / 2)) {
+                    const subIdMap = new Map();
+                    const newSubIds = {};
+                    for (const [nodeId, localId] of Object.entries(subAssignment)) {
+                        if (!subIdMap.has(localId))
+                            subIdMap.set(localId, nextId++);
+                        const globalId = subIdMap.get(localId);
+                        graph.setNodeAttribute(nodeId, 'community', globalId);
+                        if (!newSubIds[globalId])
+                            newSubIds[globalId] = [];
+                        newSubIds[globalId].push(nodeId);
+                    }
+                    delete communities[cid];
+                    Object.assign(communities, newSubIds);
+                    continue;
+                }
+            }
+            catch { /* fall through to directory heuristic */ }
+        }
+        // Directory heuristic fallback
+        const subMap = new Map();
+        const newSubIds = {};
+        for (const nodeId of members) {
+            const file = graph.getNodeAttribute(nodeId, 'sourceFile') || '';
+            const parts = file.split('/');
+            const parentDir = parts.length > 1 ? parts[parts.length - 2] : 'root';
+            if (!subMap.has(parentDir))
+                subMap.set(parentDir, nextId++);
+            const subId = subMap.get(parentDir);
+            graph.setNodeAttribute(nodeId, 'community', subId);
+            if (!newSubIds[subId])
+                newSubIds[subId] = [];
+            newSubIds[subId].push(nodeId);
+        }
+        delete communities[cid];
+        Object.assign(communities, newSubIds);
+    }
+    return communities;
+}
+//# sourceMappingURL=cluster.js.map

package/packages/@monomind/cli/bundled-graph/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@monomind/graph",
+  "version": "1.4.0",
+  "type": "module",
+  "description": "Knowledge graph engine for monomind — AST extraction, graph construction, community detection, and persistent codebase understanding",
+  "main": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "graphology": "^0.25.4",
+    "graphology-types": "^0.24.7",
+    "graphology-communities-louvain": "^2.0.1",
+    "graphology-shortest-path": "^2.0.2",
+    "graphology-traversal": "^0.3.1",
+    "graphology-metrics": "^2.4.0",
+    "chokidar": "^3.6.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.3.0",
+    "vitest": "^4.1.4"
+  },
+  "optionalDependencies": {
+    "node-tree-sitter": "^0.22.4",
+    "tree-sitter-typescript": "^0.23.2",
+    "tree-sitter-javascript": "^0.23.1",
+    "tree-sitter-python": "^0.23.6",
+    "tree-sitter-go": "^0.23.4",
+    "tree-sitter-rust": "^0.23.2",
+    "tree-sitter-java": "^0.23.5",
+    "tree-sitter-c": "^0.23.4",
+    "tree-sitter-cpp": "^0.23.4",
+    "tree-sitter-ruby": "^0.23.1",
+    "tree-sitter-c-sharp": "^0.23.1",
+    "tree-sitter-kotlin": "^0.3.9",
+    "tree-sitter-swift": "^0.6.1",
+    "tree-sitter-scala": "^0.23.4",
+    "tree-sitter-php": "^0.23.11"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/packages/@monomind/cli/dist/src/agents/halt-signal.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Halt Signal (Task 35)
+ *
+ * JSONL-based broadcast/check for swarm-level halt signals.
+ * When an agent triggers a cascade halt, other agents in the same swarm
+ * can query whether a halt has been issued.
+ */
+import type { TerminationReason } from '../../../shared/src/types/termination.js';
+/** Record written to the JSONL halt log. */
+export interface HaltRecord {
+    id: string;
+    swarmId: string;
+    sourceAgentId: string;
+    reason: TerminationReason;
+    haltedAt: string;
+}
+/**
+ * Broadcast a halt signal for a swarm.
+ */
+export declare function broadcast(swarmId: string, sourceAgentId: string, reason: TerminationReason, filePath?: string): HaltRecord;
+/**
+ * Check whether any halt signal exists for the given swarm.
+ */
+export declare function isHalted(swarmId: string, filePath?: string): boolean;
+//# sourceMappingURL=halt-signal.d.ts.map

package/packages/@monomind/cli/dist/src/agents/halt-signal.js

@@ -0,0 +1,76 @@
+/**
+ * Halt Signal (Task 35)
+ *
+ * JSONL-based broadcast/check for swarm-level halt signals.
+ * When an agent triggers a cascade halt, other agents in the same swarm
+ * can query whether a halt has been issued.
+ */
+import { randomUUID } from 'crypto';
+import { existsSync, mkdirSync, appendFileSync, readFileSync, statSync } from 'fs';
+import { join, dirname, resolve, sep } from 'path';
+const ALLOWED_ROOT = () => resolve(process.env.MONOMIND_DATA_DIR ?? process.cwd());
+const DEFAULT_FILE = () => join(ALLOWED_ROOT(), 'data', 'halt-signals.jsonl');
+function safeHaltFilePath(filePath) {
+    const allowedRoot = ALLOWED_ROOT();
+    const resolved = resolve(filePath);
+    if (resolved !== allowedRoot && !resolved.startsWith(allowedRoot + sep)) {
+        throw new Error(`Halt signal file path escapes allowed directory: ${filePath}`);
+    }
+    return resolved;
+}
+/**
+ * Broadcast a halt signal for a swarm.
+ */
+export function broadcast(swarmId, sourceAgentId, reason, filePath) {
+    const target = filePath ? safeHaltFilePath(filePath) : DEFAULT_FILE();
+    const dir = dirname(target);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    const record = {
+        id: randomUUID(),
+        swarmId,
+        sourceAgentId,
+        reason,
+        haltedAt: new Date().toISOString(),
+    };
+    appendFileSync(target, JSON.stringify(record) + '\n', 'utf-8');
+    return record;
+}
+/**
+ * Check whether any halt signal exists for the given swarm.
+ */
+export function isHalted(swarmId, filePath) {
+    const target = filePath ? safeHaltFilePath(filePath) : DEFAULT_FILE();
+    if (!existsSync(target)) {
+        return false;
+    }
+    // Size cap. isHalted is on the swarm-coordination hot path; without this
+    // cap a planted multi-GB file (or unbounded broadcast accumulation over
+    // weeks) reliably OOMs the CLI on the next call. Treat oversized halt
+    // logs as "no halt" — fail-safe in the swarm-termination flow.
+    try {
+        const stat = statSync(target);
+        if (stat.size > 10 * 1024 * 1024)
+            return false;
+    }
+    catch {
+        return false;
+    }
+    const raw = readFileSync(target, 'utf-8').trim();
+    if (!raw)
+        return false;
+    return raw
+        .split('\n')
+        .filter(Boolean)
+        .some((line) => {
+        try {
+            const rec = JSON.parse(line);
+            return rec.swarmId === swarmId;
+        }
+        catch {
+            return false;
+        }
+    });
+}
+//# sourceMappingURL=halt-signal.js.map

package/packages/@monomind/cli/dist/src/agents/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Agent utilities — prompt versioning, experiment routing, managed agents.
+ *
+ * @module @monoes/cli/agents
+ */
+export { PromptExperimentRouter } from './prompt-experiment.js';
+export type { ResolvedPrompt } from './prompt-experiment.js';
+export { PromptVersionManager } from './prompt-version-manager.js';
+export { spawnAndAwait } from './managed-agent.js';
+export type { AgentRunResult, ManagedAgentOptions } from './managed-agent.js';
+export { check as checkTermination, persistEvent } from './termination-watcher.js';
+export type { AgentRunState } from './termination-watcher.js';
+export { broadcast as broadcastHalt, isHalted } from './halt-signal.js';
+export type { HaltRecord } from './halt-signal.js';
+export { buildRegistry } from './registry-builder.js';
+export { RegistryQuery } from './registry-query.js';
+export type { RegistryValidationResult, RegistryConflict } from './registry-query.js';
+//# sourceMappingURL=index.d.ts.map

package/packages/@monomind/cli/dist/src/agents/index.js

@@ -0,0 +1,13 @@
+/**
+ * Agent utilities — prompt versioning, experiment routing, managed agents.
+ *
+ * @module @monoes/cli/agents
+ */
+export { PromptExperimentRouter } from './prompt-experiment.js';
+export { PromptVersionManager } from './prompt-version-manager.js';
+export { spawnAndAwait } from './managed-agent.js';
+export { check as checkTermination, persistEvent } from './termination-watcher.js';
+export { broadcast as broadcastHalt, isHalted } from './halt-signal.js';
+export { buildRegistry } from './registry-builder.js';
+export { RegistryQuery } from './registry-query.js';
+//# sourceMappingURL=index.js.map

package/packages/@monomind/cli/dist/src/agents/managed-agent.d.ts

@@ -0,0 +1,41 @@
+export interface AgentRunResult {
+    agentSlug: string;
+    taskId: string;
+    output: string;
+    status: 'success' | 'error' | 'timeout';
+    durationMs: number;
+    tokens?: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+    error?: string;
+}
+export interface ManagedAgentOptions {
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+}
+/**
+ * Simulates spawn-and-await by creating a taskId, delegating to a runner function,
+ * and applying timeout.
+ */
+export declare function spawnAndAwait(agentSlug: string, task: string, runner: (agentSlug: string, taskId: string, task: string) => Promise<string>, options?: ManagedAgentOptions): Promise<AgentRunResult>;
+export declare class ManagedAgent {
+    private readonly agentSlug;
+    private readonly runner;
+    private readonly options;
+    constructor(agentSlug: string, runner: (agentSlug: string, taskId: string, task: string) => Promise<string>, options?: ManagedAgentOptions);
+    run(task: string): Promise<AgentRunResult>;
+    /** Generate an MCP-style tool descriptor for this agent */
+    toToolDescriptor(): {
+        name: string;
+        description: string;
+        inputSchema: Record<string, unknown>;
+    };
+    static create(agentSlug: string, runner: (slug: string, id: string, task: string) => Promise<string>, options?: ManagedAgentOptions): ManagedAgent;
+}
+/** Run multiple agents in parallel */
+export declare function runBatch(agents: Array<{
+    agentSlug: string;
+    task: string;
+}>, runner: (agentSlug: string, taskId: string, task: string) => Promise<string>, options?: ManagedAgentOptions): Promise<AgentRunResult[]>;
+//# sourceMappingURL=managed-agent.d.ts.map

package/packages/@monomind/cli/dist/src/agents/managed-agent.js

@@ -0,0 +1,69 @@
+import { randomBytes } from 'node:crypto';
+/**
+ * Simulates spawn-and-await by creating a taskId, delegating to a runner function,
+ * and applying timeout.
+ */
+export async function spawnAndAwait(agentSlug, task, runner, options = {}) {
+    const { timeoutMs = 120_000 } = options;
+    const startedAt = Date.now();
+    const taskId = `managed-${Date.now().toString(36)}-${randomBytes(4).toString('hex')}`;
+    try {
+        let timeoutHandle;
+        const output = await Promise.race([
+            runner(agentSlug, taskId, task),
+            new Promise((_, reject) => {
+                timeoutHandle = setTimeout(() => reject(new Error(`Timeout after ${timeoutMs}ms`)), timeoutMs);
+            }),
+        ]).finally(() => clearTimeout(timeoutHandle));
+        return {
+            agentSlug, taskId, output, status: 'success',
+            durationMs: Date.now() - startedAt,
+        };
+    }
+    catch (err) {
+        const isTimeout = String(err).includes('Timeout');
+        return {
+            agentSlug, taskId, output: '',
+            status: isTimeout ? 'timeout' : 'error',
+            durationMs: Date.now() - startedAt,
+            error: String(err),
+        };
+    }
+}
+export class ManagedAgent {
+    agentSlug;
+    runner;
+    options;
+    constructor(agentSlug, runner, options = {}) {
+        this.agentSlug = agentSlug;
+        this.runner = runner;
+        this.options = options;
+    }
+    async run(task) {
+        return spawnAndAwait(this.agentSlug, task, this.runner, this.options);
+    }
+    /** Generate an MCP-style tool descriptor for this agent */
+    toToolDescriptor() {
+        const toolName = `agent_${this.agentSlug.replace(/-/g, '_')}`;
+        return {
+            name: toolName,
+            description: `Delegate a task to the ${this.agentSlug} specialist agent`,
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    task: { type: 'string', description: 'Task description' },
+                    timeoutMs: { type: 'number', description: 'Timeout in ms (default 120000)' },
+                },
+                required: ['task'],
+            },
+        };
+    }
+    static create(agentSlug, runner, options) {
+        return new ManagedAgent(agentSlug, runner, options);
+    }
+}
+/** Run multiple agents in parallel */
+export async function runBatch(agents, runner, options = {}) {
+    return Promise.all(agents.map(({ agentSlug, task }) => spawnAndAwait(agentSlug, task, runner, options)));
+}
+//# sourceMappingURL=managed-agent.js.map

package/packages/@monomind/cli/dist/src/agents/prompt-experiment.d.ts

@@ -0,0 +1,23 @@
+/**
+ * PromptExperimentRouter - A/B traffic splitting for prompt versions
+ *
+ * Checks for an active experiment on the given agent slug and probabilistically
+ * routes to the candidate or control version. Falls back to the active version
+ * when no experiment is running.
+ *
+ * @module @monomind/cli/agents/prompt-experiment
+ */
+type PromptVersionStore = any;
+export interface ResolvedPrompt {
+    prompt: string;
+    version: string;
+    isCandidate: boolean;
+    agentSlug: string;
+}
+export declare class PromptExperimentRouter {
+    private readonly store;
+    constructor(store: PromptVersionStore);
+    resolvePromptForSpawn(agentSlug: string): ResolvedPrompt;
+}
+export {};
+//# sourceMappingURL=prompt-experiment.d.ts.map

package/packages/@monomind/cli/dist/src/agents/prompt-experiment.js

@@ -0,0 +1,49 @@
+/**
+ * PromptExperimentRouter - A/B traffic splitting for prompt versions
+ *
+ * Checks for an active experiment on the given agent slug and probabilistically
+ * routes to the candidate or control version. Falls back to the active version
+ * when no experiment is running.
+ *
+ * @module @monomind/cli/agents/prompt-experiment
+ */
+export class PromptExperimentRouter {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    resolvePromptForSpawn(agentSlug) {
+        const experiment = this.store.getExperiment(agentSlug);
+        if (experiment) {
+            const useCandidate = Math.random() < experiment.trafficPct;
+            const targetVersion = useCandidate ? experiment.candidate : experiment.control;
+            const versions = this.store.listVersions(agentSlug);
+            const found = versions.find((v) => v.version === targetVersion);
+            if (found) {
+                return {
+                    prompt: found.prompt,
+                    version: found.version,
+                    isCandidate: useCandidate,
+                    agentSlug,
+                };
+            }
+        }
+        // Fallback to active version
+        const active = this.store.getActive(agentSlug);
+        if (active) {
+            return {
+                prompt: active.prompt,
+                version: active.version,
+                isCandidate: false,
+                agentSlug,
+            };
+        }
+        return {
+            prompt: '',
+            version: '',
+            isCandidate: false,
+            agentSlug,
+        };
+    }
+}
+//# sourceMappingURL=prompt-experiment.js.map

package/packages/@monomind/cli/dist/src/agents/prompt-version-manager.d.ts

@@ -0,0 +1,22 @@
+/**
+ * PromptVersionManager - High-level prompt version lifecycle operations
+ *
+ * Provides publish-from-file, promote, rollback, and experiment
+ * start/stop workflows on top of PromptVersionStore.
+ *
+ * @module @monomind/cli/agents/prompt-version-manager
+ */
+type PromptVersionStore = any;
+type PromptVersion = any;
+type PromptExperiment = any;
+export declare class PromptVersionManager {
+    private readonly store;
+    constructor(store: PromptVersionStore);
+    publishFromFile(agentSlug: string, filePath: string, newVersion: string, changelog: string): PromptVersion;
+    promote(agentSlug: string, version: string): void;
+    rollback(agentSlug: string, stepsBack?: number): void;
+    startExperiment(experiment: PromptExperiment): void;
+    stopExperiment(agentSlug: string, promoteWinner?: boolean): void;
+}
+export {};
+//# sourceMappingURL=prompt-version-manager.d.ts.map

package/packages/@monomind/cli/dist/src/agents/prompt-version-manager.js

@@ -0,0 +1,80 @@
+/**
+ * PromptVersionManager - High-level prompt version lifecycle operations
+ *
+ * Provides publish-from-file, promote, rollback, and experiment
+ * start/stop workflows on top of PromptVersionStore.
+ *
+ * @module @monomind/cli/agents/prompt-version-manager
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+export class PromptVersionManager {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    publishFromFile(agentSlug, filePath, newVersion, changelog) {
+        // Symlink-aware containment: path.resolve does NOT follow symlinks, so
+        // a symlink under cwd pointing at /etc/shadow would have passed the
+        // prefix-check below. Use realpathSync on both sides and reject symlinks
+        // at the leaf so the resolved file is provably inside the project.
+        const allowedRoot = fs.realpathSync(process.cwd());
+        const requested = path.resolve(filePath);
+        if (!fs.existsSync(requested)) {
+            throw new Error(`filePath does not exist: ${requested}`);
+        }
+        if (fs.lstatSync(requested).isSymbolicLink()) {
+            throw new Error('filePath must not be a symlink');
+        }
+        const resolved = fs.realpathSync(requested);
+        const rel = path.relative(allowedRoot, resolved);
+        if (rel.startsWith('..') || path.isAbsolute(rel)) {
+            throw new Error(`filePath must be inside the project directory: ${allowedRoot}`);
+        }
+        const MAX_PROMPT_BYTES = 1 * 1024 * 1024;
+        const fileSize = fs.statSync(resolved).size;
+        if (fileSize > MAX_PROMPT_BYTES) {
+            throw new Error(`filePath exceeds maximum allowed size (${MAX_PROMPT_BYTES} bytes): ${resolved}`);
+        }
+        const prompt = fs.readFileSync(resolved, 'utf-8');
+        const version = {
+            agentSlug,
+            version: newVersion,
+            prompt,
+            changelog,
+            activeFrom: new Date(),
+            traceCount: 0,
+            publishedBy: 'prompt-version-manager',
+            createdAt: new Date(),
+        };
+        this.store.save(version);
+        return version;
+    }
+    promote(agentSlug, version) {
+        this.store.setActive(agentSlug, version);
+    }
+    rollback(agentSlug, stepsBack = 1) {
+        const versions = this.store.listVersions(agentSlug);
+        if (versions.length < stepsBack + 1) {
+            throw new Error(`Cannot rollback ${stepsBack} step(s): only ${versions.length} version(s) exist for "${agentSlug}"`);
+        }
+        // versions are sorted DESC by createdAt, so index 0 = newest
+        const target = versions[stepsBack];
+        this.store.setActive(agentSlug, target.version);
+    }
+    startExperiment(experiment) {
+        this.store.saveExperiment(experiment);
+    }
+    stopExperiment(agentSlug, promoteWinner) {
+        const experiment = this.store.getExperiment(agentSlug);
+        if (!experiment) {
+            throw new Error(`No active experiment for "${agentSlug}"`);
+        }
+        const winnerId = (experiment.winner ?? experiment.control);
+        this.store.concludeExperiment(agentSlug, winnerId);
+        if (promoteWinner) {
+            this.store.setActive(agentSlug, winnerId);
+        }
+    }
+}
+//# sourceMappingURL=prompt-version-manager.js.map

package/packages/@monomind/cli/dist/src/agents/registry-query.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Registry Query (Task 30)
+ *
+ * Provides query and validation utilities over an AgentRegistry.
+ * Supports loading from an in-memory object or a JSON file on disk.
+ */
+import type { AgentRegistry, AgentRegistryEntry } from '../../../shared/src/types/agent-registry.js';
+/** Validation issue found during registry validation. */
+export interface RegistryValidationResult {
+    slug: string;
+    field: string;
+    message: string;
+    severity: 'error' | 'warning';
+}
+/** Conflict entry for duplicate slug detection. */
+export interface RegistryConflict {
+    slug: string;
+    entries: AgentRegistryEntry[];
+}
+/**
+ * Query engine for the Central Agent Registry.
+ */
+export declare class RegistryQuery {
+    private agents;
+    private constructor();
+    /**
+     * Create a RegistryQuery from an in-memory AgentRegistry object.
+     */
+    static loadFromJSON(registry: AgentRegistry): RegistryQuery;
+    /**
+     * Create a RegistryQuery by reading a registry JSON file from disk.
+     */
+    static loadFromFile(path: string): RegistryQuery;
+    /**
+     * Find all agents that list the given capability.
+     */
+    findByCapability(capability: string): AgentRegistryEntry[];
+    /**
+     * Find all agents that handle the given task type.
+     */
+    findByTaskType(taskType: string): AgentRegistryEntry[];
+    /**
+     * Find an agent by its unique slug. Returns undefined if not found.
+     */
+    findBySlug(slug: string): AgentRegistryEntry | undefined;
+    /**
+     * Find all agents that list the given tool.
+     */
+    findByTool(tool: string): AgentRegistryEntry[];
+    /**
+     * Find micro-agents — agents that have at least one trigger pattern.
+     */
+    findMicroAgents(): AgentRegistryEntry[];
+    /**
+     * Return all agent slugs in the registry.
+     */
+    allSlugs(): string[];
+    /**
+     * Validate the registry, returning a list of validation issues.
+     * Checks:
+     * - version must be valid semver (X.Y.Z pattern)
+     * - slug must be non-empty
+     * - name must be non-empty
+     */
+    validate(): RegistryValidationResult[];
+    /**
+     * Detect duplicate slugs across registry entries.
+     */
+    conflicts(): RegistryConflict[];
+}
+//# sourceMappingURL=registry-query.d.ts.map