@soleri/core 2.1.0 → 2.4.0

package/src/runtime/domain-ops.ts

@@ -25,7 +25,7 @@ export function createDomainFacade(
   agentId: string,
   domain: string,
 ): FacadeConfig {
-  const { vault, brain } = runtime;
+  const { vault, brain, governance } = runtime;
   const facadeName = `${agentId}_${domain.replace(/-/g, '_')}`;
 
   const ops: OpDefinition[] = [
@@ -92,21 +92,73 @@ export function createDomainFacade(
         counterExample: z.string().optional(),
         why: z.string().optional(),
         tags: z.array(z.string()).optional().default([]),
+        projectPath: z.string().optional().default('.'),
       }),
       handler: async (params) => {
-        return brain.enrichAndCapture({
-          id: params.id as string,
-          type: params.type as 'pattern' | 'anti-pattern' | 'rule',
-          domain,
-          title: params.title as string,
-          severity: params.severity as 'critical' | 'warning' | 'suggestion',
-          description: params.description as string,
-          context: params.context as string | undefined,
-          example: params.example as string | undefined,
-          counterExample: params.counterExample as string | undefined,
-          why: params.why as string | undefined,
-          tags: params.tags as string[],
+        const projectPath = (params.projectPath as string | undefined) ?? '.';
+        const entryType = params.type as string;
+        const title = params.title as string;
+
+        const decision = governance.evaluateCapture(projectPath, {
+          type: entryType,
+          category: domain,
+          title,
         });
+
+        switch (decision.action) {
+          case 'capture': {
+            const result = brain.enrichAndCapture({
+              id: params.id as string,
+              type: params.type as 'pattern' | 'anti-pattern' | 'rule',
+              domain,
+              title,
+              severity: params.severity as 'critical' | 'warning' | 'suggestion',
+              description: params.description as string,
+              context: params.context as string | undefined,
+              example: params.example as string | undefined,
+              counterExample: params.counterExample as string | undefined,
+              why: params.why as string | undefined,
+              tags: params.tags as string[],
+            });
+            return { ...result, governance: { action: 'capture' as const } };
+          }
+          case 'propose': {
+            const proposalId = governance.propose(
+              projectPath,
+              {
+                entryId: params.id as string,
+                title,
+                type: entryType,
+                category: domain,
+                data: {
+                  severity: params.severity,
+                  description: params.description,
+                  context: params.context,
+                  example: params.example,
+                  counterExample: params.counterExample,
+                  why: params.why,
+                  tags: params.tags,
+                },
+              },
+              'domain-capture',
+            );
+            return {
+              captured: false,
+              id: params.id as string,
+              autoTags: [],
+              governance: { action: 'propose' as const, proposalId, reason: decision.reason },
+            };
+          }
+          default: {
+            // reject or quarantine
+            return {
+              captured: false,
+              id: params.id as string,
+              autoTags: [],
+              governance: { action: decision.action, reason: decision.reason },
+            };
+          }
+        }
       },
     },
     {

package/src/runtime/grading-ops.ts

@@ -0,0 +1,121 @@
+/**
+ * Plan grading operations — 5 ops for iterative plan quality scoring.
+ * Uses 6-pass gap analysis with severity-weighted scoring (ported from Salvador).
+ *
+ * Ops: plan_grade, plan_check_history, plan_latest_check,
+ *      plan_meets_grade, plan_auto_improve.
+ */
+
+import { z } from 'zod';
+import type { OpDefinition } from '../facades/types.js';
+import type { AgentRuntime } from './types.js';
+
+const planGradeSchema = z.enum(['A+', 'A', 'B', 'C', 'D', 'F']);
+
+/**
+ * Create the 5 plan grading operations for an agent runtime.
+ */
+export function createGradingOps(runtime: AgentRuntime): OpDefinition[] {
+  const { planner } = runtime;
+
+  return [
+    {
+      name: 'plan_grade',
+      description:
+        'Grade a plan using 6-pass gap analysis — severity-weighted scoring (critical=30, major=15, minor=2). Returns grade, score, gaps with recommendations, and iteration number.',
+      auth: 'read',
+      schema: z.object({
+        planId: z.string().describe('The plan ID to grade.'),
+      }),
+      handler: async (params) => {
+        const planId = params.planId as string;
+        return planner.grade(planId);
+      },
+    },
+
+    {
+      name: 'plan_check_history',
+      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.'),
+      }),
+      handler: async (params) => {
+        const planId = params.planId as string;
+        const checks = planner.getCheckHistory(planId);
+        return { planId, count: checks.length, checks };
+      },
+    },
+
+    {
+      name: 'plan_latest_check',
+      description: 'Get the latest grading check for a plan.',
+      auth: 'read',
+      schema: z.object({
+        planId: z.string().describe('The plan ID.'),
+      }),
+      handler: async (params) => {
+        const planId = params.planId as string;
+        const check = planner.getLatestCheck(planId);
+        return check ?? { planId, check: null, message: 'No checks found for this plan.' };
+      },
+    },
+
+    {
+      name: 'plan_meets_grade',
+      description:
+        'Check if a plan meets a target grade. Thresholds: A+=95, A=90, B=80, C=70, D=60.',
+      auth: 'read',
+      schema: z.object({
+        planId: z.string().describe('The plan ID.'),
+        targetGrade: planGradeSchema.describe('Target grade: A+, A, B, C, D, or F.'),
+      }),
+      handler: async (params) => {
+        const planId = params.planId as string;
+        const targetGrade = params.targetGrade as 'A+' | 'A' | 'B' | 'C' | 'D' | 'F';
+        return planner.meetsGrade(planId, targetGrade);
+      },
+    },
+
+    {
+      name: 'plan_auto_improve',
+      description:
+        'Grade a plan and return gaps grouped by severity with actionable recommendations. Critical gaps first.',
+      auth: 'read',
+      schema: z.object({
+        planId: z.string().describe('The plan ID.'),
+      }),
+      handler: async (params) => {
+        const planId = params.planId as string;
+        const check = planner.grade(planId);
+
+        // Sort gaps by severity: critical > major > minor > info
+        const severityOrder: Record<string, number> = { critical: 0, major: 1, minor: 2, info: 3 };
+        const sortedGaps = [...check.gaps].sort(
+          (a, b) => (severityOrder[a.severity] ?? 4) - (severityOrder[b.severity] ?? 4),
+        );
+
+        // Group by severity for structured output
+        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({
+            category: g.category,
+            description: g.description,
+            recommendation: g.recommendation,
+            ...(g.location ? { location: g.location } : {}),
+          });
+        }
+
+        return {
+          grade: check.grade,
+          score: check.score,
+          iteration: check.iteration,
+          totalGaps: check.gaps.length,
+          gapsBySeverity: grouped,
+          nextAction: check.score >= 90 ? 'approve' : 'iterate',
+        };
+      },
+    },
+  ];
+}

package/src/runtime/loop-ops.ts

@@ -0,0 +1,194 @@
+/**
+ * Loop operations — 7 ops for iterative validation loops.
+ *
+ * Ops: loop_start, loop_iterate, loop_status, loop_cancel,
+ *      loop_history, loop_is_active, loop_complete.
+ */
+
+import { z } from 'zod';
+import type { OpDefinition } from '../facades/types.js';
+import type { AgentRuntime } from './types.js';
+import type { LoopMode } from '../loop/types.js';
+
+const loopModeSchema = z.enum([
+  'token-migration',
+  'contrast-fix',
+  'component-build',
+  'plan-iteration',
+  'custom',
+]);
+
+/**
+ * Default max iterations per mode.
+ */
+const DEFAULT_MAX_ITERATIONS: Record<LoopMode, number> = {
+  'token-migration': 20,
+  'contrast-fix': 15,
+  'component-build': 20,
+  'plan-iteration': 10,
+  custom: 20,
+};
+
+/**
+ * Default target scores per mode.
+ */
+const DEFAULT_TARGET_SCORES: Partial<Record<LoopMode, number>> = {
+  'token-migration': 95,
+  'component-build': 90,
+  'plan-iteration': 90,
+};
+
+/**
+ * Create the 7 loop operations for an agent runtime.
+ */
+export function createLoopOps(runtime: AgentRuntime): OpDefinition[] {
+  const { loop } = runtime;
+
+  return [
+    {
+      name: 'loop_start',
+      description:
+        'Start an iterative validation loop. Modes: token-migration, contrast-fix, component-build, plan-iteration, custom.',
+      auth: 'write',
+      schema: z.object({
+        mode: loopModeSchema,
+        prompt: z.string().describe('Task description for the loop.'),
+        maxIterations: z
+          .number()
+          .optional()
+          .describe('Max iterations. Defaults vary by mode (10-20).'),
+        targetScore: z
+          .number()
+          .optional()
+          .describe('Target validation score (0-100). Defaults vary by mode.'),
+      }),
+      handler: async (params) => {
+        const mode = params.mode as LoopMode;
+        const prompt = params.prompt as string;
+        const maxIterations =
+          (params.maxIterations as number | undefined) ?? DEFAULT_MAX_ITERATIONS[mode];
+        const targetScore =
+          (params.targetScore as number | undefined) ?? DEFAULT_TARGET_SCORES[mode];
+
+        const state = loop.startLoop({
+          mode,
+          prompt,
+          maxIterations,
+          targetScore,
+        });
+
+        return {
+          started: true,
+          loopId: state.id,
+          mode,
+          maxIterations,
+          targetScore: targetScore ?? null,
+        };
+      },
+    },
+    {
+      name: 'loop_iterate',
+      description:
+        'Record a validation iteration result. If max iterations reached on a failing result, the loop auto-closes.',
+      auth: 'write',
+      schema: z.object({
+        passed: z.boolean().describe('Whether this iteration passed validation.'),
+        validationScore: z
+          .number()
+          .optional()
+          .describe('Numeric validation score (0-100).'),
+        validationResult: z
+          .string()
+          .optional()
+          .describe('Free-text validation result summary.'),
+      }),
+      handler: async (params) => {
+        const iteration = loop.iterate({
+          passed: params.passed as boolean,
+          validationScore: params.validationScore as number | undefined,
+          validationResult: params.validationResult as string | undefined,
+        });
+
+        const status = loop.getStatus();
+        return {
+          iteration: iteration.iteration,
+          passed: iteration.passed,
+          validationScore: iteration.validationScore ?? null,
+          loopActive: loop.isActive(),
+          loopStatus: status?.status ?? 'max-iterations',
+        };
+      },
+    },
+    {
+      name: 'loop_status',
+      description: 'Get current loop status, config, and iteration history.',
+      auth: 'read',
+      handler: async () => {
+        const status = loop.getStatus();
+        if (!status) {
+          return { active: false, loop: null };
+        }
+        return {
+          active: true,
+          loop: status,
+        };
+      },
+    },
+    {
+      name: 'loop_cancel',
+      description: 'Cancel the active loop.',
+      auth: 'write',
+      handler: async () => {
+        const cancelled = loop.cancelLoop();
+        return {
+          cancelled: true,
+          loopId: cancelled.id,
+          iterations: cancelled.iterations.length,
+          status: cancelled.status,
+        };
+      },
+    },
+    {
+      name: 'loop_history',
+      description: 'Get history of all completed, cancelled, and max-iterations loops.',
+      auth: 'read',
+      handler: async () => {
+        const history = loop.getHistory();
+        return {
+          count: history.length,
+          loops: history.map((l) => ({
+            id: l.id,
+            mode: l.config.mode,
+            prompt: l.config.prompt,
+            status: l.status,
+            iterations: l.iterations.length,
+            startedAt: l.startedAt,
+            completedAt: l.completedAt,
+          })),
+        };
+      },
+    },
+    {
+      name: 'loop_is_active',
+      description: 'Check if a validation loop is currently running.',
+      auth: 'read',
+      handler: async () => {
+        return { active: loop.isActive() };
+      },
+    },
+    {
+      name: 'loop_complete',
+      description: 'Mark the active loop as completed (validation passed).',
+      auth: 'write',
+      handler: async () => {
+        const completed = loop.completeLoop();
+        return {
+          completed: true,
+          loopId: completed.id,
+          iterations: completed.iterations.length,
+          status: completed.status,
+        };
+      },
+    },
+  ];
+}

package/src/runtime/memory-cross-project-ops.ts

@@ -0,0 +1,192 @@
+/**
+ * Cross-project memory operations — 3 ops for sharing knowledge across linked projects.
+ *
+ * Ops: memory_promote_to_global, memory_configure, memory_cross_project_search.
+ */
+
+import { z } from 'zod';
+import type { OpDefinition } from '../facades/types.js';
+import type { AgentRuntime } from './types.js';
+
+/**
+ * Create the 3 cross-project memory operations for an agent runtime.
+ */
+export function createMemoryCrossProjectOps(runtime: AgentRuntime): OpDefinition[] {
+  const { vault, projectRegistry } = runtime;
+
+  return [
+    {
+      name: 'memory_promote_to_global',
+      description:
+        'Promote a vault entry to the global pool by adding a _global tag. Promoted entries surface in cross-project searches across all linked projects.',
+      auth: 'write',
+      schema: z.object({
+        entryId: z.string().describe('The vault entry ID to promote.'),
+      }),
+      handler: async (params) => {
+        const entryId = params.entryId as string;
+        const entry = vault.get(entryId);
+        if (!entry) return { promoted: false, error: `Entry not found: ${entryId}` };
+
+        const tags = entry.tags ?? [];
+        if (tags.includes('_global')) {
+          return { promoted: false, entryId, message: 'Entry is already promoted to global.' };
+        }
+
+        vault.update(entryId, { tags: [...tags, '_global'] });
+        return { promoted: true, entryId, tags: [...tags, '_global'] };
+      },
+    },
+
+    {
+      name: 'memory_configure',
+      description:
+        'Configure cross-project memory settings for a project. Stores config in the project registry metadata.',
+      auth: 'admin',
+      schema: z.object({
+        projectPath: z.string().describe('Project path to configure.'),
+        crossProjectEnabled: z
+          .boolean()
+          .optional()
+          .describe('Enable/disable cross-project memory search.'),
+        extraPaths: z
+          .array(z.string())
+          .optional()
+          .describe('Additional project paths to include in cross-project searches.'),
+      }),
+      handler: async (params) => {
+        const projectPath = params.projectPath as string;
+        const project = projectRegistry.getByPath(projectPath);
+        if (!project) {
+          return { configured: false, error: `Project not registered: ${projectPath}` };
+        }
+
+        const currentMeta = project.metadata ?? {};
+        const memoryConfig = (currentMeta.memoryConfig as Record<string, unknown>) ?? {};
+
+        if (params.crossProjectEnabled !== undefined) {
+          memoryConfig.crossProjectEnabled = params.crossProjectEnabled;
+        }
+        if (params.extraPaths !== undefined) {
+          memoryConfig.extraPaths = params.extraPaths;
+        }
+
+        projectRegistry.register(projectPath, project.name, {
+          ...currentMeta,
+          memoryConfig,
+        });
+
+        return { configured: true, projectPath, memoryConfig };
+      },
+    },
+
+    {
+      name: 'memory_cross_project_search',
+      description:
+        'Search memories across the current project and all linked projects. Results weighted: current=1.0, global=0.9, linked=0.8. Requires cross-project search to be enabled.',
+      auth: 'read',
+      schema: z.object({
+        query: z.string().describe('Search query.'),
+        projectPath: z.string().describe('Current project path.'),
+        type: z
+          .enum(['session', 'lesson', 'preference'])
+          .optional()
+          .describe('Filter by memory type.'),
+        limit: z.number().optional().describe('Max results per project (default 10).'),
+      }),
+      handler: async (params) => {
+        const query = params.query as string;
+        const projectPath = params.projectPath as string;
+        const type = params.type as string | undefined;
+        const limit = (params.limit as number) ?? 10;
+
+        // Search current project (weight 1.0)
+        const currentResults = vault.searchMemories(query, { projectPath, type, limit });
+        const weightedResults = currentResults.map((m) => ({
+          memory: m,
+          weight: 1.0,
+          source: 'current' as const,
+        }));
+
+        // Search for globally promoted entries (search broadly, then filter for _global tag)
+        const allResults = vault.search(query, { limit: limit * 3 });
+        const globalEntries = allResults
+          .filter((r) => r.entry.tags?.includes('_global'))
+          .slice(0, limit)
+          .map((r) => ({
+            entry: r.entry,
+            score: r.score,
+            weight: 0.9,
+            source: 'global' as const,
+          }));
+
+        // Get linked projects and search their memories
+        const project = projectRegistry.getByPath(projectPath);
+        const linkedMemories: Array<{
+          memory: (typeof currentResults)[0];
+          weight: number;
+          source: 'linked';
+          linkedProject: string;
+        }> = [];
+
+        if (project) {
+          const config = (project.metadata?.memoryConfig as Record<string, unknown>) ?? {};
+          const enabled = config.crossProjectEnabled !== false; // default enabled
+
+          if (enabled) {
+            const linked = projectRegistry.getLinkedProjects(project.id);
+            for (const { project: linkedProj } of linked) {
+              const results = vault.searchMemories(query, {
+                projectPath: linkedProj.path,
+                type,
+                limit: Math.ceil(limit / 2), // fewer results from linked projects
+              });
+              for (const m of results) {
+                linkedMemories.push({
+                  memory: m,
+                  weight: 0.8,
+                  source: 'linked',
+                  linkedProject: linkedProj.path,
+                });
+              }
+            }
+
+            // Also search extra paths
+            const extraPaths = (config.extraPaths as string[]) ?? [];
+            for (const extraPath of extraPaths) {
+              const results = vault.searchMemories(query, {
+                projectPath: extraPath,
+                type,
+                limit: Math.ceil(limit / 2),
+              });
+              for (const m of results) {
+                linkedMemories.push({
+                  memory: m,
+                  weight: 0.7,
+                  source: 'linked',
+                  linkedProject: extraPath,
+                });
+              }
+            }
+          }
+        }
+
+        // Deduplicate by memory ID
+        const seen = new Set(weightedResults.map((r) => r.memory.id));
+        const dedupedLinked = linkedMemories.filter((r) => {
+          if (seen.has(r.memory.id)) return false;
+          seen.add(r.memory.id);
+          return true;
+        });
+
+        return {
+          memories: weightedResults,
+          globalEntries,
+          linkedMemories: dedupedLinked,
+          totalResults:
+            weightedResults.length + globalEntries.length + dedupedLinked.length,
+        };
+      },
+    },
+  ];
+}