cognitive-core 0.1.2 → 0.2.0

package/src/session-bank/types.ts

@@ -1,7 +1,7 @@
 // ─── Session Bank Types ───────────────────────────────────────────────
-// Standalone types for reading Entire CLI checkpoint data.
-// Zero imports from cognitive-core — this module can be extracted into
-// its own package.
+// Standalone types for reading SessionLog checkpoint data from orphan
+// branches. Zero imports from cognitive-core — this module can be
+// extracted.
 // ─────────────────────────────────────────────────────────────────────
 
 // ─── Content Blocks (transcript) ────────────────────────────────────
@@ -40,7 +40,7 @@ export interface TranscriptMessage {
   lineIndex: number;
 }
 
-// ─── Session Summary (from Entire's AI summarizer) ──────────────────
+// ─── Session Summary (from checkpoint AI summarizer) ────────────────
 
 export interface SessionSummary {
   intent: string;
@@ -164,10 +164,13 @@ export interface ProcessingLogEntry {
 export interface SessionBankOptions {
   /** Git repository path (default: process.cwd()) */
   repoPath?: string;
-  /** Orphan branch name (default: 'entire/checkpoints/v1') */
+  /** Orphan branch name (default: 'sessionlog/checkpoints/v1'). */
   branch?: string;
   /** Directory to store processing state (default: '.atlas/session-bank') */
   stateDir?: string;
   /** Enable in-memory caching of parsed sessions (default: true) */
   cache?: boolean;
+  /** Trailer keys to search for checkpoint IDs in commit messages.
+   *  Defaults to ['Sessionlog-Checkpoint']. */
+  trailerKeys?: string[];
 }

package/src/surfacing/skill-publisher.ts

@@ -6,7 +6,7 @@
  * conversion at the publish boundary.
  */
 
-import type { Skill, StorageAdapter, TriggerCondition } from 'skill-tree';
+import type { Skill, StorageAdapter } from 'skill-tree';
 import type { Playbook } from '../types/index.js';
 import type { PublishResult, DeprecateResult } from './publisher.js';
 import { getPlaybookSuccessRate } from '../types/playbook.js';
@@ -49,30 +49,32 @@ export function convertPlaybookToSkill(playbook: Playbook): Skill {
     notesParts.push('Rollback: ' + playbook.verification.rollbackStrategy);
   }
 
-  // Build trigger conditions
-  const triggerConditions = extractTriggerConditions(playbook);
-
   // Build description for semantic matching
   const description = playbook.applicability.situations[0]
     ?? `${playbook.name}: ${playbook.guidance.strategy.slice(0, 100)}`;
 
+  // Build instructions as structured markdown combining all content
+  const instructionParts: string[] = [];
+  instructionParts.push(`## Problem\n${playbook.applicability.situations.join('. ')}`);
+  instructionParts.push(`## Solution\n${solution}`);
+  instructionParts.push(`## Verification\n${verification}`);
+  if (notesParts.length > 0) {
+    instructionParts.push(`## Notes\n${notesParts.join('\n\n')}`);
+  }
+  if (playbook.guidance.codeExample) {
+    instructionParts.push(`## Example\n\`\`\`\n${playbook.guidance.codeExample}\n\`\`\``);
+  }
+  const instructions = instructionParts.join('\n\n');
+
   // Estimate tokens (rough: 4 chars per token)
-  const fullText = [playbook.name, solution, verification, ...notesParts].join(' ');
-  const tokenEstimate = Math.ceil(fullText.length / 4);
+  const tokenEstimate = Math.ceil(instructions.length / 4);
 
   return {
     id: playbook.id,
     name: playbook.name,
     version: playbook.evolution.version,
     description,
-    problem: playbook.applicability.situations.join('. '),
-    triggerConditions,
-    solution,
-    verification,
-    examples: playbook.guidance.codeExample
-      ? [{ scenario: playbook.applicability.situations[0] ?? playbook.name, before: '', after: playbook.guidance.codeExample }]
-      : [],
-    notes: notesParts.length > 0 ? notesParts.join('\n\n') : undefined,
+    instructions,
     author: 'cognitive-core',
     tags: playbook.applicability.domains,
     status: 'active',
@@ -97,40 +99,6 @@ export function convertPlaybookToSkill(playbook: Playbook): Skill {
   };
 }
 
-/**
- * Extract trigger conditions from playbook applicability
- */
-function extractTriggerConditions(playbook: Playbook): TriggerCondition[] {
-  const triggers: TriggerCondition[] = [];
-
-  // Add situation-based triggers
-  for (const situation of playbook.applicability.situations) {
-    triggers.push({
-      type: 'context',
-      value: situation,
-      description: 'Situation trigger',
-    });
-  }
-
-  // Add explicit triggers with type detection
-  for (const trigger of playbook.applicability.triggers) {
-    let type: TriggerCondition['type'] = 'keyword';
-    if (trigger.toLowerCase().includes('error') || /^[A-Z]{2,}\d+/.test(trigger)) {
-      type = 'error';
-    } else if (trigger.startsWith('/') || trigger.includes('*')) {
-      type = 'pattern';
-    }
-
-    triggers.push({
-      type,
-      value: trigger,
-      description: 'Explicit trigger',
-    });
-  }
-
-  return triggers;
-}
-
 /**
  * SkillPublisher - Manages publishing graduated playbooks to skill-tree storage
  */
@@ -192,7 +160,7 @@ export class SkillPublisher {
       }
 
       existing.status = 'deprecated';
-      existing.notes = (existing.notes ? existing.notes + '\n\n' : '') + `Deprecated: ${reason}`;
+      existing.description = (existing.description ? existing.description + ' ' : '') + `[Deprecated: ${reason}]`;
       existing.updatedAt = new Date();
       await this.storage.saveSkill(existing);
 

package/src/surfacing/sqlite-storage-adapter.ts

@@ -19,18 +19,14 @@ interface SkillRow {
   name: string;
   version: string;
   description: string | null;
-  problem: string | null;
-  solution: string;
-  verification: string | null;
-  notes: string | null;
+  instructions: string;
   author: string | null;
   status: string;
   tags: string;
-  trigger_conditions: string;
-  examples: string;
   metrics: string;
   source: string;
   serving: string;
+  related: string;
   created_at: string;
   updated_at: string;
 }
@@ -70,18 +66,14 @@ export class SqliteStorageAdapter implements StorageAdapter {
         name TEXT NOT NULL,
         version TEXT NOT NULL,
         description TEXT,
-        problem TEXT,
-        solution TEXT NOT NULL,
-        verification TEXT,
-        notes TEXT,
+        instructions TEXT NOT NULL DEFAULT '',
         author TEXT,
         status TEXT NOT NULL DEFAULT 'active',
         tags TEXT NOT NULL DEFAULT '[]',
-        trigger_conditions TEXT NOT NULL DEFAULT '[]',
-        examples TEXT NOT NULL DEFAULT '[]',
         metrics TEXT NOT NULL DEFAULT '{}',
         source TEXT NOT NULL DEFAULT '{}',
         serving TEXT NOT NULL DEFAULT '{}',
+        related TEXT NOT NULL DEFAULT '[]',
         created_at TEXT NOT NULL,
         updated_at TEXT NOT NULL
       )
@@ -120,11 +112,11 @@ export class SqliteStorageAdapter implements StorageAdapter {
       // Upsert the skill
       const stmt = this.db.prepare(`
         INSERT OR REPLACE INTO skills
-          (id, name, version, description, problem, solution, verification, notes,
-           author, status, tags, trigger_conditions, examples, metrics, source,
-           serving, created_at, updated_at)
+          (id, name, version, description, instructions,
+           author, status, tags, metrics, source,
+           serving, related, created_at, updated_at)
         VALUES
-          (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       `);
 
       stmt.run(
@@ -132,18 +124,14 @@ export class SqliteStorageAdapter implements StorageAdapter {
         skill.name,
         skill.version,
         skill.description ?? null,
-        skill.problem ?? null,
-        skill.solution,
-        skill.verification ?? null,
-        skill.notes ?? null,
+        skill.instructions,
         skill.author ?? null,
         skill.status,
         JSON.stringify(skill.tags ?? []),
-        JSON.stringify(skill.triggerConditions ?? []),
-        JSON.stringify(skill.examples ?? []),
         JSON.stringify(skill.metrics ?? {}),
         JSON.stringify(skill.source ?? {}),
         JSON.stringify(skill.serving ?? {}),
+        JSON.stringify(skill.related ?? []),
         toISOString(skill.createdAt),
         toISOString(skill.updatedAt),
       );
@@ -226,13 +214,13 @@ export class SqliteStorageAdapter implements StorageAdapter {
   }
 
   async searchSkills(query: string): Promise<Skill[]> {
-    // Simple LIKE-based search across name, description, and solution
+    // Simple LIKE-based search across name, description, and instructions
     const rows = this.db.prepare(`
       SELECT * FROM skills
-      WHERE name LIKE ? OR description LIKE ? OR solution LIKE ? OR problem LIKE ?
+      WHERE name LIKE ? OR description LIKE ? OR instructions LIKE ?
       ORDER BY updated_at DESC
     `).all(
-      `%${query}%`, `%${query}%`, `%${query}%`, `%${query}%`
+      `%${query}%`, `%${query}%`, `%${query}%`
     ) as SkillRow[];
 
     return rows.map(r => this.rowToSkill(r));
@@ -256,15 +244,11 @@ export class SqliteStorageAdapter implements StorageAdapter {
       name: row.name,
       version: row.version,
       description: row.description ?? '',
-      problem: row.problem ?? '',
-      solution: row.solution,
-      verification: row.verification ?? '',
-      notes: row.notes ?? undefined,
+      instructions: row.instructions,
       author: row.author ?? 'unknown',
       status: row.status as Skill['status'],
       tags: JSON.parse(row.tags),
-      triggerConditions: JSON.parse(row.trigger_conditions),
-      examples: JSON.parse(row.examples),
+      related: JSON.parse(row.related),
       metrics: {
         ...metrics,
         lastUsed: metrics.lastUsed ? new Date(metrics.lastUsed) : undefined,
@@ -290,7 +274,7 @@ function toISOString(value: Date | string | undefined): string {
  * Simple content hash for version tracking.
  */
 function hashSkill(skill: Skill): string {
-  const content = `${skill.name}:${skill.solution}:${skill.version}`;
+  const content = `${skill.name}:${skill.instructions}:${skill.version}`;
   let hash = 0;
   for (let i = 0; i < content.length; i++) {
     const char = content.charCodeAt(i);

package/src/types/config.ts

@@ -100,6 +100,8 @@ export const StorageConfigSchema = z.object({
   persistenceEnabled: z.boolean().default(true),
   /** Auto-save interval in milliseconds */
   autoSaveInterval: z.number().default(60000), // 1 minute
+  /** SQLite database filename (relative to baseDir) */
+  dbName: z.string().default('cognitive-core.db'),
 });
 
 export type StorageConfig = z.infer<typeof StorageConfigSchema>;
@@ -475,6 +477,8 @@ export const KnowledgeBankConfigSchema = z.object({
   surfacing: KnowledgeSurfacingConfigSchema.default({}),
   /** Whether to manage minimem-specific features (sync, versioning) */
   minimemAware: z.boolean().default(true),
+  /** Enable coherence checking (contradiction detection) on note insertion */
+  coherenceChecking: z.boolean().default(true),
 });
 
 export type KnowledgeBankConfig = z.infer<typeof KnowledgeBankConfigSchema>;
@@ -511,6 +515,29 @@ export const SkillTreeConfigSchema = z.object({
 
 export type SkillTreeConfig = z.infer<typeof SkillTreeConfigSchema>;
 
+/**
+ * Feature toggles for ruvector-inspired subsystems.
+ *
+ * All default to `true`. Set to `false` to disable individual features
+ * without removing them from the codebase.
+ */
+export const FeaturesConfigSchema = z.object({
+  /** Enable instant (hot-path) learning on every trajectory (InstantLoop) */
+  instantLoop: z.boolean().default(true),
+  /** Enable reflexion episode generation and storage */
+  reflexion: z.boolean().default(true),
+  /** Enable coherence checking on knowledge note insertion */
+  coherenceChecking: z.boolean().default(true),
+  /** Enable experience clustering via ReasoningBank in batch pipeline */
+  reasoningBank: z.boolean().default(true),
+  /** Enable causal edge extraction in instant loop */
+  causalExtraction: z.boolean().default(true),
+  /** Enable temporal compression (Hot/Warm/Cold/Evict) in batch pipeline */
+  temporalCompression: z.boolean().default(true),
+});
+
+export type FeaturesConfig = z.infer<typeof FeaturesConfigSchema>;
+
 /**
  * Main Atlas configuration
  */
@@ -545,6 +572,8 @@ export const AtlasConfigSchema = z.object({
   skillTree: SkillTreeConfigSchema.default({}),
   /** Session bank configuration (Entire CLI integration) */
   sessionBank: SessionBankConfigSchema.default({}),
+  /** Feature toggles for ruvector-inspired subsystems */
+  features: FeaturesConfigSchema.default({}),
 });
 
 export type AtlasConfig = z.infer<typeof AtlasConfigSchema>;
@@ -581,5 +610,6 @@ export function mergeConfig(
     knowledgeBank: { ...base.knowledgeBank, ...overrides.knowledgeBank },
     skillTree: { ...base.skillTree, ...overrides.skillTree },
     sessionBank: { ...base.sessionBank, ...overrides.sessionBank },
+    features: { ...base.features, ...overrides.features },
   });
 }

package/src/types/index.ts

@@ -39,6 +39,7 @@ export {
   CodeConceptSchema,
   StrategySchema,
   SkillSchema,
+  type ReflexionEpisode,
   createExperience,
   createConcept,
   createStrategy,
@@ -250,6 +251,7 @@ export {
   type DefragConfig,
   type SkillTreeConfig,
   type SessionBankConfig,
+  type FeaturesConfig,
   type AtlasConfig,
   SessionBankConfigSchema,
   KnowledgeBankConfigSchema,
@@ -280,6 +282,7 @@ export {
   TeamLearningConfigSchema,
   AgenticTaskRunnerConfigSchema,
   SkillTreeConfigSchema,
+  FeaturesConfigSchema,
   AtlasConfigSchema,
   createDefaultConfig,
   mergeConfig,

package/src/types/memory.ts

@@ -22,10 +22,22 @@ export const ExperienceSchema = z.object({
   trajectoryId: z.string(),
   /** Usage statistics */
   usageCount: z.number().default(0),
+  /** Composite access score — decays over time, bumped on retrieval/success */
+  accessScore: z.number().default(0),
+  /** Number of times this experience was a findSimilar() hit */
+  retrievalCount: z.number().default(0),
   /** Creation timestamp */
   createdAt: z.date().default(() => new Date()),
   /** Last accessed timestamp */
   lastAccessedAt: z.date().optional(),
+  /** Memory tier — determines fidelity and compression level */
+  tier: z.enum(['hot', 'warm', 'cold']).default('hot'),
+  /** Compressed representation (populated for warm/cold tiers) */
+  compressed: z.object({
+    keySteps: z.array(z.string()),
+    summary: z.string(),
+    originalStepCount: z.number(),
+  }).optional(),
   /** Additional metadata */
   metadata: z.record(z.unknown()).default({}),
 });
@@ -145,6 +157,23 @@ export const SkillSchema = z.object({
 
 export type Skill = z.infer<typeof SkillSchema>;
 
+/**
+ * ReflexionEpisode — structured self-reflection on a completed trajectory.
+ * Generated by the ReflexionGenerator after each trajectory completion.
+ */
+export interface ReflexionEpisode {
+  id: string;
+  trajectoryId: string;
+  taskSummary: string;
+  outcome: 'success' | 'partial' | 'failure';
+  selfCritique: string;
+  keyInsights: string[];
+  strategyAssessment: string;
+  suggestedPlaybookUpdates: string[];
+  domain: string;
+  createdAt: Date;
+}
+
 /**
  * Create a new experience
  */
@@ -168,6 +197,7 @@ export function createExperience(params: {
     domain: params.domain,
     trajectoryId: params.trajectoryId,
     embedding: params.embedding,
+    accessScore: params.success ? 1.0 : 0.3,
     metadata: params.metadata ?? {},
     createdAt: new Date(),
   });

package/src/types/playbook.ts

@@ -95,6 +95,10 @@ export interface PlaybookEvolution {
   successCount: number;
   failureCount: number;
   lastUsed?: Date;
+  /** Resistance to confidence changes — grows with successful use breadth (EWC-inspired) */
+  consolidationStrength?: number; // default: 0, range [0, 10]
+  /** How many unique domains this playbook has succeeded in */
+  domainBreadth?: number; // default: 0
 }
 
 /**

package/src/utils/error-classifier.ts

@@ -0,0 +1,113 @@
+/**
+ * Unified error classification utility.
+ *
+ * Provides a single canonical error type mapping used by TrajectoryAnalyzer,
+ * ReflexionGenerator, KnowledgeExtractor, and other learning components.
+ */
+
+/**
+ * Canonical error types recognized by the classifier.
+ */
+export type ErrorType =
+  | 'type-error'
+  | 'import-error'
+  | 'syntax-error'
+  | 'timeout'
+  | 'permission-error'
+  | 'not-found'
+  | 'network-error'
+  | 'test-failure'
+  | 'assertion-error'
+  | 'general-error';
+
+/**
+ * Result of classifying an error string.
+ */
+export interface ErrorClassification {
+  /** Canonical error type */
+  type: ErrorType;
+  /** Human-readable description */
+  description: string;
+}
+
+/**
+ * Ordered list of error classification rules.
+ * More specific patterns come first; 'general-error' is the fallback.
+ */
+const ERROR_RULES: Array<{ test: (s: string) => boolean; type: ErrorType; description: string }> = [
+  {
+    test: (s) => /type\s*error/i.test(s) || (s.includes('type') && s.includes('error')),
+    type: 'type-error',
+    description: 'Type mismatch error',
+  },
+  {
+    test: (s) => /import|module not found|cannot find module/i.test(s),
+    type: 'import-error',
+    description: 'Import or module resolution error',
+  },
+  {
+    test: (s) => /syntax\s*error/i.test(s),
+    type: 'syntax-error',
+    description: 'Syntax error in code',
+  },
+  {
+    test: (s) => /timeout|timed?\s*out/i.test(s),
+    type: 'timeout',
+    description: 'Operation timed out',
+  },
+  {
+    test: (s) => /permission\s*denied|forbidden|unauthorized/i.test(s),
+    type: 'permission-error',
+    description: 'Permission denied',
+  },
+  {
+    test: (s) => /not\s*found|missing|no\s*such\s*file/i.test(s),
+    type: 'not-found',
+    description: 'Resource not found',
+  },
+  {
+    test: (s) => /network|connection|ECONNREFUSED|ENOTFOUND/i.test(s),
+    type: 'network-error',
+    description: 'Network or connection error',
+  },
+  {
+    test: (s) => /test.*fail|fail.*test|assertion|assert/i.test(s),
+    type: 'test-failure',
+    description: 'Test or assertion failure',
+  },
+  {
+    test: (s) => /assertion|assert/i.test(s),
+    type: 'assertion-error',
+    description: 'Assertion failed',
+  },
+  {
+    test: (s) => /exception|error/i.test(s),
+    type: 'general-error',
+    description: 'General error',
+  },
+];
+
+/**
+ * Classify an error message into a canonical error type.
+ * Returns `null` if no pattern matches.
+ */
+export function classifyError(errorInfo: string): ErrorClassification | null {
+  if (!errorInfo) return null;
+
+  for (const rule of ERROR_RULES) {
+    if (rule.test(errorInfo)) {
+      return { type: rule.type, description: rule.description };
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Get just the error type string (convenience wrapper).
+ * Returns `null` if no pattern matches.
+ */
+export function classifyErrorType(errorInfo: string): ErrorType | null {
+  const result = classifyError(errorInfo);
+  return result?.type ?? null;
+}

package/src/utils/index.ts

@@ -19,6 +19,11 @@ export {
   type StorageOptions,
 } from './storage.js';
 
+export {
+  PartitionedStore,
+  type PartitionedStoreOptions,
+} from './partitioned-store.js';
+
 export {
   ValidationError,
   validateString,
@@ -43,3 +48,16 @@ export {
   serializeKnowledgeNote,
   parseKnowledgeNote,
 } from './frontmatter.js';
+
+export {
+  classifyError,
+  classifyErrorType,
+  type ErrorType,
+  type ErrorClassification,
+} from './error-classifier.js';
+
+export {
+  detectRepeatedActions,
+  extractToolNames,
+  type RepeatedAction,
+} from './trajectory-helpers.js';