@soleri/core 2.1.0 → 2.5.0

package/dist/runtime/core-ops.js

@@ -1,19 +1,40 @@
 /**
- * Generic core operations factory — 37 ops that every agent gets.
+ * Generic core operations factory — 158 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 37 generic core operations for an agent runtime.
+ * Create the 203 generic core operations for an agent runtime.
  *
  * Groups: search/vault (4), memory (4), export (1), planning (5),
- *         brain (4), brain intelligence (11), curator (8).
+ *         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 (20),
+ *         admin (8), admin-extra (23), 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, llmClient, keyPool } = runtime;
+    const { vault, brain, brainIntelligence, planner, curator, governance, cognee, identityManager, intentRouter, llmClient, keyPool, syncManager, intakePipeline, } = runtime;
     return [
         // ─── Search / Vault ──────────────────────────────────────────
         {
@@ -23,7 +44,7 @@ export function createCoreOps(runtime) {
             schema: z.object({
                 query: z.string(),
                 domain: z.string().optional(),
-                type: z.enum(['pattern', 'anti-pattern', 'rule']).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(),
@@ -50,7 +71,7 @@ export function createCoreOps(runtime) {
             auth: 'read',
             schema: z.object({
                 domain: z.string().optional(),
-                type: z.enum(['pattern', 'anti-pattern', 'rule']).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(),
@@ -79,8 +100,15 @@ export function createCoreOps(runtime) {
                 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,
@@ -88,6 +116,14 @@ export function createCoreOps(runtime) {
                         ? '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,
+                    },
                 };
             },
         },
@@ -321,6 +357,45 @@ export function createCoreOps(runtime) {
                 };
             },
         },
+        {
+            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.',
@@ -340,6 +415,19 @@ export function createCoreOps(runtime) {
                 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.',
@@ -403,17 +491,22 @@ export function createCoreOps(runtime) {
         },
         {
             name: 'brain_recommend',
-            description: 'Get pattern recommendations for a task context. Matches domain and task terms against known strengths.',
+            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,
                 });
             },
@@ -469,13 +562,15 @@ export function createCoreOps(runtime) {
         },
         {
             name: 'brain_promote_proposals',
-            description: 'Promote knowledge proposals to vault entries. Creates intelligence entries from auto-extracted patterns.',
+            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) => {
-                return brainIntelligence.promoteProposals(params.proposalIds);
+                const pp = params.projectPath ?? '.';
+                return brainIntelligence.promoteProposals(params.proposalIds, governance, pp);
             },
         },
         {
@@ -484,7 +579,10 @@ export function createCoreOps(runtime) {
             auth: 'write',
             schema: z.object({
                 action: z.enum(['start', 'end']),
-                sessionId: z.string().optional().describe('Required for end. Auto-generated for start if omitted.'),
+                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(),
@@ -505,6 +603,316 @@ export function createCoreOps(runtime) {
                 });
             },
         },
+        {
+            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',
@@ -608,6 +1016,281 @@ export function createCoreOps(runtime) {
                 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