@soleri/core 2.4.0 → 2.6.0

package/src/runtime/core-ops.ts

@@ -1,5 +1,5 @@
 /**
- * Generic core operations factory — 147 ops that every agent gets.
+ * Generic core operations factory — 207 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)
@@ -25,16 +25,21 @@ 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 147 generic core operations for an agent runtime.
+ * Create the 207 generic core operations for an agent runtime.
  *
  * Groups: search/vault (4), memory (4), export (1), planning (5),
- *         brain (7), brain intelligence (11), cognee (5),
+ *         brain (8), 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).
+ *         playbook (5), prompt templates (2),
+ *         planning-extra (22), memory-extra (8), vault-extra (23),
+ *         admin (8), admin-extra (24), loop (9), orchestrate (5),
+ *         grading (5), capture (4), curator-extra (5), project (12),
+ *         cognee-sync (3), intake (4).
  */
 export function createCoreOps(runtime: AgentRuntime): OpDefinition[] {
   const {
@@ -49,6 +54,8 @@ export function createCoreOps(runtime: AgentRuntime): OpDefinition[] {
     intentRouter,
     llmClient,
     keyPool,
+    syncManager,
+    intakePipeline,
   } = runtime;
 
   return [
@@ -61,7 +68,7 @@ export function createCoreOps(runtime: AgentRuntime): OpDefinition[] {
       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(),
@@ -88,7 +95,7 @@ export function createCoreOps(runtime: AgentRuntime): OpDefinition[] {
       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(),
@@ -461,6 +468,23 @@ export function createCoreOps(runtime: AgentRuntime): OpDefinition[] {
         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 as string,
+          (params.limit as number | undefined) ?? 10,
+        );
+        return { results, count: results.length };
+      },
+    },
     {
       name: 'llm_status',
       description:
@@ -746,6 +770,194 @@ export function createCoreOps(runtime: AgentRuntime): OpDefinition[] {
         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 as string, {
+            searchType: 'GRAPH_COMPLETION' as CogneeSearchType,
+            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 as Error).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 as Error).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 as Error).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 as string;
+          const description = params.description as string;
+
+          // Try LLM enrichment for auto-tagging
+          let inferredTags: string[] = (params.tags as string[] | undefined) ?? [];
+          let inferredType = (params.type as IntelligenceEntry['type'] | undefined) ?? 'pattern';
+          const inferredDomain = (params.domain as string | undefined) ?? 'general';
+          let inferredSeverity: IntelligenceEntry['severity'] = '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: IntelligenceEntry = {
+            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 as Error).message };
+        }
+      },
+    },
 
     // ─── LLM ─────────────────────────────────────────────────────
     {
@@ -1176,6 +1388,9 @@ export function createCoreOps(runtime: AgentRuntime): OpDefinition[] {
       },
     },
 
+    // ─── Playbook ops (from dedicated module) ─────────────────────────
+    ...createPlaybookOps(runtime),
+
     // ─── Extra Ops (from dedicated modules) ─────────────────────────
     ...createPlanningExtraOps(runtime),
     ...createMemoryExtraOps(runtime),
@@ -1189,5 +1404,40 @@ export function createCoreOps(runtime: AgentRuntime): OpDefinition[] {
     ...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' as const,
+      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 as string,
+          (params.variables ?? {}) as Record<string, string>,
+          { strict: params.strict as boolean },
+        );
+        return { rendered };
+      },
+    },
+    {
+      name: 'list_templates',
+      description: 'List all loaded prompt templates.',
+      auth: 'read' as const,
+      handler: async () => ({
+        templates: runtime.templateManager.listTemplates(),
+      }),
+    },
   ];
 }

package/src/runtime/curator-extra-ops.ts

@@ -1,7 +1,7 @@
 /**
- * Extra curator operations — 4 ops that extend the 8 base curator ops in core-ops.ts.
+ * Extra curator operations — 5 ops that extend the 8 base curator ops in core-ops.ts.
  *
- * Groups: entry history (2), queue stats (1), metadata enrichment (1).
+ * Groups: entry history (2), queue stats (1), metadata enrichment (1), hybrid detection (1).
  */
 
 import { z } from 'zod';
@@ -27,7 +27,7 @@ export function createCuratorExtraOps(runtime: AgentRuntime): OpDefinition[] {
     },
     {
       name: 'curator_record_snapshot',
-      description: 'Manually record a snapshot of an entry\'s current state.',
+      description: "Manually record a snapshot of an entry's current state.",
       auth: 'write',
       schema: z.object({
         entryId: z.string().describe('Entry ID to snapshot.'),
@@ -67,5 +67,19 @@ export function createCuratorExtraOps(runtime: AgentRuntime): OpDefinition[] {
         return curator.enrichMetadata(params.entryId as string);
       },
     },
+
+    // ─── Hybrid Contradiction Detection (#36) ────────────────────────
+    {
+      name: 'curator_hybrid_contradictions',
+      description:
+        'Detect contradictions using hybrid TF-IDF + Cognee vector similarity. Falls back to TF-IDF only when Cognee is unavailable.',
+      auth: 'read',
+      schema: z.object({
+        threshold: z.number().optional().describe('Similarity threshold (default 0.4)'),
+      }),
+      handler: async (params) => {
+        return curator.detectContradictionsHybrid(params.threshold as number | undefined);
+      },
+    },
   ];
 }

package/src/runtime/domain-ops.ts

@@ -36,7 +36,7 @@ export function createDomainFacade(
       schema: z.object({
         tags: z.array(z.string()).optional(),
         severity: z.enum(['critical', 'warning', 'suggestion']).optional(),
-        type: z.enum(['pattern', 'anti-pattern', 'rule']).optional(),
+        type: z.enum(['pattern', 'anti-pattern', 'rule', 'playbook']).optional(),
         limit: z.number().optional(),
       }),
       handler: async (params) => {
@@ -83,7 +83,7 @@ export function createDomainFacade(
       auth: 'write',
       schema: z.object({
         id: z.string(),
-        type: z.enum(['pattern', 'anti-pattern', 'rule']),
+        type: z.enum(['pattern', 'anti-pattern', 'rule', 'playbook']),
         title: z.string(),
         severity: z.enum(['critical', 'warning', 'suggestion']),
         description: z.string(),

package/src/runtime/grading-ops.ts

@@ -35,7 +35,8 @@ export function createGradingOps(runtime: AgentRuntime): OpDefinition[] {
 
     {
       name: 'plan_check_history',
-      description: 'Get all grading checks for a plan (history). Shows score progression across iterations.',
+      description:
+        'Get all grading checks for a plan (history). Shows score progression across iterations.',
       auth: 'read',
       schema: z.object({
         planId: z.string().describe('The plan ID.'),
@@ -96,7 +97,15 @@ export function createGradingOps(runtime: AgentRuntime): OpDefinition[] {
         );
 
         // Group by severity for structured output
-        const grouped: Record<string, Array<{ category: string; description: string; recommendation: string; location?: string }>> = {};
+        const grouped: Record<
+          string,
+          Array<{
+            category: string;
+            description: string;
+            recommendation: string;
+            location?: string;
+          }>
+        > = {};
         for (const g of sortedGaps) {
           if (!grouped[g.severity]) grouped[g.severity] = [];
           grouped[g.severity].push({

package/src/runtime/intake-ops.ts

@@ -0,0 +1,126 @@
+/**
+ * Intake operations — 4 ops for book/PDF ingestion.
+ *
+ * Ops: intake_ingest_book, intake_process, intake_status, intake_preview.
+ */
+
+import { z } from 'zod';
+import type { OpDefinition } from '../facades/types.js';
+import type { IntakePipeline } from '../intake/intake-pipeline.js';
+
+/**
+ * Create the 4 intake operations.
+ *
+ * The pipeline is optional — when null, all ops return a graceful error.
+ */
+export function createIntakeOps(pipeline: IntakePipeline | null): OpDefinition[] {
+  return [
+    // ─── Ingest Book ──────────────────────────────────────────────
+    {
+      name: 'intake_ingest_book',
+      description:
+        'Ingest a PDF book — parse, hash, chunk into fixed-size page windows, and create a resumable job.',
+      auth: 'write',
+      schema: z.object({
+        pdfPath: z.string().describe('Absolute path to the PDF file.'),
+        title: z.string().describe('Book title for citation and chunk labeling.'),
+        domain: z.string().describe('Knowledge domain (e.g., "design-systems", "accessibility").'),
+        author: z.string().optional().describe('Book author for metadata.'),
+        chunkPageSize: z.number().optional().describe('Number of pages per chunk. Defaults to 10.'),
+        tags: z
+          .array(z.string())
+          .optional()
+          .describe('Additional tags applied to all extracted entries.'),
+      }),
+      handler: async (params) => {
+        if (!pipeline) {
+          return { error: 'Intake pipeline not configured' };
+        }
+        const config = {
+          pdfPath: params.pdfPath as string,
+          title: params.title as string,
+          domain: params.domain as string,
+          author: params.author as string | undefined,
+          chunkPageSize: params.chunkPageSize as number | undefined,
+          tags: params.tags as string[] | undefined,
+        };
+        return pipeline.ingestBook(config);
+      },
+    },
+
+    // ─── Process Chunks ───────────────────────────────────────────
+    {
+      name: 'intake_process',
+      description:
+        'Process pending chunks for a job — extract text, classify via LLM, dedup, and store unique items in the vault.',
+      auth: 'write',
+      schema: z.object({
+        jobId: z.string().describe('Job ID returned from intake_ingest_book.'),
+        count: z
+          .number()
+          .optional()
+          .describe('Max number of chunks to process in this batch. Defaults to 5.'),
+      }),
+      handler: async (params) => {
+        if (!pipeline) {
+          return { error: 'Intake pipeline not configured' };
+        }
+        return pipeline.processChunks(params.jobId as string, params.count as number | undefined);
+      },
+    },
+
+    // ─── Status ───────────────────────────────────────────────────
+    {
+      name: 'intake_status',
+      description:
+        'Get intake job status. With jobId: returns job record and chunks. Without: lists all jobs.',
+      auth: 'read',
+      schema: z.object({
+        jobId: z.string().optional().describe('Job ID to inspect. Omit to list all jobs.'),
+      }),
+      handler: async (params) => {
+        if (!pipeline) {
+          return { error: 'Intake pipeline not configured' };
+        }
+        const jobId = params.jobId as string | undefined;
+        if (jobId) {
+          const job = pipeline.getJob(jobId);
+          if (!job) {
+            return { error: `Job not found: ${jobId}` };
+          }
+          const chunks = pipeline.getChunks(jobId);
+          return { job, chunks };
+        }
+        return { jobs: pipeline.listJobs() };
+      },
+    },
+
+    // ─── Preview ──────────────────────────────────────────────────
+    {
+      name: 'intake_preview',
+      description:
+        'Preview what the pipeline would extract from a page range — parses and classifies without storing.',
+      auth: 'read',
+      schema: z.object({
+        pdfPath: z.string().describe('Absolute path to the PDF file.'),
+        title: z.string().describe('Book title for citation context.'),
+        domain: z.string().describe('Knowledge domain for classification context.'),
+        pageStart: z.number().describe('First page of the range (1-indexed, inclusive).'),
+        pageEnd: z.number().describe('Last page of the range (1-indexed, inclusive).'),
+      }),
+      handler: async (params) => {
+        if (!pipeline) {
+          return { error: 'Intake pipeline not configured' };
+        }
+        const { pdfPath, title, domain, pageStart, pageEnd } = params as {
+          pdfPath: string;
+          title: string;
+          domain: string;
+          pageStart: number;
+          pageEnd: number;
+        };
+        return pipeline.preview({ pdfPath, title, domain }, pageStart, pageEnd);
+      },
+    },
+  ];
+}