@cogitator-ai/self-modifying 17.0.16 → 17.0.18

package/src/meta-reasoning/meta-reasoner.ts

@@ -106,19 +106,23 @@ export class MetaReasoner {
         );
 
       case 'confidence_drop':
+      case 'on_low_confidence':
         return context.confidence < this.config.triggerOnConfidenceDrop;
 
       case 'progress_stall':
+      case 'on_stagnation':
         return context.stagnationCount >= this.config.triggerOnProgressStall;
 
-      case 'periodic':
-        return (
-          context.iteration > 0 && context.iteration % this.config.triggerAfterIterations === 0
-        );
+      case 'periodic': {
+        const elapsed = Date.now() - lastAssessment;
+        return elapsed >= this.config.metaAssessmentCooldown * this.config.triggerAfterIterations;
+      }
 
+      case 'on_failure':
       case 'tool_call_failed':
         return true;
 
+      case 'on_request':
       case 'explicit_request':
         return true;
 
@@ -293,34 +297,37 @@ export class MetaReasoner {
     return adaptation;
   }
 
-  rollback(runId: string): MetaAdaptation | null {
+  rollback(runId: string, adaptationId?: string): MetaAdaptation | null {
     const runAdaptations = this.adaptations.get(runId) ?? [];
-    const lastAdaptation = runAdaptations[runAdaptations.length - 1];
+    const target = adaptationId
+      ? runAdaptations.find((a) => a.id === adaptationId)
+      : runAdaptations[runAdaptations.length - 1];
 
-    if (!lastAdaptation?.rollbackable) {
+    if (!target?.rollbackable) {
       return null;
     }
 
-    if (lastAdaptation.rollbackDeadline && Date.now() > lastAdaptation.rollbackDeadline) {
+    if (target.rollbackDeadline && Date.now() > target.rollbackDeadline) {
       return null;
     }
 
     const rollback: MetaAdaptation = {
       id: `rollback_${nanoid(10)}`,
-      assessmentId: lastAdaptation.assessmentId,
+      assessmentId: target.assessmentId,
       timestamp: Date.now(),
 
       type: 'rollback',
-      before: lastAdaptation.after,
-      after: lastAdaptation.before,
+      before: target.after,
+      after: target.before,
 
       rollbackable: false,
     };
 
-    if (lastAdaptation.type === 'mode_switch' && lastAdaptation.before.mode) {
-      this.currentMode.set(runId, lastAdaptation.before.mode);
+    if (target.type === 'mode_switch' && target.before.mode) {
+      this.currentMode.set(runId, target.before.mode);
     }
 
+    target.rollbackable = false;
     runAdaptations.push(rollback);
     return rollback;
   }
@@ -337,7 +344,7 @@ export class MetaReasoner {
       adaptation.outcome = outcome;
 
       if (this.config.rollbackOnDecline && !outcome.improved && adaptation.rollbackable) {
-        this.rollback(runId);
+        this.rollback(runId, adaptationId);
       }
     }
   }
@@ -352,7 +359,7 @@ export class MetaReasoner {
   }
 
   getModeConfig(mode: ReasoningMode): ReasoningModeConfig {
-    return this.config.modeProfiles[mode];
+    return this.config.modeProfiles[mode] ?? this.config.modeProfiles[this.config.defaultMode];
   }
 
   getRunStats(runId: string): {

package/src/meta-reasoning/observation-collector.ts

@@ -54,7 +54,11 @@ export class ObservationCollector {
 
   collect(context: ObservationContext, insights: Insight[]): MetaObservation {
     const { runId, iteration, goal, currentMode } = context;
-    const prevObservations = this.observations.get(runId) ?? [];
+    let prevObservations = this.observations.get(runId);
+    if (!prevObservations) {
+      prevObservations = [];
+      this.observations.set(runId, prevObservations);
+    }
     const lastObs = prevObservations[prevObservations.length - 1];
     const actions = this.actionHistory.get(runId) ?? [];
     const confidenceHist = this.confidenceHistory.get(runId) ?? [];
@@ -62,7 +66,7 @@ export class ObservationCollector {
     const currentConfidence = confidenceHist[confidenceHist.length - 1] ?? 0.5;
     const progressScore = this.calculateProgress(actions);
     const progressDelta = lastObs ? progressScore - lastObs.progressScore : 0;
-    const stagnationCount = progressDelta < 0.05 ? (lastObs?.stagnationCount ?? 0) + 1 : 0;
+    const stagnationCount = lastObs ? (progressDelta < 0.05 ? lastObs.stagnationCount + 1 : 0) : 0;
     const repetitionScore = this.calculateRepetition(actions);
     const toolSuccessRate = this.calculateToolSuccessRate(actions);
     const confidenceTrend = this.calculateTrend(confidenceHist);

package/src/meta-reasoning/prompts.ts

@@ -1,4 +1,5 @@
 import type { MetaObservation, ReasoningMode, ReasoningModeConfig } from '@cogitator-ai/types';
+import { extractJson } from '../utils';
 
 export function buildMetaAssessmentPrompt(
   observation: MetaObservation,
@@ -62,20 +63,20 @@ Analyze the agent's reasoning process and respond with a JSON object:
   "reasoning": "string",
   "issues": [
     {
-      "type": "stagnation" | "repetition" | "resource_exhaustion" | "confidence_decline" | "strategy_mismatch" | "goal_drift",
-      "severity": "low" | "medium" | "high" | "critical",
+      "type": "stagnation" | "low_confidence" | "high_cost" | "repetition" | "tool_failure",
+      "severity": "low" | "medium" | "high",
       "description": "string"
     }
   ],
   "opportunities": [
     {
-      "type": "strategy_switch" | "temperature_adjust" | "tool_pivot" | "goal_refinement" | "context_injection",
+      "type": "mode_switch" | "parameter_tune" | "context_add" | "tool_compose",
       "description": "string",
       "expectedImprovement": number
     }
   ],
   "recommendation": {
-    "action": "continue" | "switch_mode" | "adjust_parameters" | "inject_context" | "escalate" | "abort",
+    "action": "continue" | "switch_mode" | "adjust_parameters" | "inject_context" | "abort",
     "newMode": "string",
     "parameterChanges": {},
     "contextAddition": "string",
@@ -119,46 +120,6 @@ export function parseMetaAssessmentResponse(content: string): ParsedAssessment |
   }
 }
 
-function extractJson(text: string): string | null {
-  const start = text.indexOf('{');
-  if (start === -1) return null;
-
-  let depth = 0;
-  let inString = false;
-  let escape = false;
-
-  for (let i = start; i < text.length; i++) {
-    const ch = text[i];
-
-    if (escape) {
-      escape = false;
-      continue;
-    }
-
-    if (ch === '\\' && inString) {
-      escape = true;
-      continue;
-    }
-
-    if (ch === '"') {
-      inString = !inString;
-      continue;
-    }
-
-    if (inString) continue;
-
-    if (ch === '{') depth++;
-    else if (ch === '}') {
-      depth--;
-      if (depth === 0) {
-        return text.slice(start, i + 1);
-      }
-    }
-  }
-
-  return null;
-}
-
 export const META_REASONING_SYSTEM_PROMPT = `You are a meta-reasoning system analyzing an AI agent's reasoning process.
 Your job is to assess whether the agent is on track and recommend strategic adjustments.
 

package/src/meta-reasoning/strategy-selector.ts

@@ -143,6 +143,12 @@ export class StrategySelector {
       if (currentMode === 'intuitive' && alternatives.includes('analytical')) {
         return 'analytical';
       }
+      if (currentMode === 'reflective' && alternatives.includes('intuitive')) {
+        return 'intuitive';
+      }
+      if (currentMode === 'exploratory' && alternatives.includes('analytical')) {
+        return 'analytical';
+      }
 
       return alternatives[0] ?? null;
     }

package/src/self-modifying-agent.ts

@@ -1,3 +1,4 @@
+import { nanoid } from 'nanoid';
 import type {
   Agent,
   AgentConfig,
@@ -9,6 +10,8 @@ import type {
   MetaObservation,
   MetaAdaptation,
   ModificationCheckpoint,
+  AppliedModification,
+  ModificationRequest,
   SelfModifyingEvent,
   CapabilityGap,
   Message,
@@ -44,6 +47,8 @@ export interface RunContext {
   observations: MetaObservation[];
   adaptations: MetaAdaptation[];
   checkpoints: ModificationCheckpoint[];
+  modificationsCount: number;
+  appliedModifications: AppliedModification[];
 }
 
 export class SelfModifyingAgent {
@@ -63,6 +68,7 @@ export class SelfModifyingAgent {
 
   private currentContext: RunContext | null = null;
   private isInitialized = false;
+  private storedExecutableTools: Tool[] = [];
 
   constructor(options: SelfModifyingAgentOptions) {
     this.agent = options.agent;
@@ -145,7 +151,7 @@ export class SelfModifyingAgent {
     const tools = this.getAvailableTools();
 
     const baseConfig: ArchitectureConfig = {
-      model: 'default',
+      model: this.agent.model ?? 'default',
       temperature: 0.7,
       maxTokens: 4096,
       toolStrategy: 'sequential',
@@ -162,6 +168,8 @@ export class SelfModifyingAgent {
       observations: [],
       adaptations: [],
       checkpoints: [],
+      modificationsCount: 0,
+      appliedModifications: [],
     };
 
     void this.emitter.emit({
@@ -172,6 +180,10 @@ export class SelfModifyingAgent {
     });
 
     try {
+      if (this.config.constraints.enabled && this.config.constraints.autoRollback) {
+        await this.createCheckpoint();
+      }
+
       if (this.config.architectureEvolution.enabled) {
         await this.optimizeArchitecture(input);
       }
@@ -215,6 +227,10 @@ export class SelfModifyingAgent {
 
       return result;
     } catch (error) {
+      if (this.config.constraints.enabled && this.config.constraints.autoRollback) {
+        await this.autoRollbackOnError();
+      }
+
       void this.emitter.emit({
         type: 'run_completed',
         runId,
@@ -301,7 +317,7 @@ export class SelfModifyingAgent {
       this.agent.name || 'agent',
       agentConfig,
       this.currentContext.tools,
-      []
+      [...this.currentContext.appliedModifications]
     );
 
     this.currentContext.checkpoints.push(checkpoint);
@@ -322,6 +338,13 @@ export class SelfModifyingAgent {
 
     if (this.currentContext) {
       this.currentContext.tools = restored.tools;
+      this.currentContext.currentConfig = {
+        ...this.currentContext.currentConfig,
+        model: restored.agentConfig.model ?? this.currentContext.currentConfig.model,
+        temperature:
+          restored.agentConfig.temperature ?? this.currentContext.currentConfig.temperature,
+        maxTokens: restored.agentConfig.maxTokens ?? this.currentContext.currentConfig.maxTokens,
+      };
     }
 
     void this.emitter.emit({
@@ -340,7 +363,8 @@ export class SelfModifyingAgent {
   private async ensureInitialized(): Promise<void> {
     if (this.isInitialized) return;
 
-    await this.toolStore.list({ status: 'active' });
+    const activeTools = await this.toolStore.list({ status: 'active' });
+    this.storedExecutableTools = activeTools.map((t) => this.toolGenerator.createExecutableTool(t));
 
     this.isInitialized = true;
   }
@@ -447,7 +471,7 @@ export class SelfModifyingAgent {
   }
 
   private getAvailableTools(): Tool[] {
-    return this.agent.tools ?? [];
+    return [...(this.agent.tools ?? []), ...this.storedExecutableTools];
   }
 
   private async optimizeArchitecture(input: string): Promise<void> {
@@ -456,22 +480,24 @@ export class SelfModifyingAgent {
     try {
       const result = await this.parameterOptimizer.optimize(input);
 
-      if (result.shouldAdopt && result.confidence > 0.6) {
-        const validation = await this.modificationValidator.validate({
+      if (result.shouldAdopt && result.confidence > 0.6 && this.canApplyModification()) {
+        const validation = await this.validateModification({
           type: 'config_change',
           target: 'architecture',
           changes: result.recommendedConfig,
           reason: result.reasoning,
         });
 
-        if (validation.valid) {
+        if (validation) {
           this.currentContext.currentConfig = result.recommendedConfig;
+          this.recordModification('config_change', result.recommendedConfig);
 
           void this.emitter.emit({
             type: 'architecture_evolved',
             runId: this.currentContext.runId,
             timestamp: new Date(),
             data: {
+              success: true,
               candidateId: result.candidate?.id,
               changes: result.recommendedConfig,
               metrics: result.metrics,
@@ -484,7 +510,10 @@ export class SelfModifyingAgent {
         type: 'architecture_evolved',
         runId: this.currentContext.runId,
         timestamp: new Date(),
-        data: { error: error instanceof Error ? error.message : String(error) },
+        data: {
+          success: false,
+          error: error instanceof Error ? error.message : String(error),
+        },
       });
     }
   }
@@ -496,6 +525,12 @@ export class SelfModifyingAgent {
       const analysis = await this.gapAnalyzer.analyze(input, this.currentContext.tools);
 
       for (const gap of analysis.gaps) {
+        if (
+          this.currentContext.generatedTools.length >= this.config.toolGeneration.maxToolsPerSession
+        ) {
+          break;
+        }
+
         if (gap.confidence >= this.config.toolGeneration.minConfidenceForGeneration) {
           void this.emitter.emit({
             type: 'tool_generation_started',
@@ -506,11 +541,41 @@ export class SelfModifyingAgent {
 
           const tool = await this.generateTool(gap);
 
-          if (tool) {
-            this.currentContext.generatedTools.push(tool);
-            const executableTool = this.toolGenerator.createExecutableTool(tool);
-            this.currentContext.tools.push(executableTool);
+          if (!tool) continue;
+
+          const linesOfCode = tool.implementation.split('\n').length;
+          const validated = await this.validateModification({
+            type: 'tool_generation',
+            target: tool.name,
+            changes: { name: tool.name, implementation: tool.implementation },
+            reason: `Generated tool for gap: ${gap.suggestedToolName}`,
+            payload: {
+              sandboxExecution: this.config.toolGeneration.sandboxConfig?.enabled ?? false,
+              linesOfCode,
+              complexity: linesOfCode,
+              modificationDepth: 1,
+            },
+          });
+
+          if (!validated || !this.canApplyModification()) {
+            void this.emitter.emit({
+              type: 'tool_generation_completed',
+              runId: this.currentContext.runId,
+              timestamp: new Date(),
+              data: {
+                toolId: tool.id,
+                name: tool.name,
+                success: false,
+                error: 'Rejected by safety constraints or modification limit',
+              },
+            });
+            continue;
           }
+
+          this.currentContext.generatedTools.push(tool);
+          const executableTool = this.toolGenerator.createExecutableTool(tool);
+          this.currentContext.tools.push(executableTool);
+          this.recordModification('tool_generation', { toolId: tool.id, name: tool.name });
         }
       }
     } catch (error) {
@@ -693,6 +758,49 @@ export class SelfModifyingAgent {
     });
   }
 
+  private async validateModification(request: ModificationRequest): Promise<boolean> {
+    if (!this.config.constraints.enabled) return true;
+
+    const validation = await this.modificationValidator.validate(request);
+
+    if (validation.rollbackRequired && this.config.constraints.autoRollback) {
+      await this.autoRollbackOnError();
+    }
+
+    return validation.valid;
+  }
+
+  private canApplyModification(): boolean {
+    if (!this.config.constraints.enabled) return true;
+    if (!this.currentContext) return true;
+    return this.currentContext.modificationsCount < this.config.constraints.maxModificationsPerRun;
+  }
+
+  private recordModification(type: string, data: unknown): void {
+    if (!this.currentContext) return;
+    this.currentContext.modificationsCount++;
+    this.currentContext.appliedModifications.push({
+      id: `mod_${nanoid(8)}`,
+      type,
+      appliedAt: new Date(),
+      data,
+    });
+  }
+
+  private async autoRollbackOnError(): Promise<void> {
+    if (!this.currentContext) return;
+
+    const now = Date.now();
+    const window = this.config.constraints.rollbackWindow;
+    const target = this.currentContext.checkpoints
+      .filter((c) => now - c.timestamp.getTime() <= window)
+      .sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime())[0];
+
+    if (target) {
+      await this.rollbackToCheckpoint(target.id);
+    }
+  }
+
   private estimateConfidence(output: string): number {
     if (!output) return 0.3;
     if (output.length < 50) return 0.4;
@@ -700,7 +808,8 @@ export class SelfModifyingAgent {
     return 0.8;
   }
 
-  private isTaskComplete(_output: string): boolean {
-    return true;
+  private isTaskComplete(output: string): boolean {
+    if (!output.trim()) return false;
+    return this.estimateConfidence(output) >= 0.6;
   }
 }

package/src/tool-generation/gap-analyzer.ts

@@ -1,3 +1,4 @@
+import { createHash } from 'node:crypto';
 import type {
   Tool,
   LLMBackend,
@@ -151,7 +152,6 @@ Consider tool composition before suggesting new tools.`,
       return 1.0;
     }
 
-    const _intentWords = userIntent.toLowerCase().split(/\s+/).length;
     const toolDescriptionWords = availableTools
       .map((t) => t.description.toLowerCase().split(/\s+/))
       .flat();
@@ -222,7 +222,8 @@ Consider tool composition before suggesting new tools.`,
       .map((t) => t.name)
       .sort()
       .join(',');
-    return `${userIntent.slice(0, 100)}|${toolSignature}`;
+    const raw = `${userIntent}|${toolSignature}`;
+    return createHash('sha256').update(raw).digest('hex');
   }
 
   clearCache(): void {

package/src/tool-generation/generated-tool-store.ts

@@ -1,5 +1,78 @@
 import type { GeneratedTool, GeneratedToolStore as IGeneratedToolStore } from '@cogitator-ai/types';
 
+const STOP_WORDS = new Set([
+  'the',
+  'and',
+  'for',
+  'not',
+  'are',
+  'was',
+  'were',
+  'been',
+  'being',
+  'have',
+  'has',
+  'had',
+  'does',
+  'did',
+  'will',
+  'would',
+  'could',
+  'should',
+  'may',
+  'might',
+  'shall',
+  'can',
+  'this',
+  'that',
+  'these',
+  'those',
+  'with',
+  'from',
+  'into',
+  'through',
+  'during',
+  'before',
+  'after',
+  'above',
+  'below',
+  'between',
+  'under',
+  'over',
+  'again',
+  'further',
+  'then',
+  'once',
+  'here',
+  'there',
+  'when',
+  'where',
+  'why',
+  'how',
+  'all',
+  'each',
+  'every',
+  'both',
+  'few',
+  'more',
+  'most',
+  'other',
+  'some',
+  'such',
+  'only',
+  'own',
+  'same',
+  'than',
+  'too',
+  'very',
+  'just',
+  'because',
+  'but',
+  'nor',
+  'yet',
+  'about',
+]);
+
 export interface ToolUsageRecord {
   toolId: string;
   timestamp: Date;
@@ -25,7 +98,7 @@ export class InMemoryGeneratedToolStore implements IGeneratedToolStore {
 
   async save(tool: GeneratedTool): Promise<void> {
     const existing = this.tools.get(tool.id);
-    const version = existing ? existing.version + 1 : tool.version;
+    const version = existing ? existing.version + 1 : 1;
     this.tools.set(tool.id, { ...tool, version, updatedAt: new Date() });
   }
 
@@ -140,17 +213,27 @@ export class InMemoryGeneratedToolStore implements IGeneratedToolStore {
   }
 
   async findSimilar(description: string, limit: number = 5): Promise<GeneratedTool[]> {
-    const descWords = new Set(description.toLowerCase().split(/\s+/));
+    const descWords = new Set(
+      description
+        .toLowerCase()
+        .split(/\s+/)
+        .filter((w) => w.length >= 3 && !STOP_WORDS.has(w))
+    );
     const scored: Array<{ tool: GeneratedTool; score: number }> = [];
 
     for (const tool of this.tools.values()) {
       if (tool.status === 'deprecated') continue;
 
-      const toolWords = new Set(`${tool.name} ${tool.description}`.toLowerCase().split(/\s+/));
+      const toolWords = new Set(
+        `${tool.name} ${tool.description}`
+          .toLowerCase()
+          .split(/\s+/)
+          .filter((w) => w.length >= 3 && !STOP_WORDS.has(w))
+      );
 
       let matchCount = 0;
       for (const word of descWords) {
-        if (word.length >= 3 && toolWords.has(word)) {
+        if (toolWords.has(word)) {
           matchCount++;
         }
       }
@@ -204,13 +287,13 @@ export class InMemoryGeneratedToolStore implements IGeneratedToolStore {
     let removed = 0;
     const now = Date.now();
 
+    const keysToRemove: string[] = [];
+
     for (const [id, tool] of this.tools) {
       if (options.maxAge && tool.createdAt) {
         const age = now - tool.createdAt.getTime();
         if (age > options.maxAge && tool.status !== 'active') {
-          this.tools.delete(id);
-          this.usageRecords.delete(id);
-          removed++;
+          keysToRemove.push(id);
           continue;
         }
       }
@@ -218,13 +301,17 @@ export class InMemoryGeneratedToolStore implements IGeneratedToolStore {
       if (options.minUsage !== undefined) {
         const usage = tool.usageCount || 0;
         if (usage < options.minUsage && tool.status === 'deprecated') {
-          this.tools.delete(id);
-          this.usageRecords.delete(id);
-          removed++;
+          keysToRemove.push(id);
         }
       }
     }
 
+    for (const id of keysToRemove) {
+      this.tools.delete(id);
+      this.usageRecords.delete(id);
+      removed++;
+    }
+
     if (options.maxDeprecated !== undefined) {
       const deprecated = Array.from(this.tools.values())
         .filter((t) => t.status === 'deprecated')

package/src/tool-generation/index.ts

@@ -1,7 +1,7 @@
 export { GapAnalyzer, type GapAnalyzerOptions } from './gap-analyzer';
 export { ToolGenerator, type ToolGeneratorOptions, type GenerationResult } from './tool-generator';
 export { ToolValidator, type ToolValidatorOptions } from './tool-validator';
-export { ToolSandbox, DEFAULT_SANDBOX_CONFIG } from './tool-sandbox';
+export { ToolSandbox, DEFAULT_SANDBOX_CONFIG, deepEqual } from './tool-sandbox';
 export {
   InMemoryGeneratedToolStore,
   type ToolUsageRecord,