@soleri/core 7.0.0 → 8.1.0

package/src/runtime/facades/brain-facade.ts

@@ -8,7 +8,15 @@ import type { OpDefinition } from '../../facades/types.js';
 import type { AgentRuntime } from '../types.js';
 
 export function createBrainFacadeOps(runtime: AgentRuntime): OpDefinition[] {
-  const { brain, brainIntelligence, llmClient, keyPool, governance } = runtime;
+  const {
+    brain,
+    brainIntelligence,
+    llmClient,
+    keyPool,
+    governance,
+    learningRadar,
+    knowledgeSynthesizer,
+  } = runtime;
 
   return [
     // ─── Brain (inline from core-ops.ts) ────────────────────────
@@ -387,5 +395,138 @@ export function createBrainFacadeOps(runtime: AgentRuntime): OpDefinition[] {
         });
       },
     },
+
+    // ─── Learning Radar (#208) ────────────────────────────────────
+    {
+      name: 'radar_analyze',
+      description:
+        'Analyze a learning signal (correction, search miss, workaround, etc.). ' +
+        'High confidence auto-captures silently. Medium queues for review. Low logs only.',
+      auth: 'write',
+      schema: z.object({
+        type: z.enum([
+          'correction',
+          'search_miss',
+          'explicit_capture',
+          'pattern_success',
+          'workaround',
+          'repeated_question',
+        ]),
+        title: z.string().describe('Short title for the detected pattern'),
+        description: z.string().describe('What was learned and why it matters'),
+        suggestedType: z.enum(['pattern', 'anti-pattern']).optional(),
+        confidence: z
+          .number()
+          .optional()
+          .describe('Override confidence (0-1). Default inferred from signal type.'),
+        sourceQuery: z.string().optional().describe('Original query that triggered this signal'),
+        context: z.string().optional().describe('Additional context'),
+      }),
+      handler: async (params) => {
+        return learningRadar.analyze({
+          type: params.type as
+            | 'correction'
+            | 'search_miss'
+            | 'explicit_capture'
+            | 'pattern_success'
+            | 'workaround'
+            | 'repeated_question',
+          title: params.title as string,
+          description: params.description as string,
+          suggestedType: params.suggestedType as 'pattern' | 'anti-pattern' | undefined,
+          confidence: params.confidence as number | undefined,
+          sourceQuery: params.sourceQuery as string | undefined,
+          context: params.context as string | undefined,
+        });
+      },
+    },
+    {
+      name: 'radar_candidates',
+      description: 'Get pending radar candidates queued for end-of-session review.',
+      auth: 'read',
+      schema: z.object({
+        limit: z.number().optional().default(20),
+      }),
+      handler: async (params) => {
+        return learningRadar.getCandidates(params.limit as number);
+      },
+    },
+    {
+      name: 'radar_approve',
+      description: 'Approve a pending radar candidate — captures it to vault.',
+      auth: 'write',
+      schema: z.object({
+        candidateId: z.number().describe('Radar candidate ID to approve'),
+      }),
+      handler: async (params) => {
+        return learningRadar.approve(params.candidateId as number);
+      },
+    },
+    {
+      name: 'radar_dismiss',
+      description: 'Dismiss a pending radar candidate — marks it as not worth capturing.',
+      auth: 'write',
+      schema: z.object({
+        candidateId: z.number().describe('Radar candidate ID to dismiss'),
+      }),
+      handler: async (params) => {
+        return learningRadar.dismiss(params.candidateId as number);
+      },
+    },
+    {
+      name: 'radar_flush',
+      description:
+        'Auto-capture all pending candidates above a confidence threshold. ' +
+        'Use at end-of-session to batch-capture high-quality candidates.',
+      auth: 'write',
+      schema: z.object({
+        minConfidence: z
+          .number()
+          .optional()
+          .default(0.8)
+          .describe('Minimum confidence to auto-capture (default 0.8)'),
+      }),
+      handler: async (params) => {
+        return learningRadar.flush(params.minConfidence as number);
+      },
+    },
+    {
+      name: 'radar_stats',
+      description:
+        'Get learning radar statistics — analyzed, captured, queued, dismissed, knowledge gaps.',
+      auth: 'read',
+      handler: async () => {
+        return learningRadar.getStats();
+      },
+    },
+
+    // ─── Knowledge Synthesis (#207) ───────────────────────────────
+    {
+      name: 'synthesize',
+      description:
+        'Synthesize vault knowledge into structured content. Searches vault for relevant entries, ' +
+        'then uses LLM to produce a brief, outline, talking points, or post draft. ' +
+        'Includes source attribution, coverage score, and knowledge gap detection.',
+      auth: 'read',
+      schema: z.object({
+        query: z.string().describe('Topic to synthesize knowledge about'),
+        format: z
+          .enum(['brief', 'outline', 'talking-points', 'post-draft'])
+          .describe('Output format'),
+        maxEntries: z.number().optional().default(10).describe('Max vault entries to consult'),
+        audience: z
+          .enum(['technical', 'executive', 'general'])
+          .optional()
+          .default('general')
+          .describe('Target audience for tone and language'),
+      }),
+      handler: async (params) => {
+        return knowledgeSynthesizer.synthesize(params.query as string, {
+          format: params.format as 'brief' | 'outline' | 'talking-points' | 'post-draft',
+          maxEntries: params.maxEntries as number,
+          audience: params.audience as 'technical' | 'executive' | 'general',
+        });
+      },
+    },
   ];
 }

package/src/runtime/facades/control-facade.ts

@@ -275,5 +275,50 @@ export function createControlFacadeOps(runtime: AgentRuntime): OpDefinition[] {
         return governance.getDashboard(params.projectPath as string);
       },
     },
+
+    // ─── Routing Feedback (#209) ──────────────────────────────────
+    {
+      name: 'routing_feedback',
+      description:
+        'Record whether intent routing was correct. Call after a session to track accuracy. ' +
+        'Set correction=true if the human had to override the detected intent.',
+      auth: 'write',
+      schema: z.object({
+        initialIntent: z.string().describe('The intent that was originally detected'),
+        actualIntent: z.string().describe('The intent that the session actually turned out to be'),
+        confidence: z.number().describe('Original confidence score from route_intent'),
+        correction: z
+          .boolean()
+          .optional()
+          .default(false)
+          .describe('True if human had to correct the routing'),
+        routingLogId: z.number().optional().describe('ID from agent_routing_log for linking'),
+      }),
+      handler: async (params) => {
+        return intentRouter.recordRoutingFeedback({
+          initialIntent: params.initialIntent as string,
+          actualIntent: params.actualIntent as string,
+          confidence: params.confidence as number,
+          correction: params.correction as boolean,
+          routingLogId: params.routingLogId as number | undefined,
+        });
+      },
+    },
+    {
+      name: 'routing_accuracy',
+      description:
+        'Get routing accuracy report — overall accuracy, common misroutes, confidence calibration per bucket (high/medium/low).',
+      auth: 'read',
+      schema: z.object({
+        periodDays: z
+          .number()
+          .optional()
+          .default(30)
+          .describe('Look-back period in days (default: 30)'),
+      }),
+      handler: async (params) => {
+        return intentRouter.getRoutingAccuracy(params.periodDays as number);
+      },
+    },
   ];
 }

package/src/runtime/facades/memory-facade.ts

@@ -54,6 +54,11 @@ export function createMemoryFacadeOps(runtime: AgentRuntime): OpDefinition[] {
           topics: (params.topics as string[]) ?? [],
           filesModified: (params.filesModified as string[]) ?? [],
           toolsUsed: (params.toolsUsed as string[]) ?? [],
+          intent: null,
+          decisions: [],
+          currentState: null,
+          nextSteps: [],
+          vaultEntriesReferenced: [],
         });
         return { captured: true, memory };
       },
@@ -82,14 +87,22 @@ export function createMemoryFacadeOps(runtime: AgentRuntime): OpDefinition[] {
     {
       name: 'session_capture',
       description:
-        'Capture a session summary before context compaction. Called automatically by PreCompact hook.',
+        'Capture a session summary. Supports rich format: intent, decisions, currentState, nextSteps, vaultEntriesReferenced.',
       auth: 'write',
       schema: z.object({
         projectPath: z.string().optional().default('.'),
-        summary: z.string().describe('Brief summary of what was accomplished in this session'),
+        summary: z.string().describe('Brief summary of what was accomplished'),
         topics: z.array(z.string()).optional().default([]),
         filesModified: z.array(z.string()).optional().default([]),
         toolsUsed: z.array(z.string()).optional().default([]),
+        intent: z.string().optional().describe('What the user was trying to accomplish'),
+        decisions: z.array(z.string()).optional().describe('Key decisions and rationale'),
+        currentState: z.string().optional().describe('Where things stand at capture time'),
+        nextSteps: z.array(z.string()).optional().describe('What should happen next session'),
+        vaultEntriesReferenced: z
+          .array(z.string())
+          .optional()
+          .describe('Vault entry IDs that informed this session'),
       }),
       handler: async (params) => {
         const { resolve } = await import('node:path');
@@ -102,6 +115,11 @@ export function createMemoryFacadeOps(runtime: AgentRuntime): OpDefinition[] {
           topics: (params.topics as string[]) ?? [],
           filesModified: (params.filesModified as string[]) ?? [],
           toolsUsed: (params.toolsUsed as string[]) ?? [],
+          intent: (params.intent as string) ?? null,
+          decisions: (params.decisions as string[]) ?? [],
+          currentState: (params.currentState as string) ?? null,
+          nextSteps: (params.nextSteps as string[]) ?? [],
+          vaultEntriesReferenced: (params.vaultEntriesReferenced as string[]) ?? [],
         });
         return { captured: true, memory, message: 'Session summary saved to memory.' };
       },

package/src/runtime/facades/plan-facade.ts

@@ -8,6 +8,7 @@ import type { OpDefinition } from '../../facades/types.js';
 import type { AgentRuntime } from '../types.js';
 import { createPlanningExtraOps } from '../planning-extra-ops.js';
 import { createGradingOps } from '../grading-ops.js';
+import { createChainOps } from '../chain-ops.js';
 
 export function createPlanFacadeOps(runtime: AgentRuntime): OpDefinition[] {
   const { planner } = runtime;
@@ -115,5 +116,6 @@ export function createPlanFacadeOps(runtime: AgentRuntime): OpDefinition[] {
     // ─── Satellite ops ───────────────────────────────────────────
     ...createPlanningExtraOps(runtime),
     ...createGradingOps(runtime),
+    ...createChainOps(runtime),
   ];
 }

package/src/runtime/facades/vault-facade.ts

@@ -16,14 +16,14 @@ import { createVaultLinkingOps } from '../vault-linking-ops.js';
 import { ObsidianSync } from '../../vault/obsidian-sync.js';
 
 export function createVaultFacadeOps(runtime: AgentRuntime): OpDefinition[] {
-  const { vault, brain, intakePipeline, vaultManager } = runtime;
+  const { vault, brain, intakePipeline, textIngester, vaultManager } = runtime;
 
   return [
     // ─── Search / Vault (inline from core-ops.ts) ───────────────
     {
       name: 'search',
       description:
-        'Search across all knowledge domains. Results ranked by TF-IDF + severity + recency + tag overlap + domain match.',
+        'Search knowledge. mode:"scan" returns lightweight results (titles + scores + snippets) for two-pass retrieval. mode:"full" (default) returns complete entries.',
       auth: 'read',
       schema: z.object({
         query: z.string(),
@@ -32,15 +32,38 @@ export function createVaultFacadeOps(runtime: AgentRuntime): OpDefinition[] {
         severity: z.enum(['critical', 'warning', 'suggestion']).optional(),
         tags: z.array(z.string()).optional(),
         limit: z.number().optional(),
+        mode: z
+          .enum(['full', 'scan'])
+          .optional()
+          .default('full')
+          .describe(
+            'full = complete entries, scan = lightweight titles + scores for two-pass retrieval',
+          ),
       }),
       handler: async (params) => {
-        return brain.intelligentSearch(params.query as string, {
+        const opts = {
           domain: params.domain as string | undefined,
           type: params.type as string | undefined,
           severity: params.severity as string | undefined,
           tags: params.tags as string[] | undefined,
           limit: (params.limit as number) ?? 10,
-        });
+        };
+        if (params.mode === 'scan') {
+          return brain.scanSearch(params.query as string, opts);
+        }
+        return brain.intelligentSearch(params.query as string, opts);
+      },
+    },
+    {
+      name: 'load_entries',
+      description:
+        'Two-pass retrieval — Pass 2: Load full entries by IDs (from a previous scan search).',
+      auth: 'read',
+      schema: z.object({
+        ids: z.array(z.string()).min(1).describe('Entry IDs from a previous scan search'),
+      }),
+      handler: async (params) => {
+        return brain.loadEntries(params.ids as string[]);
       },
     },
     {
@@ -478,7 +501,7 @@ export function createVaultFacadeOps(runtime: AgentRuntime): OpDefinition[] {
     // ─── Satellite ops ───────────────────────────────────────────
     ...createVaultExtraOps(runtime),
     ...createCaptureOps(runtime),
-    ...createIntakeOps(intakePipeline),
+    ...createIntakeOps(intakePipeline, textIngester),
     ...createVaultSharingOps(runtime),
     ...createVaultLinkingOps(runtime),
   ];

package/src/runtime/intake-ops.ts

@@ -1,19 +1,24 @@
 /**
- * Intake operations — 4 ops for book/PDF ingestion.
+ * Intake operations — 7 ops for book/PDF and text/URL ingestion.
  *
- * Ops: intake_ingest_book, intake_process, intake_status, intake_preview.
+ * Ops: intake_ingest_book, intake_process, intake_status, intake_preview,
+ *       ingest_url, ingest_text, ingest_batch.
  */
 
 import { z } from 'zod';
 import type { OpDefinition } from '../facades/types.js';
 import type { IntakePipeline } from '../intake/intake-pipeline.js';
+import type { TextIngester, IngestSource } from '../intake/text-ingester.js';
 
 /**
- * Create the 4 intake operations.
+ * Create the 7 intake operations.
  *
- * The pipeline is optional — when null, all ops return a graceful error.
+ * The pipeline and textIngester are optional — when null, affected ops return a graceful error.
  */
-export function createIntakeOps(pipeline: IntakePipeline | null): OpDefinition[] {
+export function createIntakeOps(
+  pipeline: IntakePipeline | null,
+  textIngester?: TextIngester | null,
+): OpDefinition[] {
   return [
     // ─── Ingest Book ──────────────────────────────────────────────
     {
@@ -122,5 +127,102 @@ export function createIntakeOps(pipeline: IntakePipeline | null): OpDefinition[]
         return pipeline.preview({ pdfPath, title, domain }, pageStart, pageEnd);
       },
     },
+
+    // ─── URL Ingestion (#203) ──────────────────────────────────────
+    {
+      name: 'ingest_url',
+      description:
+        'Fetch a URL, extract text, classify into knowledge items via LLM, dedup against vault, and store. ' +
+        'Returns count of ingested entries and duplicates skipped.',
+      auth: 'write',
+      schema: z.object({
+        url: z.string().describe('URL to fetch and ingest'),
+        domain: z.string().optional().describe('Knowledge domain (default: general)'),
+        tags: z.array(z.string()).optional().describe('Additional tags for all extracted entries'),
+      }),
+      handler: async (params) => {
+        if (!textIngester) return { error: 'Text ingester not configured (LLM client required)' };
+        return textIngester.ingestUrl(params.url as string, {
+          domain: params.domain as string | undefined,
+          tags: params.tags as string[] | undefined,
+        });
+      },
+    },
+
+    // ─── Text/Transcript Ingestion (#203) ──────────────────────────
+    {
+      name: 'ingest_text',
+      description:
+        'Ingest raw text (article, transcript, notes) — classify via LLM, dedup, and store. ' +
+        'Use for transcripts, copied articles, meeting notes, etc.',
+      auth: 'write',
+      schema: z.object({
+        text: z.string().describe('The text content to ingest'),
+        title: z.string().describe('Title for the source material'),
+        sourceType: z
+          .enum(['article', 'transcript', 'notes', 'documentation'])
+          .optional()
+          .default('notes')
+          .describe('Type of source material'),
+        url: z.string().optional().describe('Source URL if available'),
+        author: z.string().optional().describe('Author of the source material'),
+        domain: z.string().optional().describe('Knowledge domain (default: general)'),
+        tags: z.array(z.string()).optional().describe('Additional tags'),
+      }),
+      handler: async (params) => {
+        if (!textIngester) return { error: 'Text ingester not configured (LLM client required)' };
+        const source: IngestSource = {
+          type: params.sourceType as 'article' | 'transcript' | 'notes' | 'documentation',
+          title: params.title as string,
+          url: params.url as string | undefined,
+          author: params.author as string | undefined,
+        };
+        return textIngester.ingestText(params.text as string, source, {
+          domain: params.domain as string | undefined,
+          tags: params.tags as string[] | undefined,
+        });
+      },
+    },
+
+    // ─── Batch Ingestion (#203) ────────────────────────────────────
+    {
+      name: 'ingest_batch',
+      description:
+        'Ingest multiple text items in one call. Each item has its own source metadata. Processed sequentially.',
+      auth: 'write',
+      schema: z.object({
+        items: z
+          .array(
+            z.object({
+              text: z.string(),
+              title: z.string(),
+              sourceType: z.enum(['article', 'transcript', 'notes', 'documentation']).optional(),
+              url: z.string().optional(),
+              author: z.string().optional(),
+              domain: z.string().optional(),
+              tags: z.array(z.string()).optional(),
+            }),
+          )
+          .min(1)
+          .describe('Array of items to ingest'),
+      }),
+      handler: async (params) => {
+        if (!textIngester) return { error: 'Text ingester not configured (LLM client required)' };
+        const items = (params.items as Array<Record<string, unknown>>).map((item) => ({
+          text: item.text as string,
+          source: {
+            type: (item.sourceType as string | undefined) ?? 'notes',
+            title: item.title as string,
+            url: item.url as string | undefined,
+            author: item.author as string | undefined,
+          } as IngestSource,
+          opts: {
+            domain: item.domain as string | undefined,
+            tags: item.tags as string[] | undefined,
+          },
+        }));
+        return textIngester.ingestBatch(items);
+      },
+    },
   ];
 }