@cogitator-ai/self-modifying 17.0.18 → 19.0.0

package/src/constraints/modification-validator.ts

@@ -74,6 +74,9 @@ export class ModificationValidator {
     const results: ConstraintCheckResult[] = [];
 
     for (const constraint of this.constraints.safety) {
+      if (constraint.appliesTo && !constraint.appliesTo.includes(request.type)) {
+        continue;
+      }
       const satisfied = this.evaluateSafetyRule(constraint.rule, request);
       results.push({
         constraintId: constraint.id,
@@ -88,11 +91,12 @@ export class ModificationValidator {
   }
 
   private evaluateSafetyRule(rule: ConstraintRule, request: ModificationRequest): boolean {
+    const context = this.payloadOf(request);
+
     if (typeof rule === 'string') {
-      return this.evaluateExpression(rule, request.payload as Record<string, unknown>);
+      return this.evaluateExpression(rule, context);
     }
 
-    const context = request.payload as Record<string, unknown>;
     const checks: boolean[] = [];
 
     if (rule.expression) {
@@ -170,10 +174,20 @@ export class ModificationValidator {
     return Boolean(value);
   }
 
+  private payloadOf(request: ModificationRequest): Record<string, unknown> {
+    const payload = request.payload;
+    return payload && typeof payload === 'object' && !Array.isArray(payload)
+      ? (payload as Record<string, unknown>)
+      : {};
+  }
+
   private resolveValue(expr: string, context: Record<string, unknown>): unknown {
     if (expr === 'true') return true;
     if (expr === 'false') return false;
-    if (/^\d+(\.\d+)?$/.test(expr)) return parseFloat(expr);
+    if (expr === 'null') return null;
+    if (/^-?\d+(\.\d+)?$/.test(expr)) return parseFloat(expr);
+    const quoted = /^(['"])(.*)\1$/.exec(expr);
+    if (quoted) return quoted[2];
 
     const keys = expr.split('.');
     let current: unknown = context;
@@ -196,30 +210,32 @@ export class ModificationValidator {
       return results;
     }
 
-    const payload = request.payload as { category?: string; complexity?: number };
+    const payload = this.payloadOf(request) as { category?: unknown; complexity?: unknown };
+    const category = typeof payload.category === 'string' ? payload.category : undefined;
+    const complexity = typeof payload.complexity === 'number' ? payload.complexity : undefined;
 
     for (const constraint of this.constraints.capability) {
       let satisfied = true;
       let message: string | undefined;
 
-      if (payload.category) {
-        if (constraint.forbidden?.includes(payload.category)) {
+      if (category) {
+        if (constraint.forbidden?.includes(category)) {
           satisfied = false;
-          message = `Category '${payload.category}' is forbidden`;
-        } else if (constraint.allowed?.length && !constraint.allowed.includes(payload.category)) {
+          message = `Category '${category}' is forbidden`;
+        } else if (constraint.allowed?.length && !constraint.allowed.includes(category)) {
           satisfied = false;
-          message = `Category '${payload.category}' is not in allowed list`;
+          message = `Category '${category}' is not in allowed list`;
         }
       }
 
       if (
         satisfied &&
-        constraint.maxComplexity &&
-        payload.complexity &&
-        payload.complexity > constraint.maxComplexity
+        constraint.maxComplexity !== undefined &&
+        complexity !== undefined &&
+        complexity > constraint.maxComplexity
       ) {
         satisfied = false;
-        message = `Complexity ${payload.complexity} exceeds max ${constraint.maxComplexity}`;
+        message = `Complexity ${complexity} exceeds max ${constraint.maxComplexity}`;
       }
 
       results.push({
@@ -238,7 +254,7 @@ export class ModificationValidator {
     request: ModificationRequest
   ): Promise<ConstraintCheckResult[]> {
     const results: ConstraintCheckResult[] = [];
-    const payload = (request.payload ?? {}) as {
+    const payload = this.payloadOf(request) as {
       tokensUsed?: number;
       cost?: number;
       activeTools?: number;

package/src/index.ts

@@ -1,6 +1,9 @@
 export {
   SelfModifyingAgent,
   type SelfModifyingAgentOptions,
+  type SelfModifyingAgentConfig,
+  type SelfModifyingEventDataMap,
+  type TypedSelfModifyingEvent,
   type RunContext,
 } from './self-modifying-agent';
 
@@ -15,11 +18,16 @@ export {
   buildGapAnalysisPrompt,
   buildToolGenerationPrompt,
   buildToolValidationPrompt,
+  buildToolImprovementPrompt,
   parseGapAnalysisResponse,
   parseToolGenerationResponse,
+  parseValidationResponse,
   type GapAnalyzerOptions,
   type ToolGeneratorOptions,
   type ToolValidatorOptions,
+  type ValidationRule,
+  type SandboxTestCase,
+  type GenerateOptions,
   type GenerationResult,
   type ToolUsageRecord,
   type ToolMetrics,
@@ -48,13 +56,17 @@ export {
   ARCHITECTURE_ANALYSIS_SYSTEM_PROMPT,
   buildTaskProfilePrompt,
   buildCandidateGenerationPrompt,
+  buildPerformanceAnalysisPrompt,
   parseTaskProfileResponse,
   parseCandidateGenerationResponse,
+  parsePerformanceAnalysisResponse,
+  sanitizeCandidateConfig,
   type CapabilityAnalyzerOptions,
   type EvolutionStrategyOptions,
   type ParameterOptimizerOptions,
   type SelectionResult,
   type OptimizationResult,
+  type HistoricalRecord,
 } from './architecture-evolution';
 
 export {
@@ -64,6 +76,8 @@ export {
   DEFAULT_SAFETY_CONSTRAINTS,
   DEFAULT_CAPABILITY_CONSTRAINTS,
   DEFAULT_RESOURCE_CONSTRAINTS,
+  createDefaultConstraints,
+  mergeConstraints,
   mergeSafetyConstraints,
   mergeCapabilityConstraints,
   mergeResourceConstraints,

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

@@ -10,8 +10,6 @@ import type {
   ReasoningModeConfig,
   Insight,
   LLMBackend,
-  MetaIssue,
-  MetaOpportunity,
 } from '@cogitator-ai/types';
 import { DEFAULT_META_REASONING_CONFIG } from '@cogitator-ai/types';
 import {
@@ -28,6 +26,17 @@ import {
 
 export { DEFAULT_META_REASONING_CONFIG };
 
+const TRIGGER_ALIASES: Partial<Record<MetaTrigger, MetaTrigger>> = {
+  confidence_drop: 'on_low_confidence',
+  progress_stall: 'on_stagnation',
+  tool_call_failed: 'on_failure',
+  explicit_request: 'on_request',
+};
+
+function canonicalTrigger(trigger: MetaTrigger): MetaTrigger {
+  return TRIGGER_ALIASES[trigger] ?? trigger;
+}
+
 export interface MetaReasonerOptions {
   llm: LLMBackend;
   model: string;
@@ -44,6 +53,8 @@ export class MetaReasoner {
   private assessments = new Map<string, MetaAssessment[]>();
   private adaptations = new Map<string, MetaAdaptation[]>();
   private currentMode = new Map<string, ReasoningMode>();
+  private parameterOverrides = new Map<string, Partial<ReasoningModeConfig>>();
+  private overridesBefore = new Map<string, Partial<ReasoningModeConfig>>();
 
   private lastAssessmentTime = new Map<string, number>();
   private lastAdaptationTime = new Map<string, number>();
@@ -51,7 +62,14 @@ export class MetaReasoner {
   constructor(options: MetaReasonerOptions) {
     this.llm = options.llm;
     this.model = options.model;
-    this.config = { ...DEFAULT_META_REASONING_CONFIG, ...options.config } as MetaReasoningConfig;
+    this.config = {
+      ...DEFAULT_META_REASONING_CONFIG,
+      ...options.config,
+      modeProfiles: {
+        ...DEFAULT_META_REASONING_CONFIG.modeProfiles,
+        ...options.config?.modeProfiles,
+      },
+    };
 
     this.collector = new ObservationCollector();
     this.selector = new StrategySelector({
@@ -65,10 +83,17 @@ export class MetaReasoner {
     this.assessments.set(runId, []);
     this.adaptations.set(runId, []);
     this.currentMode.set(runId, this.config.defaultMode);
+    this.parameterOverrides.delete(runId);
 
     return this.getModeConfig(this.config.defaultMode);
   }
 
+  isTriggerEnabled(trigger: MetaTrigger): boolean {
+    const canonical = canonicalTrigger(trigger);
+    if (canonical === 'on_request') return true;
+    return this.config.triggers.some((t) => canonicalTrigger(t) === canonical);
+  }
+
   recordAction(runId: string, action: ActionRecord): void {
     this.collector.recordAction(runId, action);
   }
@@ -88,6 +113,7 @@ export class MetaReasoner {
     }
   ): boolean {
     if (!this.config.enabled) return false;
+    if (!this.isTriggerEnabled(trigger)) return false;
 
     const lastAssessment = this.lastAssessmentTime.get(runId) ?? 0;
     if (Date.now() - lastAssessment < this.config.metaAssessmentCooldown) {
@@ -155,6 +181,7 @@ export class MetaReasoner {
     });
 
     const parsed = parseMetaAssessmentResponse(response.content);
+    const recommendation = this.buildRecommendation(parsed, observation);
 
     const assessment: MetaAssessment = {
       id: `meta_${nanoid(10)}`,
@@ -165,18 +192,16 @@ export class MetaReasoner {
       confidence: parsed?.confidence ?? 0.5,
       reasoning: parsed?.reasoning ?? 'Assessment unavailable',
 
-      issues: (parsed?.issues ?? []) as MetaIssue[],
+      issues: parsed?.issues ?? [],
       opportunities: (parsed?.opportunities ?? []).map((o) => ({
-        type: o.type as MetaOpportunity['type'],
-        confidence: o.expectedImprovement ?? 0.5,
+        type: o.type,
+        confidence: o.expectedImprovement,
         description: o.description,
-      })) as MetaOpportunity[],
+      })),
 
-      recommendation: this.buildRecommendation(parsed, observation),
+      recommendation,
 
-      requiresAdaptation:
-        parsed?.recommendation?.action !== undefined &&
-        parsed?.recommendation?.action !== 'continue',
+      requiresAdaptation: recommendation.action !== 'continue',
 
       assessmentDuration: Date.now() - startTime,
       assessmentCost: (response.usage?.outputTokens ?? 0) * 0.00001,
@@ -211,16 +236,7 @@ export class MetaReasoner {
       };
     }
 
-    return {
-      action: parsed.recommendation.action as MetaRecommendation['action'],
-      newMode: parsed.recommendation.newMode as ReasoningMode | undefined,
-      parameterChanges: parsed.recommendation.parameterChanges as
-        | Partial<ReasoningModeConfig>
-        | undefined,
-      contextAddition: parsed.recommendation.contextAddition,
-      confidence: parsed.recommendation.confidence,
-      reasoning: parsed.recommendation.reasoning,
-    };
+    return { ...parsed.recommendation };
   }
 
   async adapt(runId: string, assessment: MetaAssessment): Promise<MetaAdaptation | null> {
@@ -239,38 +255,62 @@ export class MetaReasoner {
       return null;
     }
 
-    const adaptationCount = this.adaptations.get(runId)?.length ?? 0;
+    const adaptationCount = (this.adaptations.get(runId) ?? []).filter(
+      (a) => a.type !== 'rollback'
+    ).length;
     if (adaptationCount >= this.config.maxAdaptations) {
       return null;
     }
 
     const currentMode = this.currentMode.get(runId) ?? this.config.defaultMode;
-    const currentConfig = this.getModeConfig(currentMode);
+    const currentConfig = this.getCurrentConfig(runId);
 
-    let newConfig: Partial<ReasoningModeConfig> = {};
-    let adaptationType: MetaAdaptation['type'] = 'parameter_change';
+    let newConfig: Partial<ReasoningModeConfig>;
+    let adaptationType: MetaAdaptation['type'];
+    let newMode = currentMode;
+    const previousOverrides = this.parameterOverrides.get(runId);
 
     switch (recommendation.action) {
-      case 'switch_mode':
-        if (recommendation.newMode && this.config.allowedModes.includes(recommendation.newMode)) {
-          newConfig = this.getModeConfig(recommendation.newMode);
-          adaptationType = 'mode_switch';
-          this.currentMode.set(runId, recommendation.newMode);
+      case 'switch_mode': {
+        const target = recommendation.newMode;
+        if (!target || target === currentMode || !this.config.allowedModes.includes(target)) {
+          return null;
         }
+        newConfig = this.getModeConfig(target);
+        adaptationType = 'mode_switch';
+        newMode = target;
+        this.currentMode.set(runId, target);
+        this.parameterOverrides.delete(runId);
         break;
+      }
 
-      case 'adjust_parameters':
-        if (recommendation.parameterChanges) {
-          newConfig = { ...currentConfig, ...recommendation.parameterChanges };
-          adaptationType = 'parameter_change';
+      case 'adjust_parameters': {
+        const changes = recommendation.parameterChanges;
+        if (!changes) return null;
+        const effective: Partial<ReasoningModeConfig> = {};
+        if (
+          changes.temperature !== undefined &&
+          changes.temperature !== currentConfig.temperature
+        ) {
+          effective.temperature = changes.temperature;
+        }
+        if (changes.depth !== undefined && changes.depth !== currentConfig.depth) {
+          effective.depth = changes.depth;
         }
+        if (Object.keys(effective).length === 0) return null;
+        newConfig = { ...currentConfig, ...effective };
+        adaptationType = 'parameter_change';
+        this.parameterOverrides.set(runId, { ...previousOverrides, ...effective });
         break;
+      }
 
       case 'inject_context':
+        if (!recommendation.contextAddition) return null;
+        newConfig = { ...currentConfig };
         adaptationType = 'context_injection';
         break;
 
-      case 'abort':
+      default:
         return null;
     }
 
@@ -282,6 +322,9 @@ export class MetaReasoner {
       type: adaptationType,
       before: currentConfig,
       after: newConfig,
+      previousMode: currentMode,
+      newMode,
+      reason: recommendation.reasoning || undefined,
 
       rollbackable: this.config.enableRollback,
       rollbackDeadline: this.config.enableRollback
@@ -289,6 +332,10 @@ export class MetaReasoner {
         : undefined,
     };
 
+    if (previousOverrides) {
+      this.overridesBefore.set(adaptation.id, previousOverrides);
+    }
+
     const runAdaptations = this.adaptations.get(runId) ?? [];
     runAdaptations.push(adaptation);
     this.adaptations.set(runId, runAdaptations);
@@ -301,7 +348,7 @@ export class MetaReasoner {
     const runAdaptations = this.adaptations.get(runId) ?? [];
     const target = adaptationId
       ? runAdaptations.find((a) => a.id === adaptationId)
-      : runAdaptations[runAdaptations.length - 1];
+      : [...runAdaptations].reverse().find((a) => a.type !== 'rollback');
 
     if (!target?.rollbackable) {
       return null;
@@ -319,15 +366,29 @@ export class MetaReasoner {
       type: 'rollback',
       before: target.after,
       after: target.before,
+      previousMode: target.newMode,
+      newMode: target.previousMode,
+      reason: `Rollback of ${target.id}`,
+      isRollback: true,
 
       rollbackable: false,
     };
 
-    if (target.type === 'mode_switch' && target.before.mode) {
-      this.currentMode.set(runId, target.before.mode);
+    if (target.type === 'mode_switch' || target.type === 'parameter_change') {
+      const restoredMode = target.previousMode ?? target.before.mode;
+      if (restoredMode) {
+        this.currentMode.set(runId, restoredMode);
+      }
+      const restoredOverrides = this.overridesBefore.get(target.id);
+      if (restoredOverrides) {
+        this.parameterOverrides.set(runId, restoredOverrides);
+      } else {
+        this.parameterOverrides.delete(runId);
+      }
     }
 
     target.rollbackable = false;
+    this.overridesBefore.delete(target.id);
     runAdaptations.push(rollback);
     return rollback;
   }
@@ -351,7 +412,7 @@ export class MetaReasoner {
 
   getCurrentConfig(runId: string): ReasoningModeConfig {
     const mode = this.currentMode.get(runId) ?? this.config.defaultMode;
-    return this.getModeConfig(mode);
+    return { ...this.getModeConfig(mode), ...this.parameterOverrides.get(runId) };
   }
 
   getCurrentMode(runId: string): ReasoningMode {
@@ -384,9 +445,13 @@ export class MetaReasoner {
     this.collector.cleanupRun(runId);
     this.selector.cleanupRun(runId);
     this.assessments.delete(runId);
-    this.adaptations.delete(runId);
     this.currentMode.delete(runId);
+    this.parameterOverrides.delete(runId);
     this.lastAssessmentTime.delete(runId);
     this.lastAdaptationTime.delete(runId);
+    for (const adaptation of this.adaptations.get(runId) ?? []) {
+      this.overridesBefore.delete(adaptation.id);
+    }
+    this.adaptations.delete(runId);
   }
 }

package/src/meta-reasoning/prompts.ts

@@ -1,4 +1,11 @@
-import type { MetaObservation, ReasoningMode, ReasoningModeConfig } from '@cogitator-ai/types';
+import type {
+  MetaIssue,
+  MetaObservation,
+  MetaOpportunity,
+  MetaRecommendation,
+  ReasoningMode,
+  ReasoningModeConfig,
+} from '@cogitator-ai/types';
 import { extractJson } from '../utils';
 
 export function buildMetaAssessmentPrompt(
@@ -86,38 +93,145 @@ Analyze the agent's reasoning process and respond with a JSON object:
 }`;
 }
 
+const REASONING_MODES: readonly ReasoningMode[] = [
+  'analytical',
+  'creative',
+  'systematic',
+  'intuitive',
+  'reflective',
+  'exploratory',
+];
+const ISSUE_TYPES: readonly MetaIssue['type'][] = [
+  'stagnation',
+  'low_confidence',
+  'high_cost',
+  'repetition',
+  'tool_failure',
+];
+const SEVERITIES: readonly MetaIssue['severity'][] = ['low', 'medium', 'high'];
+const OPPORTUNITY_TYPES: readonly MetaOpportunity['type'][] = [
+  'mode_switch',
+  'parameter_tune',
+  'context_add',
+  'tool_compose',
+];
+const ACTIONS: readonly MetaRecommendation['action'][] = [
+  'continue',
+  'switch_mode',
+  'adjust_parameters',
+  'inject_context',
+  'abort',
+];
+
 export interface ParsedAssessment {
-  onTrack: boolean;
-  confidence: number;
-  reasoning: string;
-  issues: Array<{
-    type: string;
-    severity: string;
-    description: string;
-  }>;
+  onTrack?: boolean;
+  confidence?: number;
+  reasoning?: string;
+  issues: MetaIssue[];
   opportunities: Array<{
-    type: string;
+    type: MetaOpportunity['type'];
     description: string;
     expectedImprovement: number;
   }>;
-  recommendation: {
-    action: string;
-    newMode?: string;
-    parameterChanges?: Record<string, unknown>;
+  recommendation?: {
+    action: MetaRecommendation['action'];
+    newMode?: ReasoningMode;
+    parameterChanges?: Partial<ReasoningModeConfig>;
     contextAddition?: string;
     confidence: number;
     reasoning: string;
   };
 }
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function pick<T extends string>(value: unknown, allowed: readonly T[]): T | undefined {
+  return typeof value === 'string' && (allowed as readonly string[]).includes(value)
+    ? (value as T)
+    : undefined;
+}
+
+function probability(value: unknown): number | undefined {
+  return typeof value === 'number' && Number.isFinite(value)
+    ? Math.min(1, Math.max(0, value))
+    : undefined;
+}
+
+function parseParameterChanges(value: unknown): Partial<ReasoningModeConfig> | undefined {
+  if (!isRecord(value)) return undefined;
+  const changes: Partial<ReasoningModeConfig> = {};
+  if (typeof value.temperature === 'number' && Number.isFinite(value.temperature)) {
+    changes.temperature = Math.min(2, Math.max(0, value.temperature));
+  }
+  if (typeof value.depth === 'number' && Number.isFinite(value.depth)) {
+    changes.depth = Math.min(10, Math.max(1, Math.round(value.depth)));
+  }
+  return Object.keys(changes).length > 0 ? changes : undefined;
+}
+
+function parseRecommendation(value: unknown): ParsedAssessment['recommendation'] {
+  if (!isRecord(value)) return undefined;
+  const action = pick(value.action, ACTIONS);
+  if (!action) return undefined;
+
+  return {
+    action,
+    newMode: pick(value.newMode, REASONING_MODES),
+    parameterChanges: parseParameterChanges(value.parameterChanges),
+    contextAddition:
+      typeof value.contextAddition === 'string' && value.contextAddition.trim()
+        ? value.contextAddition.trim()
+        : undefined,
+    confidence: probability(value.confidence) ?? 0,
+    reasoning: typeof value.reasoning === 'string' ? value.reasoning : '',
+  };
+}
+
 export function parseMetaAssessmentResponse(content: string): ParsedAssessment | null {
+  let parsed: unknown;
   try {
     const json = extractJson(content);
     if (!json) return null;
-    return JSON.parse(json) as ParsedAssessment;
+    parsed = JSON.parse(json);
   } catch {
     return null;
   }
+  if (!isRecord(parsed)) return null;
+
+  const issues: MetaIssue[] = [];
+  for (const raw of Array.isArray(parsed.issues) ? parsed.issues : []) {
+    if (!isRecord(raw)) continue;
+    const type = pick(raw.type, ISSUE_TYPES);
+    if (!type) continue;
+    issues.push({
+      type,
+      severity: pick(raw.severity, SEVERITIES) ?? 'medium',
+      description: typeof raw.description === 'string' ? raw.description : '',
+    });
+  }
+
+  const opportunities: ParsedAssessment['opportunities'] = [];
+  for (const raw of Array.isArray(parsed.opportunities) ? parsed.opportunities : []) {
+    if (!isRecord(raw)) continue;
+    const type = pick(raw.type, OPPORTUNITY_TYPES);
+    if (!type) continue;
+    opportunities.push({
+      type,
+      description: typeof raw.description === 'string' ? raw.description : '',
+      expectedImprovement: probability(raw.expectedImprovement) ?? 0.5,
+    });
+  }
+
+  return {
+    onTrack: typeof parsed.onTrack === 'boolean' ? parsed.onTrack : undefined,
+    confidence: probability(parsed.confidence),
+    reasoning: typeof parsed.reasoning === 'string' ? parsed.reasoning : undefined,
+    issues,
+    opportunities,
+    recommendation: parseRecommendation(parsed.recommendation),
+  };
 }
 
 export const META_REASONING_SYSTEM_PROMPT = `You are a meta-reasoning system analyzing an AI agent's reasoning process.