@learningnodes/elen-mcp 0.1.2

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+export interface CliOptions {
+    agentId: string;
+    projectId: string;
+    storagePath?: string;
+}
+export declare function parseCliArgs(argv: string[]): CliOptions;

package/dist/index.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCliArgs = parseCliArgs;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const server_1 = require("./server");
+// MCP SDK overrides the ambient `process` type, stripping cwd().
+// We use execSync as a workaround.
+const currentDir = () => (0, node_child_process_1.execSync)('cd', { encoding: 'utf-8' }).trim();
+/**
+ * Auto-detect project identity from the environment.
+ * Priority: git remote name > package.json name > cwd basename > 'default'
+ */
+function detectProject() {
+    // 1. Try git remote URL → extract repo name
+    try {
+        const remote = (0, node_child_process_1.execSync)('git remote get-url origin', {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe']
+        }).trim();
+        // https://github.com/org/repo-name.git → repo-name
+        // git@github.com:org/repo-name.git → repo-name
+        const match = remote.match(/[/:]([^/]+?)(?:\.git)?$/);
+        if (match?.[1])
+            return match[1];
+    }
+    catch {
+        // Not a git repo or git not available
+    }
+    // 2. Try package.json name
+    const pkgPath = (0, node_path_1.resolve)(currentDir(), 'package.json');
+    if ((0, node_fs_1.existsSync)(pkgPath)) {
+        try {
+            const pkg = JSON.parse((0, node_fs_1.readFileSync)(pkgPath, 'utf-8'));
+            if (pkg.name) {
+                // Strip scope: @org/name → name
+                return pkg.name.replace(/^@[^/]+\//, '');
+            }
+        }
+        catch {
+            // Malformed package.json
+        }
+    }
+    // 3. Working directory basename
+    return (0, node_path_1.basename)(currentDir()) || 'default';
+}
+function parseCliArgs(argv) {
+    let agentId = 'default-agent';
+    let projectId;
+    let storagePath;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === '--agent-id') {
+            agentId = argv[i + 1] ?? agentId;
+            i += 1;
+            continue;
+        }
+        if (arg === '--project') {
+            projectId = argv[i + 1] ?? projectId;
+            i += 1;
+            continue;
+        }
+        if (arg === '--storage') {
+            storagePath = argv[i + 1] ?? storagePath;
+            i += 1;
+        }
+    }
+    return {
+        agentId,
+        projectId: projectId ?? detectProject(),
+        storagePath
+    };
+}
+async function main() {
+    const options = parseCliArgs(process.argv.slice(2));
+    process.stderr.write(`✦ Elen MCP starting — agent: ${options.agentId}, project: ${options.projectId}\n`);
+    const server = (0, server_1.createMcpServer)({
+        agentId: options.agentId,
+        projectId: options.projectId,
+        storagePath: options.storagePath ?? (0, server_1.defaultStoragePath)()
+    });
+    await server.start();
+}
+if (require.main === module) {
+    main().catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`Failed to start @learningnodes/elen-mcp: ${message}\n`);
+        process.exit(1);
+    });
+}

package/dist/server.d.ts

@@ -0,0 +1,14 @@
+import { Elen } from '@learningnodes/elen';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+export interface McpServerOptions {
+    agentId: string;
+    projectId?: string;
+    storagePath?: string;
+}
+export declare function defaultStoragePath(): string;
+export declare function createElenClient(options: McpServerOptions): Elen;
+export declare function routeToolCall(elen: Elen, agentId: string, name: string, args: unknown): Promise<unknown>;
+export declare function createMcpServer(options: McpServerOptions): {
+    server: Server;
+    start(): Promise<void>;
+};

package/dist/server.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultStoragePath = defaultStoragePath;
+exports.createElenClient = createElenClient;
+exports.routeToolCall = routeToolCall;
+exports.createMcpServer = createMcpServer;
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const elen_1 = require("@learningnodes/elen");
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const tools_1 = require("./tools");
+function defaultStoragePath() {
+    return (0, node_path_1.join)((0, node_os_1.homedir)(), '.elen', 'decisions.db');
+}
+function createElenClient(options) {
+    const sqlitePath = options.storagePath ?? defaultStoragePath();
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(sqlitePath), { recursive: true });
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return new elen_1.Elen({
+        agentId: options.agentId,
+        projectId: options.projectId,
+        storage: 'sqlite',
+        sqlitePath
+    });
+}
+async function routeToolCall(elen, agentId, name, args) {
+    switch (name) {
+        case tools_1.elenCommitTool.name:
+            return (0, tools_1.handleCommit)(elen, args);
+        case tools_1.elenSuggestTool.name:
+            return (0, tools_1.handleSuggest)(elen, args);
+        case tools_1.elenExpandTool.name:
+            return (0, tools_1.handleExpand)(elen, args);
+        case tools_1.elenSupersedeTool.name:
+            return (0, tools_1.handleSupersede)(elen, args);
+        case tools_1.elenGetCompetencyTool.name:
+            return (0, tools_1.handleGetCompetency)(elen, args, agentId);
+        case tools_1.elenLogDecisionTool.name:
+            return (0, tools_1.handleLogDecision)(elen, args);
+        case tools_1.elenSearchPrecedentsTool.name:
+            return (0, tools_1.handleSearchPrecedents)(elen, args);
+        default:
+            throw new Error(`Unknown tool: ${name}`);
+    }
+}
+function createMcpServer(options) {
+    const elen = createElenClient(options);
+    const server = new index_js_1.Server({
+        name: '@learningnodes/elen-mcp',
+        version: '0.1.0'
+    }, {
+        capabilities: {
+            tools: {}
+        }
+    });
+    server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
+        tools: [
+            tools_1.elenCommitTool,
+            tools_1.elenSuggestTool,
+            tools_1.elenExpandTool,
+            tools_1.elenSupersedeTool,
+            tools_1.elenGetCompetencyTool,
+            tools_1.elenLogDecisionTool,
+            tools_1.elenSearchPrecedentsTool
+        ]
+    }));
+    server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+        const result = await routeToolCall(elen, options.agentId, request.params.name, request.params.arguments);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2)
+                }
+            ]
+        };
+    });
+    return {
+        server,
+        async start() {
+            const transport = new stdio_js_1.StdioServerTransport();
+            await server.connect(transport);
+        }
+    };
+}

package/dist/tools/commit.d.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import type { Elen } from '@learningnodes/elen';
+export declare const elenCommitTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            question: {
+                type: string;
+                description: string;
+            };
+            domain: {
+                type: string;
+                description: string;
+            };
+            decisionText: {
+                type: string;
+                description: string;
+            };
+            constraints: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            refs: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare const commitInputSchema: z.ZodObject<{
+    question: z.ZodString;
+    domain: z.ZodString;
+    decisionText: z.ZodString;
+    constraints: z.ZodArray<z.ZodString>;
+    refs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare function handleCommit(elen: Elen, args: unknown): Promise<unknown>;

package/dist/tools/commit.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commitInputSchema = exports.elenCommitTool = void 0;
+exports.handleCommit = handleCommit;
+const zod_1 = require("zod");
+exports.elenCommitTool = {
+    name: 'elen_commit',
+    description: 'Commit a new minimal epistemic decision to the graph. Pass constraints as plain text array.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            question: { type: 'string', description: 'The question or problem statement' },
+            domain: { type: 'string', description: 'Domain of decision (e.g. infrastructure, product)' },
+            decisionText: { type: 'string', description: 'The proposed answer/decision made' },
+            constraints: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Plain-text constraint rules (e.g. "budget < 500 tokens")'
+            },
+            refs: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Explicit pointers to other decision IDs or artifacts'
+            }
+        },
+        required: ['question', 'domain', 'decisionText', 'constraints']
+    }
+};
+exports.commitInputSchema = zod_1.z.object({
+    question: zod_1.z.string().min(1),
+    domain: zod_1.z.string().min(1),
+    decisionText: zod_1.z.string().min(1),
+    constraints: zod_1.z.array(zod_1.z.string().min(1)),
+    refs: zod_1.z.array(zod_1.z.string()).optional()
+});
+async function handleCommit(elen, args) {
+    const parsed = exports.commitInputSchema.parse(args);
+    const result = await elen.commitDecision(parsed);
+    return result;
+}

package/dist/tools/competency.d.ts

@@ -0,0 +1,18 @@
+import type { Elen } from '@learningnodes/elen';
+export declare const elenGetCompetencyTool: {
+    readonly name: "elen_get_competency";
+    readonly description: "View the competency profile for this agent — domain expertise based on validated decision history.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly agentId: {
+                readonly type: "string";
+                readonly description: "Agent ID (defaults to current agent)";
+            };
+        };
+    };
+};
+export declare function validateCompetencyInput(input: unknown): {
+    agentId?: string;
+};
+export declare function handleGetCompetency(elen: Elen, args: unknown, defaultAgentId: string): Promise<unknown>;

package/dist/tools/competency.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.elenGetCompetencyTool = void 0;
+exports.validateCompetencyInput = validateCompetencyInput;
+exports.handleGetCompetency = handleGetCompetency;
+exports.elenGetCompetencyTool = {
+    name: 'elen_get_competency',
+    description: 'View the competency profile for this agent — domain expertise based on validated decision history.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            agentId: { type: 'string', description: 'Agent ID (defaults to current agent)' }
+        }
+    }
+};
+function validateCompetencyInput(input) {
+    if (input === undefined) {
+        return {};
+    }
+    if (!input || typeof input !== 'object') {
+        throw new Error('Invalid input: expected object');
+    }
+    const candidate = input;
+    if (candidate.agentId !== undefined && typeof candidate.agentId !== 'string') {
+        throw new Error('Invalid input: agentId must be a string');
+    }
+    return { agentId: candidate.agentId };
+}
+async function handleGetCompetency(elen, args, defaultAgentId) {
+    const parsed = validateCompetencyInput(args);
+    if (parsed.agentId && parsed.agentId !== defaultAgentId) {
+        throw new Error('Cross-agent profile lookup is not supported by this MCP server');
+    }
+    return elen.getCompetencyProfile();
+}

package/dist/tools/expand.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import type { Elen } from '@learningnodes/elen';
+export declare const elenExpandTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            decisionId: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare const expandInputSchema: z.ZodObject<{
+    decisionId: z.ZodString;
+}, z.core.$strip>;
+export declare function handleExpand(elen: Elen, args: unknown): Promise<unknown>;

package/dist/tools/expand.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expandInputSchema = exports.elenExpandTool = void 0;
+exports.handleExpand = handleExpand;
+const zod_1 = require("zod");
+exports.elenExpandTool = {
+    name: 'elen_expand',
+    description: 'Expand a minimal pointer decision ID into its full constraints and text when ambiguity requires it.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            decisionId: { type: 'string', description: 'The decision_id (e.g. dec:INFA-aBcDeF) to expand' }
+        },
+        required: ['decisionId']
+    }
+};
+exports.expandInputSchema = zod_1.z.object({
+    decisionId: zod_1.z.string().min(1)
+});
+async function handleExpand(elen, args) {
+    const parsed = exports.expandInputSchema.parse(args);
+    const result = await elen.expand(parsed.decisionId);
+    return result;
+}

package/dist/tools/get-context.d.ts

@@ -0,0 +1,34 @@
+import type { Elen } from '@learningnodes/elen';
+export declare const elenGetContextTool: {
+    readonly name: "elen_get_context";
+    readonly description: "Call this at the start of every deliberation to load your current decision context. Returns active threads and recent decisions.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly domain: {
+                readonly type: "string";
+                readonly description: "Optional domain filter to narrow context";
+            };
+            readonly limit: {
+                readonly type: "number";
+                readonly description: "Max recent decisions to return (default: 5)";
+            };
+        };
+    };
+};
+export declare function validateGetContextInput(input: unknown): {
+    domain?: string;
+    limit?: number;
+};
+export declare function handleGetContext(elen: Elen, input: unknown): Promise<{
+    total_decisions: number;
+    active_threads: {
+        thread_id: string;
+        thread_name: string;
+        decision_count: number;
+        latest_decision: string;
+        domains: string[];
+        turn_breakdown: Record<string, number>;
+    }[];
+    summary: string;
+}>;

package/dist/tools/get-context.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.elenGetContextTool = void 0;
+exports.validateGetContextInput = validateGetContextInput;
+exports.handleGetContext = handleGetContext;
+exports.elenGetContextTool = {
+    name: 'elen_get_context',
+    description: 'Call this at the start of every deliberation to load your current decision context. Returns active threads and recent decisions.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            domain: {
+                type: 'string',
+                description: 'Optional domain filter to narrow context'
+            },
+            limit: {
+                type: 'number',
+                description: 'Max recent decisions to return (default: 5)'
+            }
+        }
+    }
+};
+function validateGetContextInput(input) {
+    if (!input || typeof input !== 'object') {
+        return {};
+    }
+    const candidate = input;
+    if (candidate.domain !== undefined && typeof candidate.domain !== 'string') {
+        throw new Error('Invalid input: domain must be a string');
+    }
+    if (candidate.limit !== undefined && typeof candidate.limit !== 'number') {
+        throw new Error('Invalid input: limit must be a number');
+    }
+    return {
+        domain: candidate.domain,
+        limit: candidate.limit
+    };
+}
+async function handleGetContext(elen, input) {
+    const opts = validateGetContextInput(input);
+    const limit = opts.limit ?? 5;
+    const records = await elen.searchRecords({
+        domain: opts.domain,
+        limit
+    });
+    // Group by thread
+    const threads = {};
+    for (const record of records) {
+        const threadId = record.thread_id || `auto-${record.domain || 'general'}`;
+        const threadName = record.thread_name || `${record.domain || 'General'} Decisions`;
+        if (!threads[threadId]) {
+            threads[threadId] = {
+                thread_name: threadName,
+                count: 0,
+                latest: '',
+                domains: new Set(),
+                turn_types: {}
+            };
+        }
+        const thread = threads[threadId];
+        thread.count++;
+        thread.domains.add(record.domain || 'general');
+        const turnType = record.turn_type || 'ASK';
+        thread.turn_types[turnType] = (thread.turn_types[turnType] || 0) + 1;
+        if (!thread.latest || record.published_at > thread.latest) {
+            thread.latest = record.published_at;
+        }
+    }
+    const activeThreads = Object.entries(threads).map(([id, t]) => ({
+        thread_id: id,
+        thread_name: t.thread_name,
+        decision_count: t.count,
+        latest_decision: t.latest,
+        domains: [...t.domains],
+        turn_breakdown: t.turn_types
+    }));
+    return {
+        total_decisions: records.length,
+        active_threads: activeThreads,
+        summary: activeThreads.length === 0
+            ? 'No decisions recorded yet. Start by logging your first decision with elen_log_decision.'
+            : `${records.length} decisions across ${activeThreads.length} thread(s). Use elen_search_precedents to find related prior decisions.`
+    };
+}

package/dist/tools/index.d.ts

@@ -0,0 +1,7 @@
+export { elenCommitTool, handleCommit, commitInputSchema } from './commit';
+export { elenSuggestTool, handleSuggest, suggestInputSchema } from './suggest';
+export { elenExpandTool, handleExpand, expandInputSchema } from './expand';
+export { elenSupersedeTool, handleSupersede, supersedeInputSchema } from './supersede';
+export { elenGetCompetencyTool, handleGetCompetency, validateCompetencyInput } from './competency';
+export { elenLogDecisionTool, elenSearchPrecedentsTool, handleLogDecision, handleSearchPrecedents, validateLogDecisionInput, validateSearchInput } from './legacy';
+export declare const ELEN_TOOLS: readonly ["elen_commit", "elen_suggest", "elen_expand", "elen_supersede", "elen_get_competency", "elen_log_decision", "elen_search_precedents"];

package/dist/tools/index.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ELEN_TOOLS = exports.validateSearchInput = exports.validateLogDecisionInput = exports.handleSearchPrecedents = exports.handleLogDecision = exports.elenSearchPrecedentsTool = exports.elenLogDecisionTool = exports.validateCompetencyInput = exports.handleGetCompetency = exports.elenGetCompetencyTool = exports.supersedeInputSchema = exports.handleSupersede = exports.elenSupersedeTool = exports.expandInputSchema = exports.handleExpand = exports.elenExpandTool = exports.suggestInputSchema = exports.handleSuggest = exports.elenSuggestTool = exports.commitInputSchema = exports.handleCommit = exports.elenCommitTool = void 0;
+var commit_1 = require("./commit");
+Object.defineProperty(exports, "elenCommitTool", { enumerable: true, get: function () { return commit_1.elenCommitTool; } });
+Object.defineProperty(exports, "handleCommit", { enumerable: true, get: function () { return commit_1.handleCommit; } });
+Object.defineProperty(exports, "commitInputSchema", { enumerable: true, get: function () { return commit_1.commitInputSchema; } });
+var suggest_1 = require("./suggest");
+Object.defineProperty(exports, "elenSuggestTool", { enumerable: true, get: function () { return suggest_1.elenSuggestTool; } });
+Object.defineProperty(exports, "handleSuggest", { enumerable: true, get: function () { return suggest_1.handleSuggest; } });
+Object.defineProperty(exports, "suggestInputSchema", { enumerable: true, get: function () { return suggest_1.suggestInputSchema; } });
+var expand_1 = require("./expand");
+Object.defineProperty(exports, "elenExpandTool", { enumerable: true, get: function () { return expand_1.elenExpandTool; } });
+Object.defineProperty(exports, "handleExpand", { enumerable: true, get: function () { return expand_1.handleExpand; } });
+Object.defineProperty(exports, "expandInputSchema", { enumerable: true, get: function () { return expand_1.expandInputSchema; } });
+var supersede_1 = require("./supersede");
+Object.defineProperty(exports, "elenSupersedeTool", { enumerable: true, get: function () { return supersede_1.elenSupersedeTool; } });
+Object.defineProperty(exports, "handleSupersede", { enumerable: true, get: function () { return supersede_1.handleSupersede; } });
+Object.defineProperty(exports, "supersedeInputSchema", { enumerable: true, get: function () { return supersede_1.supersedeInputSchema; } });
+var competency_1 = require("./competency");
+Object.defineProperty(exports, "elenGetCompetencyTool", { enumerable: true, get: function () { return competency_1.elenGetCompetencyTool; } });
+Object.defineProperty(exports, "handleGetCompetency", { enumerable: true, get: function () { return competency_1.handleGetCompetency; } });
+Object.defineProperty(exports, "validateCompetencyInput", { enumerable: true, get: function () { return competency_1.validateCompetencyInput; } });
+var legacy_1 = require("./legacy");
+Object.defineProperty(exports, "elenLogDecisionTool", { enumerable: true, get: function () { return legacy_1.elenLogDecisionTool; } });
+Object.defineProperty(exports, "elenSearchPrecedentsTool", { enumerable: true, get: function () { return legacy_1.elenSearchPrecedentsTool; } });
+Object.defineProperty(exports, "handleLogDecision", { enumerable: true, get: function () { return legacy_1.handleLogDecision; } });
+Object.defineProperty(exports, "handleSearchPrecedents", { enumerable: true, get: function () { return legacy_1.handleSearchPrecedents; } });
+Object.defineProperty(exports, "validateLogDecisionInput", { enumerable: true, get: function () { return legacy_1.validateLogDecisionInput; } });
+Object.defineProperty(exports, "validateSearchInput", { enumerable: true, get: function () { return legacy_1.validateSearchInput; } });
+exports.ELEN_TOOLS = [
+    'elen_commit',
+    'elen_suggest',
+    'elen_expand',
+    'elen_supersede',
+    'elen_get_competency',
+    'elen_log_decision',
+    'elen_search_precedents'
+];

package/dist/tools/legacy.d.ts

@@ -0,0 +1,72 @@
+import type { Elen } from '@learningnodes/elen';
+export declare const elenLogDecisionTool: {
+    readonly name: "elen_log_decision";
+    readonly description: "Create a validated Decision Record from constraints/evidence/answer.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly question: {
+                readonly type: "string";
+            };
+            readonly domain: {
+                readonly type: "string";
+            };
+            readonly constraints: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+            };
+            readonly evidence: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+            };
+            readonly answer: {
+                readonly type: "string";
+            };
+            readonly parentPrompt: {
+                readonly type: "string";
+            };
+        };
+        readonly required: readonly ["question", "constraints", "evidence", "answer"];
+    };
+};
+export declare const elenSearchPrecedentsTool: {
+    readonly name: "elen_search_precedents";
+    readonly description: "Search validated decisions for precedents.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly query: {
+                readonly type: "string";
+            };
+            readonly domain: {
+                readonly type: "string";
+            };
+            readonly minConfidence: {
+                readonly type: "number";
+            };
+            readonly limit: {
+                readonly type: "number";
+            };
+        };
+    };
+};
+export declare function validateLogDecisionInput(input: unknown): {
+    question: string;
+    domain?: string;
+    constraints: string[];
+    evidence: string[];
+    answer: string;
+    parentPrompt?: string;
+};
+export declare function validateSearchInput(input: unknown): {
+    query?: string;
+    domain?: string;
+    minConfidence?: number;
+    limit?: number;
+};
+export declare function handleLogDecision(elen: Elen, args: unknown): Promise<unknown>;
+export declare function handleSearchPrecedents(elen: Elen, args: unknown): Promise<unknown>;