@soleri/core 2.0.2 → 2.4.0

package/dist/runtime/core-ops.js

@@ -1,19 +1,35 @@
 /**
- * Generic core operations factory — 26 ops that every agent gets.
+ * Generic core operations factory — 147 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';
 /**
- * Create the 26 generic core operations for an agent runtime.
+ * Create the 147 generic core operations for an agent runtime.
  *
  * Groups: search/vault (4), memory (4), export (1), planning (5),
- *         brain (4), curator (8).
+ *         brain (7), brain intelligence (11), cognee (5),
+ *         llm (2), curator (8), control (8), governance (5),
+ *         planning-extra (9), memory-extra (8), vault-extra (12),
+ *         admin (8), admin-extra (10), loop (7), orchestrate (5),
+ *         grading (5), capture (4), curator-extra (4), project (12).
  */
 export function createCoreOps(runtime) {
-    const { vault, brain, planner, curator, llmClient, keyPool } = runtime;
+    const { vault, brain, brainIntelligence, planner, curator, governance, cognee, identityManager, intentRouter, llmClient, keyPool, } = runtime;
     return [
         // ─── Search / Vault ──────────────────────────────────────────
         {
@@ -79,8 +95,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 +111,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,
+                    },
                 };
             },
         },
@@ -193,9 +224,7 @@ export function createCoreOps(runtime) {
             }),
             handler: async (params) => {
                 const stats = vault.stats();
-                const domains = params.domain
-                    ? [params.domain]
-                    : Object.keys(stats.byDomain);
+                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 });
@@ -218,7 +247,10 @@ export function createCoreOps(runtime) {
                 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([]),
+                tasks: z
+                    .array(z.object({ title: z.string(), description: z.string() }))
+                    .optional()
+                    .default([]),
             }),
             handler: async (params) => {
                 const plan = planner.create({
@@ -253,7 +285,11 @@ export function createCoreOps(runtime) {
             auth: 'write',
             schema: z.object({
                 planId: z.string(),
-                startExecution: z.boolean().optional().default(false).describe('If true, immediately start execution after approval'),
+                startExecution: z
+                    .boolean()
+                    .optional()
+                    .default(false)
+                    .describe('If true, immediately start execution after approval'),
             }),
             handler: async (params) => {
                 let plan = planner.approve(params.planId);
@@ -308,7 +344,51 @@ export function createCoreOps(runtime) {
             }),
             handler: async (params) => {
                 brain.recordFeedback(params.query, params.entryId, params.action);
-                return { recorded: true, query: params.query, entryId: params.entryId, action: 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();
             },
         },
         {
@@ -322,10 +402,12 @@ export function createCoreOps(runtime) {
         },
         {
             name: 'brain_stats',
-            description: 'Get brain intelligence stats — vocabulary size, feedback count, current scoring weights.',
+            description: 'Get brain intelligence stats — vocabulary size, feedback count, current scoring weights, intelligence pipeline stats.',
             auth: 'read',
             handler: async () => {
-                return brain.getStats();
+                const base = brain.getStats();
+                const intelligence = brainIntelligence.getStats();
+                return { ...base, intelligence };
             },
         },
         {
@@ -349,6 +431,300 @@ export function createCoreOps(runtime) {
                 };
             },
         },
+        // ─── 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() };
+            },
+        },
+        // ─── 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',
@@ -422,9 +798,18 @@ export function createCoreOps(runtime) {
             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.'),
+                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({
@@ -443,6 +828,252 @@ 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);
+            },
+        },
+        // ─── 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),
     ];
 }
 //# sourceMappingURL=core-ops.js.map