@cogitator-ai/self-modifying 17.0.17 → 18.0.0

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) {
@@ -106,19 +132,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;
 
@@ -151,6 +181,7 @@ export class MetaReasoner {
     });
 
     const parsed = parseMetaAssessmentResponse(response.content);
+    const recommendation = this.buildRecommendation(parsed, observation);
 
     const assessment: MetaAssessment = {
       id: `meta_${nanoid(10)}`,
@@ -161,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,
@@ -207,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> {
@@ -235,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;
     }
 
@@ -278,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
@@ -285,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);
@@ -293,34 +344,51 @@ 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].reverse().find((a) => a.type !== 'rollback');
 
-    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,
+      previousMode: target.newMode,
+      newMode: target.previousMode,
+      reason: `Rollback of ${target.id}`,
+      isRollback: true,
 
       rollbackable: false,
     };
 
-    if (lastAdaptation.type === 'mode_switch' && lastAdaptation.before.mode) {
-      this.currentMode.set(runId, lastAdaptation.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;
   }
@@ -337,14 +405,14 @@ export class MetaReasoner {
       adaptation.outcome = outcome;
 
       if (this.config.rollbackOnDecline && !outcome.improved && adaptation.rollbackable) {
-        this.rollback(runId);
+        this.rollback(runId, adaptationId);
       }
     }
   }
 
   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 {
@@ -352,7 +420,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): {
@@ -377,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/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,12 @@
-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(
   observation: MetaObservation,
@@ -62,20 +70,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",
@@ -85,78 +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;
   }
-}
-
-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 (!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 : '',
+    });
+  }
 
-    if (ch === '{') depth++;
-    else if (ch === '}') {
-      depth--;
-      if (depth === 0) {
-        return text.slice(start, i + 1);
-      }
-    }
+  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 null;
+  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.

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;
     }