@soleri/core 2.4.0 → 2.6.0

package/src/runtime/loop-ops.ts

@@ -1,14 +1,15 @@
 /**
- * Loop operations — 7 ops for iterative validation loops.
+ * Loop operations — 9 ops for iterative validation loops.
  *
- * Ops: loop_start, loop_iterate, loop_status, loop_cancel,
- *      loop_history, loop_is_active, loop_complete.
+ * Ops: loop_start, loop_iterate, loop_iterate_gate, loop_status,
+ *      loop_cancel, loop_history, loop_is_active, loop_complete,
+ *      loop_anomaly_check.
  */
 
 import { z } from 'zod';
 import type { OpDefinition } from '../facades/types.js';
 import type { AgentRuntime } from './types.js';
-import type { LoopMode } from '../loop/types.js';
+import type { LoopMode, LoopKnowledge } from '../loop/types.js';
 
 const loopModeSchema = z.enum([
   'token-migration',
@@ -39,7 +40,7 @@ const DEFAULT_TARGET_SCORES: Partial<Record<LoopMode, number>> = {
 };
 
 /**
- * Create the 7 loop operations for an agent runtime.
+ * Create the 9 loop operations for an agent runtime.
  */
 export function createLoopOps(runtime: AgentRuntime): OpDefinition[] {
   const { loop } = runtime;
@@ -61,6 +62,22 @@ export function createLoopOps(runtime: AgentRuntime): OpDefinition[] {
           .number()
           .optional()
           .describe('Target validation score (0-100). Defaults vary by mode.'),
+        targetGrade: z
+          .string()
+          .optional()
+          .describe('Target grade for plan-iteration mode (e.g., "A", "A+").'),
+        completionPromise: z
+          .string()
+          .optional()
+          .describe('Completion promise text — loop completes when this appears in output.'),
+        validationInstructions: z
+          .string()
+          .optional()
+          .describe('Validation instructions appended to the prompt each iteration.'),
+        intent: z
+          .string()
+          .optional()
+          .describe('Detected intent for brain session recording (e.g., "BUILD", "FIX").'),
       }),
       handler: async (params) => {
         const mode = params.mode as LoopMode;
@@ -75,6 +92,10 @@ export function createLoopOps(runtime: AgentRuntime): OpDefinition[] {
           prompt,
           maxIterations,
           targetScore,
+          targetGrade: params.targetGrade as string | undefined,
+          completionPromise: params.completionPromise as string | undefined,
+          validationInstructions: params.validationInstructions as string | undefined,
+          intent: params.intent as string | undefined,
         });
 
         return {
@@ -93,14 +114,8 @@ export function createLoopOps(runtime: AgentRuntime): OpDefinition[] {
       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.'),
+        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({
@@ -119,6 +134,37 @@ export function createLoopOps(runtime: AgentRuntime): OpDefinition[] {
         };
       },
     },
+    {
+      name: 'loop_iterate_gate',
+      description:
+        'Gate-based loop iteration — accepts LLM output, scans for completion signals ' +
+        '(promise tags, heuristic detection), and returns allow/block decision. ' +
+        'Primary method for Stop hook integration.',
+      auth: 'write',
+      schema: z.object({
+        lastOutput: z.string().describe('The LLM response to scan for completion signals.'),
+        knowledge: z
+          .object({
+            items: z.array(z.string()).optional(),
+            patternsApplied: z.array(z.string()).optional(),
+            antiPatternsAvoided: z.array(z.string()).optional(),
+          })
+          .optional()
+          .describe('Knowledge items discovered during this iteration.'),
+        durationMs: z
+          .number()
+          .optional()
+          .describe('Duration of this iteration in milliseconds (for anomaly detection).'),
+      }),
+      handler: async (params) => {
+        const decision = loop.iterateWithGate(
+          params.lastOutput as string,
+          params.knowledge as LoopKnowledge | undefined,
+          params.durationMs as number | undefined,
+        );
+        return decision;
+      },
+    },
     {
       name: 'loop_status',
       description: 'Get current loop status, config, and iteration history.',
@@ -190,5 +236,42 @@ export function createLoopOps(runtime: AgentRuntime): OpDefinition[] {
         };
       },
     },
+    {
+      name: 'loop_anomaly_check',
+      description:
+        'Check active loop iterations for anomalous patterns — fast iterations with low scores, repeated failures, no-progress loops.',
+      auth: 'read',
+      handler: async () => {
+        const status = loop.getStatus();
+        if (!status) {
+          return { active: false, anomalies: [], summary: 'No active loop' };
+        }
+
+        const { detectAnomaly } = await import('../loop/loop-manager.js');
+        const anomalies: string[] = [];
+
+        for (const iter of status.iterations) {
+          const warning = detectAnomaly(iter, status.config.mode);
+          if (warning) anomalies.push(warning);
+        }
+
+        // Check for repeated failures (3+ consecutive non-passing iterations)
+        const recent = status.iterations.slice(-3);
+        if (recent.length >= 3 && recent.every((i) => !i.passed)) {
+          anomalies.push(
+            `Warning: ${recent.length} consecutive failing iterations — consider cancelling or adjusting approach`,
+          );
+        }
+
+        return {
+          active: true,
+          loopId: status.id,
+          mode: status.config.mode,
+          totalIterations: status.iterations.length,
+          anomalies,
+          hasAnomalies: anomalies.length > 0,
+        };
+      },
+    },
   ];
 }

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

@@ -183,8 +183,7 @@ export function createMemoryCrossProjectOps(runtime: AgentRuntime): OpDefinition
           memories: weightedResults,
           globalEntries,
           linkedMemories: dedupedLinked,
-          totalResults:
-            weightedResults.length + globalEntries.length + dedupedLinked.length,
+          totalResults: weightedResults.length + globalEntries.length + dedupedLinked.length,
         };
       },
     },

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

@@ -64,7 +64,10 @@ export function createMemoryExtraOps(runtime: AgentRuntime): OpDefinition[] {
       auth: 'read',
       schema: z.object({
         projectPath: z.string().optional().describe('Filter to a specific project'),
-        type: z.enum(['session', 'lesson', 'preference']).optional().describe('Filter by memory type'),
+        type: z
+          .enum(['session', 'lesson', 'preference'])
+          .optional()
+          .describe('Filter by memory type'),
         includeArchived: z
           .boolean()
           .optional()
@@ -126,10 +129,7 @@ export function createMemoryExtraOps(runtime: AgentRuntime): OpDefinition[] {
         'Delete non-archived memories older than N days. Destructive — cannot be undone.',
       auth: 'admin',
       schema: z.object({
-        olderThanDays: z
-          .number()
-          .min(1)
-          .describe('Delete memories older than this many days'),
+        olderThanDays: z.number().min(1).describe('Delete memories older than this many days'),
       }),
       handler: async (params) => {
         const days = params.olderThanDays as number;

package/src/runtime/orchestrate-ops.ts

@@ -31,7 +31,10 @@ export function createOrchestrateOps(runtime: AgentRuntime): OpDefinition[] {
       schema: z.object({
         objective: z.string().describe('What the plan aims to achieve'),
         scope: z.string().describe('Boundaries of the work'),
-        domain: z.string().optional().describe('Domain for brain recommendations (e.g. "component", "styling")'),
+        domain: z
+          .string()
+          .optional()
+          .describe('Domain for brain recommendations (e.g. "component", "styling")'),
         tasks: z
           .array(z.object({ title: z.string(), description: z.string() }))
           .optional()
@@ -168,7 +171,10 @@ export function createOrchestrateOps(runtime: AgentRuntime): OpDefinition[] {
       auth: 'read',
       schema: z.object({
         domain: z.string().optional().describe('Filter recommendations by domain'),
-        sessionLimit: z.number().optional().describe('Number of recent sessions to include (default 5)'),
+        sessionLimit: z
+          .number()
+          .optional()
+          .describe('Number of recent sessions to include (default 5)'),
       }),
       handler: async (params) => {
         const domain = params.domain as string | undefined;