@soleri/core 9.0.3 → 9.2.0

package/dist/runtime/core-ops.js

@@ -1,1296 +0,0 @@
-/**
- * Generic core operations factory — 209 ops that every agent gets.
- *
- * These ops are agent-agnostic (no persona, no activation).
- * The 5 agent-specific ops (health, identity, activate, inject_claude_md, setup)
- * stay in generated code because they reference agent-specific modules.
- */
-import { z } from 'zod';
-import { createPlanningExtraOps } from './planning-extra-ops.js';
-import { createMemoryExtraOps } from './memory-extra-ops.js';
-import { createVaultExtraOps } from './vault-extra-ops.js';
-import { createAdminOps } from './admin-ops.js';
-import { createAdminExtraOps } from './admin-extra-ops.js';
-import { createLoopOps } from './loop-ops.js';
-import { createOrchestrateOps } from './orchestrate-ops.js';
-import { createGradingOps } from './grading-ops.js';
-import { createCaptureOps } from './capture-ops.js';
-import { createCuratorExtraOps } from './curator-extra-ops.js';
-import { createProjectOps } from './project-ops.js';
-import { createMemoryCrossProjectOps } from './memory-cross-project-ops.js';
-import { createPlaybookOps } from './playbook-ops.js';
-import { createCogneeSyncOps } from './cognee-sync-ops.js';
-import { createIntakeOps } from './intake-ops.js';
-/**
- * Create the 207 generic core operations for an agent runtime.
- *
- * Groups: search/vault (4), memory (4), export (1), planning (5),
- *         brain (8), brain intelligence (11), cognee (5),
- *         llm (2), curator (8), control (8), governance (5),
- *         playbook (5), prompt templates (2),
- *         planning-extra (22), memory-extra (8), vault-extra (23),
- *         admin (8), admin-extra (24), loop (9), orchestrate (5),
- *         grading (5), capture (4), curator-extra (5), project (12),
- *         cognee-sync (3), intake (4).
- */
-export function createCoreOps(runtime) {
-    const { vault, brain, brainIntelligence, planner, curator, governance, cognee, identityManager, intentRouter, llmClient, keyPool, syncManager, intakePipeline, } = runtime;
-    return [
-        // ─── Search / Vault ──────────────────────────────────────────
-        {
-            name: 'search',
-            description: 'Search across all knowledge domains. Results ranked by TF-IDF + severity + recency + tag overlap + domain match.',
-            auth: 'read',
-            schema: z.object({
-                query: z.string(),
-                domain: z.string().optional(),
-                type: z.enum(['pattern', 'anti-pattern', 'rule', 'playbook']).optional(),
-                severity: z.enum(['critical', 'warning', 'suggestion']).optional(),
-                tags: z.array(z.string()).optional(),
-                limit: z.number().optional(),
-            }),
-            handler: async (params) => {
-                return brain.intelligentSearch(params.query, {
-                    domain: params.domain,
-                    type: params.type,
-                    severity: params.severity,
-                    tags: params.tags,
-                    limit: params.limit ?? 10,
-                });
-            },
-        },
-        {
-            name: 'vault_stats',
-            description: 'Get vault statistics — entry counts by type, domain, severity.',
-            auth: 'read',
-            handler: async () => vault.stats(),
-        },
-        {
-            name: 'list_all',
-            description: 'List all knowledge entries with optional filters.',
-            auth: 'read',
-            schema: z.object({
-                domain: z.string().optional(),
-                type: z.enum(['pattern', 'anti-pattern', 'rule', 'playbook']).optional(),
-                severity: z.enum(['critical', 'warning', 'suggestion']).optional(),
-                tags: z.array(z.string()).optional(),
-                limit: z.number().optional(),
-                offset: z.number().optional(),
-            }),
-            handler: async (params) => {
-                return vault.list({
-                    domain: params.domain,
-                    type: params.type,
-                    severity: params.severity,
-                    tags: params.tags,
-                    limit: params.limit ?? 50,
-                    offset: params.offset ?? 0,
-                });
-            },
-        },
-        {
-            name: 'register',
-            description: 'Register a project for this session. Call on every new session to track usage and get context.',
-            auth: 'write',
-            schema: z.object({
-                projectPath: z.string().optional().default('.'),
-                name: z.string().optional().describe('Project display name (derived from path if omitted)'),
-            }),
-            handler: async (params) => {
-                const { resolve } = await import('node:path');
-                const projectPath = resolve(params.projectPath ?? '.');
-                const project = vault.registerProject(projectPath, params.name);
-                // Also track in project registry for cross-project features
-                runtime.projectRegistry.register(projectPath, params.name);
-                const stats = vault.stats();
-                const isNew = project.sessionCount === 1;
-                // Expire stale proposals on session start (fire-and-forget)
-                const policy = governance.getPolicy(projectPath);
-                const expired = governance.expireStaleProposals(policy.autoCapture.autoExpireDays);
-                const proposalStats = governance.getProposalStats(projectPath);
-                const quotaStatus = governance.getQuotaStatus(projectPath);
-                return {
-                    project,
-                    is_new: isNew,
-                    message: isNew
-                        ? 'Welcome! New project registered.'
-                        : 'Welcome back! Session #' + project.sessionCount + ' for ' + project.name + '.',
-                    vault: { entries: stats.totalEntries, domains: Object.keys(stats.byDomain) },
-                    governance: {
-                        pendingProposals: proposalStats.pending,
-                        quotaPercent: quotaStatus.maxTotal > 0
-                            ? Math.round((quotaStatus.total / quotaStatus.maxTotal) * 100)
-                            : 0,
-                        isQuotaWarning: quotaStatus.isWarning,
-                        expiredThisSession: expired,
-                    },
-                };
-            },
-        },
-        // ─── Memory ──────────────────────────────────────────────────
-        {
-            name: 'memory_search',
-            description: 'Search memories using full-text search.',
-            auth: 'read',
-            schema: z.object({
-                query: z.string(),
-                type: z.enum(['session', 'lesson', 'preference']).optional(),
-                projectPath: z.string().optional(),
-                limit: z.number().optional(),
-            }),
-            handler: async (params) => {
-                return vault.searchMemories(params.query, {
-                    type: params.type,
-                    projectPath: params.projectPath,
-                    limit: params.limit ?? 10,
-                });
-            },
-        },
-        {
-            name: 'memory_capture',
-            description: 'Capture a memory — session summary, lesson learned, or preference.',
-            auth: 'write',
-            schema: z.object({
-                projectPath: z.string(),
-                type: z.enum(['session', 'lesson', 'preference']),
-                context: z.string(),
-                summary: z.string(),
-                topics: z.array(z.string()).optional().default([]),
-                filesModified: z.array(z.string()).optional().default([]),
-                toolsUsed: z.array(z.string()).optional().default([]),
-            }),
-            handler: async (params) => {
-                const memory = vault.captureMemory({
-                    projectPath: params.projectPath,
-                    type: params.type,
-                    context: params.context,
-                    summary: params.summary,
-                    topics: params.topics ?? [],
-                    filesModified: params.filesModified ?? [],
-                    toolsUsed: params.toolsUsed ?? [],
-                });
-                return { captured: true, memory };
-            },
-        },
-        {
-            name: 'memory_list',
-            description: 'List memories with optional filters.',
-            auth: 'read',
-            schema: z.object({
-                type: z.enum(['session', 'lesson', 'preference']).optional(),
-                projectPath: z.string().optional(),
-                limit: z.number().optional(),
-                offset: z.number().optional(),
-            }),
-            handler: async (params) => {
-                const memories = vault.listMemories({
-                    type: params.type,
-                    projectPath: params.projectPath,
-                    limit: params.limit ?? 50,
-                    offset: params.offset ?? 0,
-                });
-                const stats = vault.memoryStats();
-                return { memories, stats };
-            },
-        },
-        {
-            name: 'session_capture',
-            description: 'Capture a session summary before context compaction. Called automatically by PreCompact hook.',
-            auth: 'write',
-            schema: z.object({
-                projectPath: z.string().optional().default('.'),
-                summary: z.string().describe('Brief summary of what was accomplished in this session'),
-                topics: z.array(z.string()).optional().default([]),
-                filesModified: z.array(z.string()).optional().default([]),
-                toolsUsed: z.array(z.string()).optional().default([]),
-            }),
-            handler: async (params) => {
-                const { resolve } = await import('node:path');
-                const projectPath = resolve(params.projectPath ?? '.');
-                const memory = vault.captureMemory({
-                    projectPath,
-                    type: 'session',
-                    context: 'Auto-captured before context compaction',
-                    summary: params.summary,
-                    topics: params.topics ?? [],
-                    filesModified: params.filesModified ?? [],
-                    toolsUsed: params.toolsUsed ?? [],
-                });
-                return { captured: true, memory, message: 'Session summary saved to memory.' };
-            },
-        },
-        // ─── Export ───────────────────────────────────────────────────
-        {
-            name: 'export',
-            description: 'Export vault entries as JSON intelligence bundles — one per domain. Enables version control and sharing.',
-            auth: 'read',
-            schema: z.object({
-                domain: z.string().optional().describe('Export only this domain. Omit to export all.'),
-            }),
-            handler: async (params) => {
-                const stats = vault.stats();
-                const domains = params.domain ? [params.domain] : Object.keys(stats.byDomain);
-                const bundles = [];
-                for (const d of domains) {
-                    const entries = vault.list({ domain: d, limit: 10000 });
-                    bundles.push({ domain: d, version: '1.0.0', entries });
-                }
-                return {
-                    exported: true,
-                    bundles,
-                    totalEntries: bundles.reduce((sum, b) => sum + b.entries.length, 0),
-                    domains: bundles.map((b) => b.domain),
-                };
-            },
-        },
-        // ─── Planning ────────────────────────────────────────────────
-        {
-            name: 'create_plan',
-            description: 'Create a new plan in draft status. Plans track multi-step tasks with decisions and sub-tasks.',
-            auth: 'write',
-            schema: z.object({
-                objective: z.string().describe('What the plan aims to achieve'),
-                scope: z.string().describe('Which parts of the codebase are affected'),
-                decisions: z.array(z.string()).optional().default([]),
-                tasks: z
-                    .array(z.object({ title: z.string(), description: z.string() }))
-                    .optional()
-                    .default([]),
-            }),
-            handler: async (params) => {
-                const plan = planner.create({
-                    objective: params.objective,
-                    scope: params.scope,
-                    decisions: params.decisions ?? [],
-                    tasks: params.tasks ?? [],
-                });
-                return { created: true, plan };
-            },
-        },
-        {
-            name: 'get_plan',
-            description: 'Get a plan by ID, or list all active plans if no ID provided.',
-            auth: 'read',
-            schema: z.object({
-                planId: z.string().optional().describe('Plan ID. Omit to list all active plans.'),
-            }),
-            handler: async (params) => {
-                if (params.planId) {
-                    const plan = planner.get(params.planId);
-                    if (!plan)
-                        return { error: 'Plan not found: ' + params.planId };
-                    return plan;
-                }
-                return { active: planner.getActive(), executing: planner.getExecuting() };
-            },
-        },
-        {
-            name: 'approve_plan',
-            description: 'Approve a draft plan and optionally start execution.',
-            auth: 'write',
-            schema: z.object({
-                planId: z.string(),
-                startExecution: z
-                    .boolean()
-                    .optional()
-                    .default(false)
-                    .describe('If true, immediately start execution after approval'),
-            }),
-            handler: async (params) => {
-                let plan = planner.approve(params.planId);
-                if (params.startExecution) {
-                    plan = planner.startExecution(plan.id);
-                }
-                return { approved: true, executing: plan.status === 'executing', plan };
-            },
-        },
-        {
-            name: 'update_task',
-            description: 'Update a task status within an executing plan.',
-            auth: 'write',
-            schema: z.object({
-                planId: z.string(),
-                taskId: z.string(),
-                status: z.enum(['pending', 'in_progress', 'completed', 'skipped', 'failed']),
-            }),
-            handler: async (params) => {
-                const plan = planner.updateTask(params.planId, params.taskId, params.status);
-                const task = plan.tasks.find((t) => t.id === params.taskId);
-                return { updated: true, task, plan: { id: plan.id, status: plan.status } };
-            },
-        },
-        {
-            name: 'complete_plan',
-            description: 'Mark an executing plan as completed.',
-            auth: 'write',
-            schema: z.object({
-                planId: z.string(),
-            }),
-            handler: async (params) => {
-                const plan = planner.complete(params.planId);
-                const taskSummary = {
-                    completed: plan.tasks.filter((t) => t.status === 'completed').length,
-                    skipped: plan.tasks.filter((t) => t.status === 'skipped').length,
-                    failed: plan.tasks.filter((t) => t.status === 'failed').length,
-                    total: plan.tasks.length,
-                };
-                return { completed: true, plan, taskSummary };
-            },
-        },
-        // ─── Brain ───────────────────────────────────────────────────
-        {
-            name: 'record_feedback',
-            description: 'Record feedback on a search result — accepted or dismissed. Used for adaptive weight tuning.',
-            auth: 'write',
-            schema: z.object({
-                query: z.string().describe('The original search query'),
-                entryId: z.string().describe('The entry ID that was accepted or dismissed'),
-                action: z.enum(['accepted', 'dismissed']),
-            }),
-            handler: async (params) => {
-                brain.recordFeedback(params.query, params.entryId, params.action);
-                return {
-                    recorded: true,
-                    query: params.query,
-                    entryId: params.entryId,
-                    action: params.action,
-                };
-            },
-        },
-        {
-            name: 'brain_feedback',
-            description: 'Enhanced feedback with typed actions (accepted/dismissed/modified/failed), source tracking, confidence, duration, and reason.',
-            auth: 'write',
-            schema: z.object({
-                query: z.string().describe('The original search query'),
-                entryId: z.string().describe('The entry ID'),
-                action: z.enum(['accepted', 'dismissed', 'modified', 'failed']),
-                source: z
-                    .enum(['search', 'recommendation', 'tool-execution', 'explicit'])
-                    .optional()
-                    .describe("Feedback source. Default 'search'."),
-                confidence: z.number().optional().describe('Confidence 0-1. Default 0.6.'),
-                duration: z.number().optional().describe('Duration in ms.'),
-                context: z.string().optional().describe("JSON context string. Default '{}'."),
-                reason: z.string().optional().describe('Human-readable reason.'),
-            }),
-            handler: async (params) => {
-                const entry = brain.recordFeedback({
-                    query: params.query,
-                    entryId: params.entryId,
-                    action: params.action,
-                    source: params.source,
-                    confidence: params.confidence,
-                    duration: params.duration,
-                    context: params.context,
-                    reason: params.reason,
-                });
-                return entry;
-            },
-        },
-        {
-            name: 'brain_feedback_stats',
-            description: 'Feedback statistics — counts by action and source, acceptance rate, average confidence.',
-            auth: 'read',
-            handler: async () => {
-                return brain.getFeedbackStats();
-            },
-        },
-        {
-            name: 'rebuild_vocabulary',
-            description: 'Force rebuild the TF-IDF vocabulary from all vault entries.',
-            auth: 'write',
-            handler: async () => {
-                brain.rebuildVocabulary();
-                return { rebuilt: true, vocabularySize: brain.getVocabularySize() };
-            },
-        },
-        {
-            name: 'brain_stats',
-            description: 'Get brain intelligence stats — vocabulary size, feedback count, current scoring weights, intelligence pipeline stats.',
-            auth: 'read',
-            handler: async () => {
-                const base = brain.getStats();
-                const intelligence = brainIntelligence.getStats();
-                return { ...base, intelligence };
-            },
-        },
-        {
-            name: 'brain_decay_report',
-            description: 'Show temporal decay scores for entries matching a query — reveals which entries are expiring, active, or expired.',
-            auth: 'read',
-            schema: z.object({
-                query: z.string().describe('Search query to find entries'),
-                limit: z.number().optional().describe('Max results (default 10)'),
-            }),
-            handler: async (params) => {
-                const results = await brain.getDecayReport(params.query, params.limit ?? 10);
-                return { results, count: results.length };
-            },
-        },
-        {
-            name: 'llm_status',
-            description: 'LLM client status — provider availability, key pool status, model routing config.',
-            auth: 'read',
-            handler: async () => {
-                const available = llmClient.isAvailable();
-                return {
-                    providers: {
-                        openai: {
-                            available: available.openai,
-                            keyPool: keyPool.openai.hasKeys ? keyPool.openai.getStatus() : null,
-                        },
-                        anthropic: {
-                            available: available.anthropic,
-                            keyPool: keyPool.anthropic.hasKeys ? keyPool.anthropic.getStatus() : null,
-                        },
-                    },
-                    routes: llmClient.getRoutes(),
-                };
-            },
-        },
-        // ─── Brain Intelligence ───────────────────────────────────────
-        {
-            name: 'brain_session_context',
-            description: 'Get recent session context — sessions, tool usage frequency, file change frequency.',
-            auth: 'read',
-            schema: z.object({
-                limit: z.number().optional().describe('Number of recent sessions. Default 10.'),
-            }),
-            handler: async (params) => {
-                return brainIntelligence.getSessionContext(params.limit ?? 10);
-            },
-        },
-        {
-            name: 'brain_strengths',
-            description: 'Get pattern strength scores. 4-signal scoring: usage (0-25) + spread (0-25) + success (0-25) + recency (0-25).',
-            auth: 'read',
-            schema: z.object({
-                domain: z.string().optional(),
-                minStrength: z.number().optional().describe('Minimum strength score (0-100).'),
-                limit: z.number().optional(),
-            }),
-            handler: async (params) => {
-                return brainIntelligence.getStrengths({
-                    domain: params.domain,
-                    minStrength: params.minStrength,
-                    limit: params.limit ?? 50,
-                });
-            },
-        },
-        {
-            name: 'brain_global_patterns',
-            description: 'Get cross-domain pattern registry — patterns that appear across multiple domains.',
-            auth: 'read',
-            schema: z.object({
-                limit: z.number().optional(),
-            }),
-            handler: async (params) => {
-                return brainIntelligence.getGlobalPatterns(params.limit ?? 20);
-            },
-        },
-        {
-            name: 'brain_recommend',
-            description: 'Get pattern recommendations for a task context. Matches domain, task terms, and source-specific acceptance rates against known strengths.',
-            auth: 'read',
-            schema: z.object({
-                domain: z.string().optional(),
-                task: z.string().optional().describe('Task description for contextual matching.'),
-                source: z
-                    .string()
-                    .optional()
-                    .describe('Feedback source to boost by (search, recommendation, tool-execution, explicit).'),
-                limit: z.number().optional(),
-            }),
-            handler: async (params) => {
-                return brainIntelligence.recommend({
-                    domain: params.domain,
-                    task: params.task,
-                    source: params.source,
-                    limit: params.limit ?? 5,
-                });
-            },
-        },
-        {
-            name: 'brain_build_intelligence',
-            description: 'Run the full intelligence pipeline: compute strengths → build global registry → build domain profiles.',
-            auth: 'write',
-            handler: async () => {
-                return brainIntelligence.buildIntelligence();
-            },
-        },
-        {
-            name: 'brain_export',
-            description: 'Export all brain intelligence data — strengths, sessions, proposals, global patterns, domain profiles.',
-            auth: 'read',
-            handler: async () => {
-                return brainIntelligence.exportData();
-            },
-        },
-        {
-            name: 'brain_import',
-            description: 'Import brain intelligence data from a previous export.',
-            auth: 'write',
-            schema: z.object({
-                data: z.any().describe('BrainExportData object from brain_export.'),
-            }),
-            handler: async (params) => {
-                return brainIntelligence.importData(params.data);
-            },
-        },
-        {
-            name: 'brain_extract_knowledge',
-            description: 'Extract knowledge proposals from a session using 6 heuristic rules (repeated tools, multi-file edits, long sessions, plan outcomes, feedback ratios).',
-            auth: 'write',
-            schema: z.object({
-                sessionId: z.string().describe('Session ID to extract knowledge from.'),
-            }),
-            handler: async (params) => {
-                return brainIntelligence.extractKnowledge(params.sessionId);
-            },
-        },
-        {
-            name: 'brain_archive_sessions',
-            description: 'Archive (delete) completed sessions older than N days.',
-            auth: 'write',
-            schema: z.object({
-                olderThanDays: z.number().optional().describe('Days threshold. Default 30.'),
-            }),
-            handler: async (params) => {
-                return brainIntelligence.archiveSessions(params.olderThanDays ?? 30);
-            },
-        },
-        {
-            name: 'brain_promote_proposals',
-            description: 'Promote knowledge proposals to vault entries. Creates intelligence entries from auto-extracted patterns. Gated by governance policies.',
-            auth: 'write',
-            schema: z.object({
-                proposalIds: z.array(z.string()).describe('IDs of proposals to promote.'),
-                projectPath: z.string().optional().default('.'),
-            }),
-            handler: async (params) => {
-                const pp = params.projectPath ?? '.';
-                return brainIntelligence.promoteProposals(params.proposalIds, governance, pp);
-            },
-        },
-        {
-            name: 'brain_lifecycle',
-            description: 'Start or end a brain session. Sessions track tool usage, file changes, and plan context.',
-            auth: 'write',
-            schema: z.object({
-                action: z.enum(['start', 'end']),
-                sessionId: z
-                    .string()
-                    .optional()
-                    .describe('Required for end. Auto-generated for start if omitted.'),
-                domain: z.string().optional(),
-                context: z.string().optional(),
-                toolsUsed: z.array(z.string()).optional(),
-                filesModified: z.array(z.string()).optional(),
-                planId: z.string().optional(),
-                planOutcome: z.string().optional(),
-            }),
-            handler: async (params) => {
-                return brainIntelligence.lifecycle({
-                    action: params.action,
-                    sessionId: params.sessionId,
-                    domain: params.domain,
-                    context: params.context,
-                    toolsUsed: params.toolsUsed,
-                    filesModified: params.filesModified,
-                    planId: params.planId,
-                    planOutcome: params.planOutcome,
-                });
-            },
-        },
-        {
-            name: 'brain_reset_extracted',
-            description: 'Reset extraction status on brain sessions, allowing re-extraction. Filter by sessionId, since date, or all.',
-            auth: 'write',
-            schema: z.object({
-                sessionId: z.string().optional().describe('Reset a specific session.'),
-                since: z.string().optional().describe('Reset sessions extracted since this ISO date.'),
-                all: z.boolean().optional().describe('Reset all extracted sessions.'),
-            }),
-            handler: async (params) => {
-                return brainIntelligence.resetExtracted({
-                    sessionId: params.sessionId,
-                    since: params.since,
-                    all: params.all,
-                });
-            },
-        },
-        // ─── Cognee ──────────────────────────────────────────────────
-        {
-            name: 'cognee_status',
-            description: 'Cognee vector search health — availability, URL, latency. Checks the Cognee API endpoint.',
-            auth: 'read',
-            handler: async () => {
-                return cognee.healthCheck();
-            },
-        },
-        {
-            name: 'cognee_search',
-            description: 'Vector similarity search via Cognee. Complements TF-IDF vault search with semantic understanding.',
-            auth: 'read',
-            schema: z.object({
-                query: z.string(),
-                searchType: z
-                    .enum([
-                    'SUMMARIES',
-                    'CHUNKS',
-                    'RAG_COMPLETION',
-                    'TRIPLET_COMPLETION',
-                    'GRAPH_COMPLETION',
-                    'GRAPH_SUMMARY_COMPLETION',
-                    'NATURAL_LANGUAGE',
-                    'GRAPH_COMPLETION_COT',
-                    'FEELING_LUCKY',
-                    'CHUNKS_LEXICAL',
-                ])
-                    .optional()
-                    .describe('Cognee search type. Default CHUNKS (pure vector similarity).'),
-                limit: z.number().optional(),
-            }),
-            handler: async (params) => {
-                return cognee.search(params.query, {
-                    searchType: params.searchType,
-                    limit: params.limit ?? 10,
-                });
-            },
-        },
-        {
-            name: 'cognee_add',
-            description: 'Ingest vault entries into Cognee for vector indexing. Auto-schedules cognify after ingest.',
-            auth: 'write',
-            schema: z.object({
-                entryIds: z.array(z.string()).describe('Vault entry IDs to ingest into Cognee.'),
-            }),
-            handler: async (params) => {
-                const ids = params.entryIds;
-                const entries = ids
-                    .map((id) => vault.get(id))
-                    .filter((e) => e !== null && e !== undefined);
-                if (entries.length === 0)
-                    return { added: 0, error: 'No matching vault entries found' };
-                return cognee.addEntries(entries);
-            },
-        },
-        {
-            name: 'cognee_cognify',
-            description: 'Trigger Cognee knowledge graph processing on the vault dataset. Usually auto-scheduled after add.',
-            auth: 'write',
-            handler: async () => {
-                return cognee.cognify();
-            },
-        },
-        {
-            name: 'cognee_config',
-            description: 'Get current Cognee client configuration and cached health status.',
-            auth: 'read',
-            handler: async () => {
-                return { config: cognee.getConfig(), cachedStatus: cognee.getStatus() };
-            },
-        },
-        // ─── Cognee Graph (#156) ──────────────────────────────────────
-        {
-            name: 'cognee_get_node',
-            description: 'Get a specific Cognee graph node by UUID with all properties and connections.',
-            auth: 'read',
-            schema: z.object({
-                nodeId: z.string().describe('UUID of the graph node'),
-            }),
-            handler: async (params) => {
-                try {
-                    // Use Cognee search with specific ID query — the graph node API is accessed via search
-                    const results = await cognee.search(params.nodeId, {
-                        searchType: 'GRAPH_COMPLETION',
-                        limit: 1,
-                    });
-                    if (!results || (Array.isArray(results) && results.length === 0)) {
-                        return { found: false, nodeId: params.nodeId };
-                    }
-                    return {
-                        found: true,
-                        nodeId: params.nodeId,
-                        node: Array.isArray(results) ? results[0] : results,
-                    };
-                }
-                catch (err) {
-                    return { error: err.message };
-                }
-            },
-        },
-        {
-            name: 'cognee_graph_stats',
-            description: 'Cognee graph statistics — availability, endpoint, latency from last health check.',
-            auth: 'read',
-            handler: async () => {
-                try {
-                    const status = cognee.getStatus();
-                    const health = await cognee.healthCheck();
-                    return {
-                        available: status?.available ?? false,
-                        url: status?.url ?? cognee.getConfig().baseUrl,
-                        latencyMs: status?.latencyMs ?? health.latencyMs ?? null,
-                        error: status?.error ?? health.error ?? null,
-                    };
-                }
-                catch (err) {
-                    return { error: err.message };
-                }
-            },
-        },
-        {
-            name: 'cognee_export_status',
-            description: 'Check Cognee dataset and processing status — availability, pending operations.',
-            auth: 'read',
-            handler: async () => {
-                try {
-                    const status = cognee.getStatus();
-                    const config = cognee.getConfig();
-                    return {
-                        available: status?.available ?? false,
-                        dataset: config.dataset ?? 'default',
-                        pendingCognify: false, // CogneeClient tracks internally via flushPendingCognify
-                        url: status?.url ?? config.baseUrl,
-                    };
-                }
-                catch (err) {
-                    return { error: err.message };
-                }
-            },
-        },
-        // ─── Enriched Capture (#154) ─────────────────────────────────
-        {
-            name: 'capture_enriched',
-            description: 'Unified LLM-enriched capture — accepts minimal fields (title, description, type), uses LLM to auto-infer tags, category, and severity.',
-            auth: 'write',
-            schema: z.object({
-                title: z.string().describe('Knowledge title'),
-                description: z.string().describe('Knowledge description'),
-                type: z
-                    .enum(['pattern', 'anti-pattern', 'rule', 'playbook'])
-                    .optional()
-                    .describe('Entry type. If omitted, LLM infers from content.'),
-                domain: z.string().optional().describe('Domain. If omitted, LLM infers.'),
-                tags: z.array(z.string()).optional().describe('Tags. LLM adds more if needed.'),
-            }),
-            handler: async (params) => {
-                try {
-                    const title = params.title;
-                    const description = params.description;
-                    // Try LLM enrichment for auto-tagging
-                    let inferredTags = params.tags ?? [];
-                    let inferredType = params.type ?? 'pattern';
-                    const inferredDomain = params.domain ?? 'general';
-                    let inferredSeverity = 'suggestion';
-                    const enriched = false;
-                    try {
-                        const captureId = `enriched-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
-                        const enrichResult = brain.enrichAndCapture({
-                            id: captureId,
-                            title,
-                            description,
-                            type: inferredType,
-                            domain: inferredDomain,
-                            severity: inferredSeverity,
-                            tags: inferredTags,
-                        });
-                        if (enrichResult.captured) {
-                            return {
-                                captured: true,
-                                enriched: true,
-                                entryId: enrichResult.id,
-                                autoTags: enrichResult.autoTags,
-                                duplicate: enrichResult.duplicate ?? null,
-                            };
-                        }
-                    }
-                    catch {
-                        // LLM enrichment failed — fall back to basic capture
-                    }
-                    // Fallback: basic capture without LLM enrichment
-                    // Infer type from keywords
-                    const lowerDesc = description.toLowerCase();
-                    if (!params.type) {
-                        if (lowerDesc.includes('avoid') ||
-                            lowerDesc.includes("don't") ||
-                            lowerDesc.includes('anti-pattern'))
-                            inferredType = 'anti-pattern';
-                        else if (lowerDesc.includes('rule') ||
-                            lowerDesc.includes('must') ||
-                            lowerDesc.includes('always'))
-                            inferredType = 'rule';
-                    }
-                    // Infer severity from keywords
-                    if (lowerDesc.includes('critical') ||
-                        lowerDesc.includes('security') ||
-                        lowerDesc.includes('breaking'))
-                        inferredSeverity = 'critical';
-                    else if (lowerDesc.includes('warning') ||
-                        lowerDesc.includes('careful') ||
-                        lowerDesc.includes('avoid'))
-                        inferredSeverity = 'warning';
-                    // Auto-generate tags from title words
-                    if (inferredTags.length === 0) {
-                        inferredTags = title
-                            .toLowerCase()
-                            .split(/\s+/)
-                            .filter((w) => w.length > 3 && !['with', 'from', 'that', 'this', 'have', 'been'].includes(w))
-                            .slice(0, 5);
-                    }
-                    const entry = {
-                        id: `enriched-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
-                        type: inferredType,
-                        domain: inferredDomain,
-                        title,
-                        severity: inferredSeverity,
-                        description,
-                        tags: inferredTags,
-                    };
-                    vault.add(entry);
-                    return {
-                        captured: true,
-                        enriched,
-                        entry,
-                        autoTags: inferredTags,
-                    };
-                }
-                catch (err) {
-                    return { error: err.message };
-                }
-            },
-        },
-        // ─── LLM ─────────────────────────────────────────────────────
-        {
-            name: 'llm_rotate',
-            description: 'Force rotate the active API key for a provider. Useful when rate-limited or key is failing.',
-            auth: 'write',
-            schema: z.object({
-                provider: z.enum(['openai', 'anthropic']),
-            }),
-            handler: async (params) => {
-                const provider = params.provider;
-                const pool = keyPool[provider];
-                if (!pool.hasKeys)
-                    return { rotated: false, error: `No ${provider} keys configured` };
-                const newKey = pool.rotateOnError();
-                return {
-                    rotated: newKey !== null,
-                    activeKeyIndex: pool.activeKeyIndex,
-                    poolSize: pool.poolSize,
-                    exhausted: pool.exhausted,
-                };
-            },
-        },
-        {
-            name: 'llm_call',
-            description: 'Make an LLM completion call. Uses model routing config and key pool rotation.',
-            auth: 'write',
-            schema: z.object({
-                systemPrompt: z.string().describe('System prompt for the LLM.'),
-                userPrompt: z.string().describe('User prompt / task input.'),
-                model: z
-                    .string()
-                    .optional()
-                    .describe('Model name. Routed via model-routing.json if omitted.'),
-                temperature: z.number().optional().describe('Sampling temperature (0-2). Default 0.3.'),
-                maxTokens: z.number().optional().describe('Max output tokens. Default 500.'),
-                caller: z.string().optional().describe('Caller name for routing. Default "core-ops".'),
-                task: z.string().optional().describe('Task name for routing.'),
-            }),
-            handler: async (params) => {
-                return llmClient.complete({
-                    provider: 'openai',
-                    model: params.model ?? '',
-                    systemPrompt: params.systemPrompt,
-                    userPrompt: params.userPrompt,
-                    temperature: params.temperature,
-                    maxTokens: params.maxTokens,
-                    caller: params.caller ?? 'core-ops',
-                    task: params.task,
-                });
-            },
-        },
-        // ─── Curator ─────────────────────────────────────────────────
-        {
-            name: 'curator_status',
-            description: 'Curator status — table row counts, last groomed timestamp.',
-            auth: 'read',
-            handler: async () => {
-                return curator.getStatus();
-            },
-        },
-        {
-            name: 'curator_detect_duplicates',
-            description: 'Detect duplicate entries using TF-IDF cosine similarity.',
-            auth: 'read',
-            schema: z.object({
-                entryId: z.string().optional().describe('Check a specific entry. Omit to scan all.'),
-                threshold: z.number().optional().describe('Similarity threshold (0-1). Default 0.45.'),
-            }),
-            handler: async (params) => {
-                return curator.detectDuplicates(params.entryId, params.threshold);
-            },
-        },
-        {
-            name: 'curator_contradictions',
-            description: 'List or detect contradictions between patterns and anti-patterns.',
-            auth: 'read',
-            schema: z.object({
-                status: z.enum(['open', 'resolved', 'dismissed']).optional().describe('Filter by status.'),
-                detect: z.boolean().optional().describe('If true, run detection before listing.'),
-            }),
-            handler: async (params) => {
-                if (params.detect) {
-                    curator.detectContradictions();
-                }
-                return curator.getContradictions(params.status);
-            },
-        },
-        {
-            name: 'curator_resolve_contradiction',
-            description: 'Resolve or dismiss a contradiction.',
-            auth: 'write',
-            schema: z.object({
-                id: z.number().describe('Contradiction ID.'),
-                resolution: z.enum(['resolved', 'dismissed']),
-            }),
-            handler: async (params) => {
-                return curator.resolveContradiction(params.id, params.resolution);
-            },
-        },
-        {
-            name: 'curator_groom',
-            description: 'Groom a single entry — normalize tags, check staleness.',
-            auth: 'write',
-            schema: z.object({
-                entryId: z.string().describe('Entry ID to groom.'),
-            }),
-            handler: async (params) => {
-                return curator.groomEntry(params.entryId);
-            },
-        },
-        {
-            name: 'curator_groom_all',
-            description: 'Groom all vault entries — normalize tags, detect staleness.',
-            auth: 'write',
-            handler: async () => {
-                return curator.groomAll();
-            },
-        },
-        {
-            name: 'curator_consolidate',
-            description: 'Consolidate vault — find duplicates, stale entries, contradictions. Dry-run by default.',
-            auth: 'write',
-            schema: z.object({
-                dryRun: z.boolean().optional().describe('Default true. Set false to apply mutations.'),
-                staleDaysThreshold: z
-                    .number()
-                    .optional()
-                    .describe('Days before entry is stale. Default 90.'),
-                duplicateThreshold: z
-                    .number()
-                    .optional()
-                    .describe('Cosine similarity threshold. Default 0.45.'),
-                contradictionThreshold: z
-                    .number()
-                    .optional()
-                    .describe('Contradiction threshold. Default 0.4.'),
-            }),
-            handler: async (params) => {
-                return curator.consolidate({
-                    dryRun: params.dryRun,
-                    staleDaysThreshold: params.staleDaysThreshold,
-                    duplicateThreshold: params.duplicateThreshold,
-                    contradictionThreshold: params.contradictionThreshold,
-                });
-            },
-        },
-        {
-            name: 'curator_health_audit',
-            description: 'Audit vault health — score (0-100), coverage, freshness, quality, tag health, recommendations.',
-            auth: 'read',
-            handler: async () => {
-                return curator.healthAudit();
-            },
-        },
-        // ─── Control ──────────────────────────────────────────────────────
-        {
-            name: 'get_identity',
-            description: 'Get current agent identity with guidelines.',
-            auth: 'read',
-            schema: z.object({
-                agentId: z.string().describe('Agent identifier.'),
-            }),
-            handler: async (params) => {
-                const identity = identityManager.getIdentity(params.agentId);
-                if (!identity)
-                    return { found: false, agentId: params.agentId };
-                return identity;
-            },
-        },
-        {
-            name: 'update_identity',
-            description: 'Update identity fields. Auto-versions and snapshots previous state.',
-            auth: 'write',
-            schema: z.object({
-                agentId: z.string(),
-                name: z.string().optional(),
-                role: z.string().optional(),
-                description: z.string().optional(),
-                personality: z.array(z.string()).optional(),
-                changedBy: z.string().optional(),
-                changeReason: z.string().optional(),
-            }),
-            handler: async (params) => {
-                const identity = identityManager.setIdentity(params.agentId, {
-                    name: params.name,
-                    role: params.role,
-                    description: params.description,
-                    personality: params.personality,
-                    changedBy: params.changedBy,
-                    changeReason: params.changeReason,
-                });
-                return { updated: true, identity };
-            },
-        },
-        {
-            name: 'add_guideline',
-            description: 'Add a behavioral guideline (behavior/preference/restriction/style).',
-            auth: 'write',
-            schema: z.object({
-                agentId: z.string(),
-                category: z.enum(['behavior', 'preference', 'restriction', 'style']),
-                text: z.string(),
-                priority: z.number().optional(),
-            }),
-            handler: async (params) => {
-                const guideline = identityManager.addGuideline(params.agentId, {
-                    category: params.category,
-                    text: params.text,
-                    priority: params.priority,
-                });
-                return { added: true, guideline };
-            },
-        },
-        {
-            name: 'remove_guideline',
-            description: 'Remove a guideline by ID.',
-            auth: 'write',
-            schema: z.object({
-                guidelineId: z.string(),
-            }),
-            handler: async (params) => {
-                const removed = identityManager.removeGuideline(params.guidelineId);
-                return { removed };
-            },
-        },
-        {
-            name: 'rollback_identity',
-            description: 'Restore a previous identity version. Creates a new version with the old data.',
-            auth: 'write',
-            schema: z.object({
-                agentId: z.string(),
-                version: z.number().describe('Version number to roll back to.'),
-            }),
-            handler: async (params) => {
-                const identity = identityManager.rollback(params.agentId, params.version);
-                return { rolledBack: true, identity };
-            },
-        },
-        {
-            name: 'route_intent',
-            description: 'Classify a prompt into intent + operational mode via keyword matching.',
-            auth: 'read',
-            schema: z.object({
-                prompt: z.string().describe('The user prompt to classify.'),
-            }),
-            handler: async (params) => {
-                return intentRouter.routeIntent(params.prompt);
-            },
-        },
-        {
-            name: 'morph',
-            description: 'Switch operational mode manually.',
-            auth: 'write',
-            schema: z.object({
-                mode: z
-                    .string()
-                    .describe('The operational mode to switch to (e.g., BUILD-MODE, FIX-MODE).'),
-            }),
-            handler: async (params) => {
-                return intentRouter.morph(params.mode);
-            },
-        },
-        {
-            name: 'get_behavior_rules',
-            description: 'Get behavior rules for current or specified mode.',
-            auth: 'read',
-            schema: z.object({
-                mode: z.string().optional().describe('Mode to get rules for. Defaults to current mode.'),
-            }),
-            handler: async (params) => {
-                const mode = params.mode;
-                const rules = intentRouter.getBehaviorRules(mode);
-                const currentMode = intentRouter.getCurrentMode();
-                return { mode: mode ?? currentMode, rules };
-            },
-        },
-        // ─── Governance ─────────────────────────────────────────────────
-        {
-            name: 'governance_policy',
-            description: 'Get, set, or apply a preset to vault governance policies (quota, retention, auto-capture).',
-            auth: 'write',
-            schema: z.object({
-                action: z.enum(['get', 'set', 'applyPreset']),
-                projectPath: z.string(),
-                policyType: z.enum(['quota', 'retention', 'auto-capture']).optional(),
-                config: z.record(z.unknown()).optional(),
-                preset: z.enum(['strict', 'moderate', 'permissive']).optional(),
-                changedBy: z.string().optional(),
-            }),
-            handler: async (params) => {
-                const action = params.action;
-                const projectPath = params.projectPath;
-                if (action === 'get') {
-                    return governance.getPolicy(projectPath);
-                }
-                if (action === 'set') {
-                    governance.setPolicy(projectPath, params.policyType, params.config, params.changedBy);
-                    return { updated: true, policy: governance.getPolicy(projectPath) };
-                }
-                if (action === 'applyPreset') {
-                    governance.applyPreset(projectPath, params.preset, params.changedBy);
-                    return {
-                        applied: true,
-                        preset: params.preset,
-                        policy: governance.getPolicy(projectPath),
-                    };
-                }
-                return { error: 'Unknown action: ' + action };
-            },
-        },
-        {
-            name: 'governance_proposals',
-            description: 'Manage knowledge capture proposals — list, approve, reject, modify, get stats, or expire stale.',
-            auth: 'write',
-            schema: z.object({
-                action: z.enum(['list', 'approve', 'reject', 'modify', 'stats', 'expire']),
-                projectPath: z.string().optional(),
-                proposalId: z.number().optional(),
-                decidedBy: z.string().optional(),
-                note: z.string().optional(),
-                modifications: z.record(z.unknown()).optional(),
-                maxAgeDays: z.number().optional(),
-                limit: z.number().optional(),
-            }),
-            handler: async (params) => {
-                const action = params.action;
-                if (action === 'list') {
-                    return governance.listPendingProposals(params.projectPath, params.limit);
-                }
-                if (action === 'approve') {
-                    return governance.approveProposal(params.proposalId, params.decidedBy);
-                }
-                if (action === 'reject') {
-                    return governance.rejectProposal(params.proposalId, params.decidedBy, params.note);
-                }
-                if (action === 'modify') {
-                    return governance.modifyProposal(params.proposalId, params.modifications, params.decidedBy);
-                }
-                if (action === 'stats') {
-                    return governance.getProposalStats(params.projectPath);
-                }
-                if (action === 'expire') {
-                    const expired = governance.expireStaleProposals(params.maxAgeDays);
-                    return { expired };
-                }
-                return { error: 'Unknown action: ' + action };
-            },
-        },
-        {
-            name: 'governance_stats',
-            description: 'Get governance statistics — quota status and proposal stats for a project.',
-            auth: 'read',
-            schema: z.object({
-                projectPath: z.string(),
-            }),
-            handler: async (params) => {
-                const projectPath = params.projectPath;
-                return {
-                    quotaStatus: governance.getQuotaStatus(projectPath),
-                    proposalStats: governance.getProposalStats(projectPath),
-                };
-            },
-        },
-        {
-            name: 'governance_expire',
-            description: 'Expire stale pending proposals older than a threshold.',
-            auth: 'write',
-            schema: z.object({
-                projectPath: z.string().optional(),
-                maxAgeDays: z.number().optional().describe('Days threshold. Default 14.'),
-            }),
-            handler: async (params) => {
-                const expired = governance.expireStaleProposals(params.maxAgeDays);
-                return { expired };
-            },
-        },
-        {
-            name: 'governance_dashboard',
-            description: 'Get governance dashboard — vault size, quota usage, pending proposals, acceptance rate, evaluation trend.',
-            auth: 'read',
-            schema: z.object({
-                projectPath: z.string(),
-            }),
-            handler: async (params) => {
-                return governance.getDashboard(params.projectPath);
-            },
-        },
-        // ─── Playbook ops (from dedicated module) ─────────────────────────
-        ...createPlaybookOps(runtime),
-        // ─── Extra Ops (from dedicated modules) ─────────────────────────
-        ...createPlanningExtraOps(runtime),
-        ...createMemoryExtraOps(runtime),
-        ...createVaultExtraOps(runtime),
-        ...createAdminOps(runtime),
-        ...createAdminExtraOps(runtime),
-        ...createLoopOps(runtime),
-        ...createOrchestrateOps(runtime),
-        ...createGradingOps(runtime),
-        ...createCaptureOps(runtime),
-        ...createCuratorExtraOps(runtime),
-        ...createProjectOps(runtime),
-        ...createMemoryCrossProjectOps(runtime),
-        // ─── Cognee Sync ──────────────────────────────────────────────
-        ...createCogneeSyncOps(syncManager),
-        // ─── Intake Pipeline ──────────────────────────────────────────
-        ...createIntakeOps(intakePipeline),
-        // ─── Prompt Templates ─────────────────────────────────────────
-        {
-            name: 'render_prompt',
-            description: 'Render a prompt template with variable substitution. Templates are .prompt files loaded from the templates directory.',
-            auth: 'read',
-            schema: z.object({
-                template: z.string().describe('Template name (without .prompt extension)'),
-                variables: z.record(z.string()).optional().default({}),
-                strict: z.boolean().optional().default(true),
-            }),
-            handler: async (params) => {
-                const rendered = runtime.templateManager.render(params.template, (params.variables ?? {}), { strict: params.strict });
-                return { rendered };
-            },
-        },
-        {
-            name: 'list_templates',
-            description: 'List all loaded prompt templates.',
-            auth: 'read',
-            handler: async () => ({
-                templates: runtime.templateManager.listTemplates(),
-            }),
-        },
-    ];
-}
-//# sourceMappingURL=core-ops.js.map