@soleri/core 2.0.2 → 2.4.0

package/src/runtime/core-ops.ts

@@ -1,5 +1,5 @@
 /**
- * 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)
@@ -10,21 +10,53 @@ import { z } from 'zod';
 import type { OpDefinition } from '../facades/types.js';
 import type { IntelligenceEntry } from '../intelligence/types.js';
 import type { AgentRuntime } from './types.js';
+import type { GuidelineCategory, OperationalMode } from '../control/types.js';
+import type { PolicyType, PolicyPreset } from '../governance/types.js';
+import type { CogneeSearchType } from '../cognee/types.js';
+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: AgentRuntime): OpDefinition[] {
-  const { vault, brain, planner, curator, llmClient, keyPool } = runtime;
+  const {
+    vault,
+    brain,
+    brainIntelligence,
+    planner,
+    curator,
+    governance,
+    cognee,
+    identityManager,
+    intentRouter,
+    llmClient,
+    keyPool,
+  } = runtime;
 
   return [
     // ─── Search / Vault ──────────────────────────────────────────
     {
       name: 'search',
-      description: 'Search across all knowledge domains. Results ranked by TF-IDF + severity + recency + tag overlap + domain match.',
+      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(),
@@ -75,7 +107,8 @@ export function createCoreOps(runtime: AgentRuntime): OpDefinition[] {
     },
     {
       name: 'register',
-      description: 'Register a project for this session. Call on every new session to track usage and get context.',
+      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('.'),
@@ -85,9 +118,18 @@ export function createCoreOps(runtime: AgentRuntime): OpDefinition[] {
         const { resolve } = await import('node:path');
         const projectPath = resolve((params.projectPath as string) ?? '.');
         const project = vault.registerProject(projectPath, params.name as string | undefined);
+        // Also track in project registry for cross-project features
+        runtime.projectRegistry.register(projectPath, params.name as string | undefined);
         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,
@@ -95,6 +137,15 @@ export function createCoreOps(runtime: AgentRuntime): OpDefinition[] {
             ? '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,
+          },
         };
       },
     },
@@ -167,7 +218,8 @@ export function createCoreOps(runtime: AgentRuntime): OpDefinition[] {
     },
     {
       name: 'session_capture',
-      description: 'Capture a session summary before context compaction. Called automatically by PreCompact hook.',
+      description:
+        'Capture a session summary before context compaction. Called automatically by PreCompact hook.',
       auth: 'write',
       schema: z.object({
         projectPath: z.string().optional().default('.'),
@@ -195,17 +247,17 @@ export function createCoreOps(runtime: AgentRuntime): OpDefinition[] {
     // ─── Export ───────────────────────────────────────────────────
     {
       name: 'export',
-      description: 'Export vault entries as JSON intelligence bundles — one per domain. Enables version control and sharing.',
+      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 as string]
-          : Object.keys(stats.byDomain);
-        const bundles: Array<{ domain: string; version: string; entries: IntelligenceEntry[] }> = [];
+        const domains = params.domain ? [params.domain as string] : Object.keys(stats.byDomain);
+        const bundles: Array<{ domain: string; version: string; entries: IntelligenceEntry[] }> =
+          [];
         for (const d of domains) {
           const entries = vault.list({ domain: d, limit: 10000 });
           bundles.push({ domain: d, version: '1.0.0', entries });
@@ -222,13 +274,17 @@ export function createCoreOps(runtime: AgentRuntime): OpDefinition[] {
     // ─── Planning ────────────────────────────────────────────────
     {
       name: 'create_plan',
-      description: 'Create a new plan in draft status. Plans track multi-step tasks with decisions and sub-tasks.',
+      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([]),
+        tasks: z
+          .array(z.object({ title: z.string(), description: z.string() }))
+          .optional()
+          .default([]),
       }),
       handler: async (params) => {
         const plan = planner.create({
@@ -262,7 +318,11 @@ export function createCoreOps(runtime: AgentRuntime): OpDefinition[] {
       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 as string);
@@ -313,7 +373,8 @@ export function createCoreOps(runtime: AgentRuntime): OpDefinition[] {
     // ─── Brain ───────────────────────────────────────────────────
     {
       name: 'record_feedback',
-      description: 'Record feedback on a search result — accepted or dismissed. Used for adaptive weight tuning.',
+      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'),
@@ -326,7 +387,58 @@ export function createCoreOps(runtime: AgentRuntime): OpDefinition[] {
           params.entryId as string,
           params.action as 'accepted' | 'dismissed',
         );
-        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 as string,
+          entryId: params.entryId as string,
+          action: params.action as 'accepted' | 'dismissed' | 'modified' | 'failed',
+          source: params.source as
+            | 'search'
+            | 'recommendation'
+            | 'tool-execution'
+            | 'explicit'
+            | undefined,
+          confidence: params.confidence as number | undefined,
+          duration: params.duration as number | undefined,
+          context: params.context as string | undefined,
+          reason: params.reason as string | undefined,
+        });
+        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();
       },
     },
     {
@@ -340,15 +452,19 @@ export function createCoreOps(runtime: AgentRuntime): OpDefinition[] {
     },
     {
       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 };
       },
     },
     {
       name: 'llm_status',
-      description: 'LLM client status — provider availability, key pool status, model routing config.',
+      description:
+        'LLM client status — provider availability, key pool status, model routing config.',
       auth: 'read',
       handler: async () => {
         const available = llmClient.isAvailable();
@@ -368,6 +484,321 @@ export function createCoreOps(runtime: AgentRuntime): OpDefinition[] {
       },
     },
 
+    // ─── 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 as number) ?? 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 as string | undefined,
+          minStrength: params.minStrength as number | undefined,
+          limit: (params.limit as number) ?? 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 as number) ?? 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 as string | undefined,
+          task: params.task as string | undefined,
+          source: params.source as string | undefined,
+          limit: (params.limit as number) ?? 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 as import('../brain/types.js').BrainExportData,
+        );
+      },
+    },
+    {
+      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 as string);
+      },
+    },
+    {
+      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 as number) ?? 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 as string | undefined) ?? '.';
+        return brainIntelligence.promoteProposals(params.proposalIds as string[], 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 as 'start' | 'end',
+          sessionId: params.sessionId as string | undefined,
+          domain: params.domain as string | undefined,
+          context: params.context as string | undefined,
+          toolsUsed: params.toolsUsed as string[] | undefined,
+          filesModified: params.filesModified as string[] | undefined,
+          planId: params.planId as string | undefined,
+          planOutcome: params.planOutcome as string | undefined,
+        });
+      },
+    },
+
+    {
+      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 as string | undefined,
+          since: params.since as string | undefined,
+          all: params.all as boolean | undefined,
+        });
+      },
+    },
+
+    // ─── 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 as string, {
+          searchType: params.searchType as CogneeSearchType | undefined,
+          limit: (params.limit as number) ?? 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 as string[];
+        const entries = ids
+          .map((id) => vault.get(id))
+          .filter((e): e is IntelligenceEntry => 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 as 'openai' | 'anthropic';
+        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 as string) ?? '',
+          systemPrompt: params.systemPrompt as string,
+          userPrompt: params.userPrompt as string,
+          temperature: params.temperature as number | undefined,
+          maxTokens: params.maxTokens as number | undefined,
+          caller: (params.caller as string) ?? 'core-ops',
+          task: params.task as string | undefined,
+        });
+      },
+    },
+
     // ─── Curator ─────────────────────────────────────────────────
     {
       name: 'curator_status',
@@ -404,7 +835,9 @@ export function createCoreOps(runtime: AgentRuntime): OpDefinition[] {
         if (params.detect) {
           curator.detectContradictions();
         }
-        return curator.getContradictions(params.status as 'open' | 'resolved' | 'dismissed' | undefined);
+        return curator.getContradictions(
+          params.status as 'open' | 'resolved' | 'dismissed' | undefined,
+        );
       },
     },
     {
@@ -443,13 +876,23 @@ export function createCoreOps(runtime: AgentRuntime): OpDefinition[] {
     },
     {
       name: 'curator_consolidate',
-      description: 'Consolidate vault — find duplicates, stale entries, contradictions. Dry-run by default.',
+      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.'),
+        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({
@@ -462,11 +905,289 @@ export function createCoreOps(runtime: AgentRuntime): OpDefinition[] {
     },
     {
       name: 'curator_health_audit',
-      description: 'Audit vault health — score (0-100), coverage, freshness, quality, tag health, recommendations.',
+      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 as string);
+        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 as string, {
+          name: params.name as string | undefined,
+          role: params.role as string | undefined,
+          description: params.description as string | undefined,
+          personality: params.personality as string[] | undefined,
+          changedBy: params.changedBy as string | undefined,
+          changeReason: params.changeReason as string | undefined,
+        });
+        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 as string, {
+          category: params.category as GuidelineCategory,
+          text: params.text as string,
+          priority: params.priority as number | undefined,
+        });
+        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 as string);
+        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 as string,
+          params.version as number,
+        );
+        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 as string);
+      },
+    },
+    {
+      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 as OperationalMode);
+      },
+    },
+    {
+      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 as OperationalMode | undefined;
+        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 as string;
+        const projectPath = params.projectPath as string;
+        if (action === 'get') {
+          return governance.getPolicy(projectPath);
+        }
+        if (action === 'set') {
+          governance.setPolicy(
+            projectPath,
+            params.policyType as PolicyType,
+            params.config as Record<string, unknown>,
+            params.changedBy as string | undefined,
+          );
+          return { updated: true, policy: governance.getPolicy(projectPath) };
+        }
+        if (action === 'applyPreset') {
+          governance.applyPreset(
+            projectPath,
+            params.preset as PolicyPreset,
+            params.changedBy as string | undefined,
+          );
+          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 as string;
+        if (action === 'list') {
+          return governance.listPendingProposals(
+            params.projectPath as string | undefined,
+            params.limit as number | undefined,
+          );
+        }
+        if (action === 'approve') {
+          return governance.approveProposal(
+            params.proposalId as number,
+            params.decidedBy as string | undefined,
+          );
+        }
+        if (action === 'reject') {
+          return governance.rejectProposal(
+            params.proposalId as number,
+            params.decidedBy as string | undefined,
+            params.note as string | undefined,
+          );
+        }
+        if (action === 'modify') {
+          return governance.modifyProposal(
+            params.proposalId as number,
+            params.modifications as Record<string, unknown>,
+            params.decidedBy as string | undefined,
+          );
+        }
+        if (action === 'stats') {
+          return governance.getProposalStats(params.projectPath as string | undefined);
+        }
+        if (action === 'expire') {
+          const expired = governance.expireStaleProposals(params.maxAgeDays as number | undefined);
+          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 as string;
+        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 as number | undefined);
+        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 as string);
+      },
+    },
+
+    // ─── 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),
   ];
 }