@cogitator-ai/self-modifying 0.1.0 → 1.0.0

package/src/architecture-evolution/capability-analyzer.ts

@@ -16,28 +16,102 @@ interface DomainKeywords {
 
 const DOMAIN_KEYWORDS: DomainKeywords = {
   coding: [
-    'code', 'program', 'function', 'class', 'debug', 'implement', 'refactor',
-    'typescript', 'javascript', 'python', 'api', 'database', 'sql', 'algorithm',
-    'data structure', 'compile', 'syntax', 'bug', 'error', 'test', 'unit test',
+    'code',
+    'program',
+    'function',
+    'class',
+    'debug',
+    'implement',
+    'refactor',
+    'typescript',
+    'javascript',
+    'python',
+    'api',
+    'database',
+    'sql',
+    'algorithm',
+    'data structure',
+    'compile',
+    'syntax',
+    'bug',
+    'error',
+    'test',
+    'unit test',
   ],
   reasoning: [
-    'analyze', 'reason', 'logic', 'deduce', 'infer', 'solve', 'problem',
-    'strategy', 'plan', 'decision', 'evaluate', 'compare', 'trade-off',
-    'optimize', 'proof', 'argument', 'conclusion', 'hypothesis',
+    'analyze',
+    'reason',
+    'logic',
+    'deduce',
+    'infer',
+    'solve',
+    'problem',
+    'strategy',
+    'plan',
+    'decision',
+    'evaluate',
+    'compare',
+    'trade-off',
+    'optimize',
+    'proof',
+    'argument',
+    'conclusion',
+    'hypothesis',
   ],
   creative: [
-    'create', 'imagine', 'story', 'poem', 'write', 'design', 'brainstorm',
-    'innovative', 'novel', 'artistic', 'compose', 'invent', 'original',
-    'creative', 'fiction', 'narrative', 'metaphor', 'style',
+    'create',
+    'imagine',
+    'story',
+    'poem',
+    'write',
+    'design',
+    'brainstorm',
+    'innovative',
+    'novel',
+    'artistic',
+    'compose',
+    'invent',
+    'original',
+    'creative',
+    'fiction',
+    'narrative',
+    'metaphor',
+    'style',
   ],
   factual: [
-    'what is', 'define', 'explain', 'describe', 'list', 'fact', 'information',
-    'history', 'science', 'data', 'statistic', 'research', 'study', 'source',
-    'reference', 'accurate', 'true', 'correct',
+    'what is',
+    'define',
+    'explain',
+    'describe',
+    'list',
+    'fact',
+    'information',
+    'history',
+    'science',
+    'data',
+    'statistic',
+    'research',
+    'study',
+    'source',
+    'reference',
+    'accurate',
+    'true',
+    'correct',
   ],
   conversational: [
-    'chat', 'talk', 'hello', 'hi', 'thanks', 'please', 'help', 'assist',
-    'question', 'answer', 'discuss', 'conversation', 'opinion',
+    'chat',
+    'talk',
+    'hello',
+    'hi',
+    'thanks',
+    'please',
+    'help',
+    'assist',
+    'question',
+    'answer',
+    'discuss',
+    'conversation',
+    'opinion',
   ],
 };
 
@@ -117,7 +191,8 @@ export class CapabilityAnalyzer {
             messages: [
               {
                 role: 'system',
-                content: 'You are a task analysis expert. Analyze tasks and determine their characteristics.',
+                content:
+                  'You are a task analysis expert. Analyze tasks and determine their characteristics.',
               },
               { role: 'user', content: prompt },
             ],
@@ -128,7 +203,8 @@ export class CapabilityAnalyzer {
             messages: [
               {
                 role: 'system',
-                content: 'You are a task analysis expert. Analyze tasks and determine their characteristics.',
+                content:
+                  'You are a task analysis expert. Analyze tasks and determine their characteristics.',
               },
               { role: 'user', content: prompt },
             ],
@@ -139,17 +215,12 @@ export class CapabilityAnalyzer {
       if (parsed) {
         return parsed;
       }
-    } catch {
-
-    }
+    } catch {}
 
     return this.analyzeHeuristically(taskDescription, context?.availableTools);
   }
 
-  private analyzeHeuristically(
-    taskDescription: string,
-    availableTools?: Tool[]
-  ): TaskProfile {
+  private analyzeHeuristically(taskDescription: string, availableTools?: Tool[]): TaskProfile {
     const lowerTask = taskDescription.toLowerCase();
     const words = lowerTask.split(/\s+/);
     const wordCount = words.length;
@@ -165,7 +236,8 @@ export class CapabilityAnalyzer {
       requiresTools: toolAnalysis.requiresTools,
       toolIntensity: toolAnalysis.intensity,
       reasoningDepth: this.estimateReasoningDepth(complexity, domain),
-      creativityLevel: domain === 'creative' ? 'high' : complexity === 'trivial' ? 'low' : 'moderate',
+      creativityLevel:
+        domain === 'creative' ? 'high' : complexity === 'trivial' ? 'low' : 'moderate',
       accuracyRequirement: this.estimateAccuracyRequirement(domain, lowerTask),
       timeConstraint: this.detectTimeConstraint(lowerTask),
     };
@@ -214,8 +286,17 @@ export class CapabilityAnalyzer {
     availableTools?: Tool[]
   ): { requiresTools: boolean; intensity: TaskProfile['toolIntensity'] } {
     const toolIndicators = [
-      'calculate', 'search', 'fetch', 'query', 'lookup', 'find',
-      'execute', 'run', 'call', 'invoke', 'use tool',
+      'calculate',
+      'search',
+      'fetch',
+      'query',
+      'lookup',
+      'find',
+      'execute',
+      'run',
+      'call',
+      'invoke',
+      'use tool',
     ];
 
     let toolMentions = 0;
@@ -255,10 +336,7 @@ export class CapabilityAnalyzer {
       expert: 15,
     };
 
-    return Math.min(
-      wordCount * baseMultiplier[complexity] + 200,
-      32000
-    );
+    return Math.min(wordCount * baseMultiplier[complexity] + 200, 32000);
   }
 
   private estimateReasoningDepth(
@@ -266,7 +344,11 @@ export class CapabilityAnalyzer {
     domain: TaskProfile['domain']
   ): TaskProfile['reasoningDepth'] {
     if (domain === 'reasoning') {
-      return complexity === 'trivial' ? 'moderate' : complexity === 'simple' ? 'deep' : 'exhaustive';
+      return complexity === 'trivial'
+        ? 'moderate'
+        : complexity === 'simple'
+          ? 'deep'
+          : 'exhaustive';
     }
 
     switch (complexity) {

package/src/architecture-evolution/evolution-strategy.ts

@@ -1,4 +1,7 @@
-import type { EvolutionCandidate, EvolutionStrategy as IEvolutionStrategy } from '@cogitator-ai/types';
+import type {
+  EvolutionCandidate,
+  EvolutionStrategy as IEvolutionStrategy,
+} from '@cogitator-ai/types';
 
 export interface EvolutionStrategyOptions {
   strategy: IEvolutionStrategy;
@@ -93,7 +96,8 @@ export class EvolutionStrategy {
       }
 
       const exploitation = candidate.score;
-      const exploration = c * Math.sqrt(Math.log(this.totalSelections + 1) / candidate.evaluationCount);
+      const exploration =
+        c * Math.sqrt(Math.log(this.totalSelections + 1) / candidate.evaluationCount);
       const ucb = exploitation + exploration;
 
       return { candidate, ucb, isExploration: exploration > exploitation };
@@ -105,20 +109,19 @@ export class EvolutionStrategy {
       candidate: best.candidate,
       score: best.ucb === Infinity ? 0 : best.ucb,
       isExploration: best.isExploration,
-      reasoning: best.ucb === Infinity
-        ? `UCB: selected unexplored candidate ${best.candidate.id}`
-        : `UCB: selected ${best.candidate.id} with UCB score ${best.ucb.toFixed(3)} (base: ${best.candidate.score.toFixed(3)}, exploration bonus)`,
+      reasoning:
+        best.ucb === Infinity
+          ? `UCB: selected unexplored candidate ${best.candidate.id}`
+          : `UCB: selected ${best.candidate.id} with UCB score ${best.ucb.toFixed(3)} (base: ${best.candidate.score.toFixed(3)}, exploration bonus)`,
     };
   }
 
   private thompsonSampling(candidates: EvolutionCandidate[]): SelectionResult {
     const samples = candidates.map((candidate) => {
-      const alpha = candidate.evaluationCount > 0
-        ? candidate.score * candidate.evaluationCount + 1
-        : 1;
-      const beta = candidate.evaluationCount > 0
-        ? (1 - candidate.score) * candidate.evaluationCount + 1
-        : 1;
+      const alpha =
+        candidate.evaluationCount > 0 ? candidate.score * candidate.evaluationCount + 1 : 1;
+      const beta =
+        candidate.evaluationCount > 0 ? (1 - candidate.score) * candidate.evaluationCount + 1 : 1;
 
       const sample = this.sampleBeta(alpha, beta);
 
@@ -193,7 +196,10 @@ export class EvolutionStrategy {
       case 'epsilon_greedy':
         return this.strategy.epsilon ?? 0.1;
       case 'ucb':
-        return Math.min(1, (this.strategy.explorationConstant ?? 2) / Math.sqrt(this.totalSelections));
+        return Math.min(
+          1,
+          (this.strategy.explorationConstant ?? 2) / Math.sqrt(this.totalSelections)
+        );
       case 'thompson_sampling':
         return 0.5;
       default:
@@ -205,7 +211,8 @@ export class EvolutionStrategy {
     const unexploredCount = candidates.filter((c) => c.evaluationCount === 0).length;
     if (unexploredCount > 0) return true;
 
-    const avgEvaluations = candidates.reduce((sum, c) => sum + c.evaluationCount, 0) / candidates.length;
+    const avgEvaluations =
+      candidates.reduce((sum, c) => sum + c.evaluationCount, 0) / candidates.length;
     if (avgEvaluations < 5) return true;
 
     const scores = candidates.map((c) => c.score);

package/src/architecture-evolution/index.ts

@@ -1,7 +1,4 @@
-export {
-  CapabilityAnalyzer,
-  type CapabilityAnalyzerOptions,
-} from './capability-analyzer';
+export { CapabilityAnalyzer, type CapabilityAnalyzerOptions } from './capability-analyzer';
 
 export {
   EvolutionStrategy,

package/src/architecture-evolution/parameter-optimizer.ts

@@ -133,13 +133,16 @@ export class ParameterOptimizer {
     );
 
     try {
-      const response = await this.callLLM([
-        {
-          role: 'system',
-          content: 'You are an AI architecture optimizer. Generate candidate configurations.',
-        },
-        { role: 'user', content: prompt },
-      ], 0.5);
+      const response = await this.callLLM(
+        [
+          {
+            role: 'system',
+            content: 'You are an AI architecture optimizer. Generate candidate configurations.',
+          },
+          { role: 'user', content: prompt },
+        ],
+        0.5
+      );
 
       const generated = parseCandidateGenerationResponse(response.content);
 
@@ -239,7 +242,10 @@ export class ParameterOptimizer {
     const mutationRate = 0.3;
 
     if (Math.random() < mutationRate && mutated.temperature !== undefined) {
-      mutated.temperature = Math.max(0, Math.min(2, mutated.temperature + (Math.random() - 0.5) * 0.3));
+      mutated.temperature = Math.max(
+        0,
+        Math.min(2, mutated.temperature + (Math.random() - 0.5) * 0.3)
+      );
     }
 
     if (Math.random() < mutationRate && mutated.maxTokens !== undefined) {
@@ -248,7 +254,10 @@ export class ParameterOptimizer {
     }
 
     if (Math.random() < mutationRate && mutated.reflectionDepth !== undefined) {
-      mutated.reflectionDepth = Math.max(0, Math.min(5, mutated.reflectionDepth + Math.round(Math.random() * 2 - 1)));
+      mutated.reflectionDepth = Math.max(
+        0,
+        Math.min(5, mutated.reflectionDepth + Math.round(Math.random() * 2 - 1))
+      );
     }
 
     return mutated;
@@ -324,7 +333,10 @@ export class ParameterOptimizer {
 
   private getRelevantHistory(profile: TaskProfile): HistoricalRecord[] {
     return this.history
-      .filter((h) => h.taskProfile.domain === profile.domain || h.taskProfile.complexity === profile.complexity)
+      .filter(
+        (h) =>
+          h.taskProfile.domain === profile.domain || h.taskProfile.complexity === profile.complexity
+      )
       .slice(-10);
   }
 
@@ -435,15 +447,19 @@ export class ParameterOptimizer {
     if (evaluatedCandidates.length === 0) return null;
 
     const results = evaluatedCandidates.map((c) => {
-      const records = this.history.filter((h) => JSON.stringify(h.config) === JSON.stringify(c.config));
-      const avgMetrics = records.length > 0
-        ? {
-            successRate: records.reduce((s, r) => s + r.metrics.successRate, 0) / records.length,
-            avgLatency: records.reduce((s, r) => s + r.metrics.latency, 0) / records.length,
-            avgTokens: records.reduce((s, r) => s + r.metrics.tokenUsage, 0) / records.length,
-            qualityScore: records.reduce((s, r) => s + r.metrics.qualityScore, 0) / records.length,
-          }
-        : { successRate: 0, avgLatency: 0, avgTokens: 0, qualityScore: 0 };
+      const records = this.history.filter(
+        (h) => JSON.stringify(h.config) === JSON.stringify(c.config)
+      );
+      const avgMetrics =
+        records.length > 0
+          ? {
+              successRate: records.reduce((s, r) => s + r.metrics.successRate, 0) / records.length,
+              avgLatency: records.reduce((s, r) => s + r.metrics.latency, 0) / records.length,
+              avgTokens: records.reduce((s, r) => s + r.metrics.tokenUsage, 0) / records.length,
+              qualityScore:
+                records.reduce((s, r) => s + r.metrics.qualityScore, 0) / records.length,
+            }
+          : { successRate: 0, avgLatency: 0, avgTokens: 0, qualityScore: 0 };
 
       return { candidateId: c.id, metrics: avgMetrics };
     });
@@ -451,10 +467,13 @@ export class ParameterOptimizer {
     const prompt = buildPerformanceAnalysisPrompt(evaluatedCandidates, results);
 
     try {
-      const response = await this.callLLM([
-        { role: 'system', content: 'You are an AI performance analyst.' },
-        { role: 'user', content: prompt },
-      ], 0.2);
+      const response = await this.callLLM(
+        [
+          { role: 'system', content: 'You are an AI performance analyst.' },
+          { role: 'user', content: prompt },
+        ],
+        0.2
+      );
 
       return parsePerformanceAnalysisResponse(response.content);
     } catch {

package/src/architecture-evolution/prompts.ts

@@ -63,12 +63,12 @@ export function buildCandidateGenerationPrompt(
     ? `
 HISTORICAL PERFORMANCE:
 ${historicalPerformance
-    .slice(-5)
-    .map(
-      (h, i) =>
-        `${i + 1}. Config: ${JSON.stringify(h.config)} → Score: ${h.score.toFixed(2)}, Metrics: ${JSON.stringify(h.metrics)}`
-    )
-    .join('\n')}`
+  .slice(-5)
+  .map(
+    (h, i) =>
+      `${i + 1}. Config: ${JSON.stringify(h.config)} → Score: ${h.score.toFixed(2)}, Metrics: ${JSON.stringify(h.metrics)}`
+  )
+  .join('\n')}`
     : '';
 
   return `Generate candidate configurations for architecture evolution.
@@ -118,15 +118,15 @@ export function buildPerformanceAnalysisPrompt(
 
 CANDIDATES AND RESULTS:
 ${candidates
-    .map((c) => {
-      const result = results.find((r) => r.candidateId === c.id);
-      return `
+  .map((c) => {
+    const result = results.find((r) => r.candidateId === c.id);
+    return `
 ${c.id}:
   Config: ${JSON.stringify(c.config)}
   Reasoning: ${c.reasoning}
   ${result ? `Results: ${JSON.stringify(result.metrics)}` : 'Not yet tested'}`;
-    })
-    .join('\n')}
+  })
+  .join('\n')}
 
 Respond with:
 {
@@ -162,9 +162,7 @@ export function parseTaskProfileResponse(response: string): TaskProfile | null {
   }
 }
 
-export function parseCandidateGenerationResponse(
-  response: string
-): EvolutionCandidate[] {
+export function parseCandidateGenerationResponse(response: string): EvolutionCandidate[] {
   const jsonMatch = response.match(/\[[\s\S]*\]/);
   if (!jsonMatch) return [];
 
@@ -178,7 +176,8 @@ export function parseCandidateGenerationResponse(
         id: String(c.id || `candidate_${idx}`),
         config: c.config as Partial<ArchitectureConfig>,
         reasoning: String(c.reasoning || ''),
-        expectedImprovement: typeof c.expectedImprovement === 'number' ? c.expectedImprovement : 0.5,
+        expectedImprovement:
+          typeof c.expectedImprovement === 'number' ? c.expectedImprovement : 0.5,
         risk: (['low', 'medium', 'high'].includes(String(c.risk)) ? c.risk : 'medium') as
           | 'low'
           | 'medium'

package/src/constraints/index.ts

@@ -17,7 +17,4 @@ export {
   type CheckpointDiff,
 } from './rollback-manager';
 
-export {
-  ModificationValidator,
-  type ModificationValidatorOptions,
-} from './modification-validator';
+export { ModificationValidator, type ModificationValidatorOptions } from './modification-validator';

package/src/constraints/modification-validator.ts

@@ -21,10 +21,7 @@ export class ModificationValidator {
   private strictMode: boolean;
 
   constructor(options: ModificationValidatorOptions = {}) {
-    this.constraints = mergeConstraints(
-      createDefaultConstraints(),
-      options.constraints ?? {}
-    );
+    this.constraints = mergeConstraints(createDefaultConstraints(), options.constraints ?? {});
     this.strictMode = options.strictMode ?? false;
   }
 
@@ -55,12 +52,8 @@ export class ModificationValidator {
       }
     }
 
-    const hasCriticalViolation = results.some(
-      (r) => !r.satisfied && r.severity === 'critical'
-    );
-    const hasErrorViolation = results.some(
-      (r) => !r.satisfied && r.severity === 'error'
-    );
+    const hasCriticalViolation = results.some((r) => !r.satisfied && r.severity === 'critical');
+    const hasErrorViolation = results.some((r) => !r.satisfied && r.severity === 'error');
 
     const valid = this.strictMode
       ? results.every((r) => r.satisfied)
@@ -146,10 +139,7 @@ export class ModificationValidator {
     return result;
   }
 
-  private evaluateSimpleCondition(
-    condition: string,
-    context: Record<string, unknown>
-  ): boolean {
+  private evaluateSimpleCondition(condition: string, context: Record<string, unknown>): boolean {
     const operators = ['<=', '>=', '<', '>', '!=', '='];
     for (const op of operators) {
       const idx = condition.indexOf(op);
@@ -216,10 +206,7 @@ export class ModificationValidator {
         if (constraint.forbidden?.includes(payload.category)) {
           satisfied = false;
           message = `Category '${payload.category}' is forbidden`;
-        } else if (
-          constraint.allowed?.length &&
-          !constraint.allowed.includes(payload.category)
-        ) {
+        } else if (constraint.allowed?.length && !constraint.allowed.includes(payload.category)) {
           satisfied = false;
           message = `Category '${payload.category}' is not in allowed list`;
         }

package/src/constraints/rollback-manager.ts

@@ -156,9 +156,7 @@ export class RollbackManager {
     const toolsRemoved = [...toolsA].filter((t) => !toolsB.has(t));
 
     const modsBefore = new Set(checkpointA.modifications.map((m) => m.id));
-    const modificationsApplied = checkpointB.modifications.filter(
-      (m) => !modsBefore.has(m.id)
-    );
+    const modificationsApplied = checkpointB.modifications.filter((m) => !modsBefore.has(m.id));
 
     return { configChanges, toolsAdded, toolsRemoved, modificationsApplied };
   }

package/src/constraints/safety-constraints.ts

@@ -89,9 +89,7 @@ export function mergeConstraints(
   additions: Partial<ModificationConstraints>
 ): ModificationConstraints {
   return {
-    safety: additions.safety
-      ? mergeSafetyConstraints(base.safety, additions.safety)
-      : base.safety,
+    safety: additions.safety ? mergeSafetyConstraints(base.safety, additions.safety) : base.safety,
     capability: additions.capability
       ? mergeCapabilityConstraints(base.capability, additions.capability)
       : base.capability,

package/src/index.ts

@@ -1,4 +1,8 @@
-export { SelfModifyingAgent, type SelfModifyingAgentOptions, type RunContext } from './self-modifying-agent';
+export {
+  SelfModifyingAgent,
+  type SelfModifyingAgentOptions,
+  type RunContext,
+} from './self-modifying-agent';
 
 export {
   GapAnalyzer,
@@ -69,10 +73,7 @@ export {
   type CheckpointDiff,
 } from './constraints';
 
-export {
-  SelfModifyingEventEmitter,
-  type SelfModifyingEventHandler,
-} from './events';
+export { SelfModifyingEventEmitter, type SelfModifyingEventHandler } from './events';
 
 export type {
   SelfModifyingConfig,

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

@@ -14,7 +14,11 @@ import type {
   MetaOpportunity,
 } from '@cogitator-ai/types';
 import { DEFAULT_META_REASONING_CONFIG } from '@cogitator-ai/types';
-import { ObservationCollector, type ActionRecord, type ObservationContext } from './observation-collector';
+import {
+  ObservationCollector,
+  type ActionRecord,
+  type ObservationContext,
+} from './observation-collector';
 import { StrategySelector } from './strategy-selector';
 import {
   buildMetaAssessmentPrompt,
@@ -98,8 +102,7 @@ export class MetaReasoner {
     switch (trigger) {
       case 'iteration_complete':
         return (
-          context.iteration > 0 &&
-          context.iteration % this.config.triggerAfterIterations === 0
+          context.iteration > 0 && context.iteration % this.config.triggerAfterIterations === 0
         );
 
       case 'confidence_drop':
@@ -235,10 +238,7 @@ export class MetaReasoner {
 
     switch (recommendation.action) {
       case 'switch_mode':
-        if (
-          recommendation.newMode &&
-          this.config.allowedModes.includes(recommendation.newMode)
-        ) {
+        if (recommendation.newMode && this.config.allowedModes.includes(recommendation.newMode)) {
           newConfig = this.getModeConfig(recommendation.newMode);
           adaptationType = 'mode_switch';
           this.currentMode.set(runId, recommendation.newMode);
@@ -290,10 +290,7 @@ export class MetaReasoner {
       return null;
     }
 
-    if (
-      lastAdaptation.rollbackDeadline &&
-      Date.now() > lastAdaptation.rollbackDeadline
-    ) {
+    if (lastAdaptation.rollbackDeadline && Date.now() > lastAdaptation.rollbackDeadline) {
       return null;
     }
 
@@ -328,11 +325,7 @@ export class MetaReasoner {
     if (adaptation) {
       adaptation.outcome = outcome;
 
-      if (
-        this.config.rollbackOnDecline &&
-        !outcome.improved &&
-        adaptation.rollbackable
-      ) {
+      if (this.config.rollbackOnDecline && !outcome.improved && adaptation.rollbackable) {
         this.rollback(runId);
       }
     }

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

@@ -1,8 +1,4 @@
-import type {
-  MetaObservation,
-  ReasoningMode,
-  Insight,
-} from '@cogitator-ai/types';
+import type { MetaObservation, ReasoningMode, Insight } from '@cogitator-ai/types';
 
 export interface ActionRecord {
   type: string;
@@ -56,10 +52,7 @@ export class ObservationCollector {
     }
   }
 
-  collect(
-    context: ObservationContext,
-    insights: Insight[]
-  ): MetaObservation {
+  collect(context: ObservationContext, insights: Insight[]): MetaObservation {
     const { runId, iteration, goal, currentMode } = context;
     const prevObservations = this.observations.get(runId) ?? [];
     const lastObs = prevObservations[prevObservations.length - 1];
@@ -69,9 +62,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 = progressDelta < 0.05 ? (lastObs?.stagnationCount ?? 0) + 1 : 0;
     const repetitionScore = this.calculateRepetition(actions);
     const toolSuccessRate = this.calculateToolSuccessRate(actions);
     const confidenceTrend = this.calculateTrend(confidenceHist);