@plur-ai/core 0.7.7 → 0.8.2

package/dist/index.js

@@ -1,19 +1,42 @@
 import {
-  atomicWrite,
+  computeIdf,
   embeddingSearch,
   engramSearchText,
   ftsScore,
   ftsTokenize,
+  searchEngrams
+} from "./chunk-UETCDULF.js";
+import {
+  EngramSchemaPassthrough,
+  appendHistory,
+  buildBatchDedupPrompt,
+  buildDedupPrompt,
+  computeContentHash,
+  generateEngramId,
+  generateEventId,
+  listHistoryMonths,
+  loadAllPacks,
+  loadEngrams,
+  loadPack,
+  logger,
+  normalizeStatement,
+  parseDedupResponse,
+  readHistory,
+  readHistoryForEngram,
+  saveEngrams,
+  storePrefix
+} from "./chunk-GRDNBUIJ.js";
+import {
+  atomicWrite,
   getSyncStatus,
-  searchEngrams,
   sync,
   withLock
-} from "./chunk-KMVQYBNP.js";
+} from "./chunk-MY4XVDCE.js";
 import "./chunk-2ZDO52B4.js";
 
 // src/index.ts
-import * as fs3 from "fs";
-import yaml5 from "js-yaml";
+import * as fs4 from "fs";
+import yaml6 from "js-yaml";
 
 // src/storage.ts
 import { existsSync, mkdirSync } from "fs";
@@ -37,284 +60,8 @@ function detectPlurStorage(explicitPath) {
 }
 
 // src/storage-indexed.ts
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync2 } from "fs";
 import { createRequire } from "module";
-
-// src/engrams.ts
-import * as fs from "fs";
-import * as yaml from "js-yaml";
-
-// src/schemas/engram.ts
-import { z } from "zod";
-var ActivationSchema = z.object({
-  retrieval_strength: z.number().min(0).max(1),
-  storage_strength: z.number().min(0).max(1),
-  frequency: z.number().int().min(0),
-  last_accessed: z.string()
-});
-var KnowledgeTypeSchema = z.object({
-  memory_class: z.enum(["semantic", "episodic", "procedural", "metacognitive"]),
-  cognitive_level: z.enum(["remember", "understand", "apply", "analyze", "evaluate", "create"])
-});
-var KnowledgeAnchorSchema = z.object({
-  path: z.string(),
-  relevance: z.enum(["primary", "supporting", "example"]).default("supporting"),
-  snippet: z.string().max(200).optional(),
-  snippet_extracted_at: z.string().optional()
-});
-var AssociationSchema = z.object({
-  target_type: z.enum(["engram", "document"]),
-  target: z.string(),
-  strength: z.number().min(0).max(0.95),
-  type: z.enum(["semantic", "temporal", "causal", "co_accessed"]),
-  updated_at: z.string().optional()
-});
-var DualCodingSchema = z.object({
-  example: z.string().optional(),
-  analogy: z.string().optional()
-}).refine(
-  (d) => d.example || d.analogy,
-  "At least one of example or analogy must be provided"
-);
-var RelationsSchema = z.object({
-  broader: z.array(z.string()).default([]),
-  narrower: z.array(z.string()).default([]),
-  related: z.array(z.string()).default([]),
-  conflicts: z.array(z.string()).default([])
-});
-var ProvenanceSchema = z.object({
-  origin: z.string(),
-  chain: z.array(z.string()).default([]),
-  signature: z.string().nullable().default(null),
-  license: z.string().default("cc-by-sa-4.0")
-});
-var FeedbackSignalsSchema = z.object({
-  positive: z.number().int().default(0),
-  negative: z.number().int().default(0),
-  neutral: z.number().int().default(0)
-});
-var EntityRefSchema = z.object({
-  name: z.string(),
-  type: z.enum([
-    "person",
-    "organization",
-    "technology",
-    "concept",
-    "project",
-    "tool",
-    "place",
-    "event",
-    "standard",
-    "other"
-  ]),
-  uri: z.string().url().optional()
-});
-var TemporalSchema = z.object({
-  learned_at: z.string(),
-  valid_from: z.string().optional(),
-  valid_until: z.string().optional(),
-  ingested_at: z.string().optional()
-});
-var UsageStatsSchema = z.object({
-  injections: z.number().int().default(0),
-  hits: z.number().int().default(0),
-  misses: z.number().int().default(0),
-  last_hit_at: z.string().optional()
-});
-var EpisodicFieldsSchema = z.object({
-  emotional_weight: z.number().int().min(1).max(10).default(5),
-  confidence: z.number().int().min(1).max(10).default(5),
-  trigger_context: z.string().optional(),
-  journal_ref: z.string().optional()
-});
-var ExchangeMetadataSchema = z.object({
-  fitness_score: z.number().min(0).max(1).optional(),
-  environmental_diversity: z.number().int().default(0),
-  adoption_count: z.number().int().default(0),
-  contradiction_rate: z.number().min(0).max(1).default(0)
-});
-var EngramSchema = z.object({
-  // Identity
-  id: z.string().regex(/^(ENG|ABS|META)-[A-Za-z0-9-]+$/),
-  version: z.number().int().min(1).default(2),
-  status: z.enum(["active", "dormant", "retired", "candidate"]),
-  consolidated: z.boolean().default(false),
-  type: z.enum(["behavioral", "terminological", "procedural", "architectural"]),
-  scope: z.string(),
-  visibility: z.enum(["private", "public", "template"]).default("private"),
-  // Content
-  statement: z.string().min(1),
-  rationale: z.string().optional(),
-  contraindications: z.array(z.string()).optional(),
-  // Lineage
-  source: z.string().optional(),
-  source_patterns: z.array(z.string()).optional(),
-  derivation_count: z.number().int().min(0).default(1),
-  pack: z.string().nullable().default(null),
-  abstract: z.string().nullable().default(null),
-  derived_from: z.string().nullable().default(null),
-  // Classification
-  knowledge_type: KnowledgeTypeSchema.optional(),
-  domain: z.string().optional(),
-  tags: z.array(z.string()).default([]),
-  // Activation (ACT-R model)
-  activation: ActivationSchema.default({
-    retrieval_strength: 0.7,
-    storage_strength: 1,
-    frequency: 0,
-    last_accessed: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)
-  }),
-  // Relations & grounding
-  relations: RelationsSchema.optional(),
-  associations: z.array(AssociationSchema).default([]),
-  knowledge_anchors: z.array(KnowledgeAnchorSchema).default([]),
-  dual_coding: DualCodingSchema.optional(),
-  // Provenance
-  provenance: ProvenanceSchema.optional(),
-  // Feedback
-  feedback_signals: FeedbackSignalsSchema.default({ positive: 0, negative: 0, neutral: 0 }),
-  // === NEW OPTIONAL FIELDS (v2.1) ===
-  /** Typed entity references extracted from statement. Enables graph queries. */
-  entities: z.array(EntityRefSchema).optional(),
-  /** Temporal validity window. When is this knowledge true? */
-  temporal: TemporalSchema.optional(),
-  /** Automatic usage tracking. Injections, hits, misses. */
-  usage: UsageStatsSchema.optional(),
-  /** Episodic context: emotional weight, confidence, trigger. */
-  episodic: EpisodicFieldsSchema.optional(),
-  /** Exchange marketplace metadata: fitness, adoption, diversity. */
-  exchange: ExchangeMetadataSchema.optional(),
-  /** Extensible key-value data for domain-specific fields. */
-  structured_data: z.record(z.string(), z.unknown()).optional(),
-  /** Polarity classification: 'do' for directives, 'dont' for prohibitions, null for unclassified. */
-  polarity: z.enum(["do", "dont"]).nullable().default(null)
-});
-
-// src/schemas/pack.ts
-import { z as z2 } from "zod";
-var PackManifestSchema = z2.object({
-  name: z2.string(),
-  version: z2.string(),
-  description: z2.string().optional(),
-  creator: z2.string().optional(),
-  license: z2.string().default("cc-by-sa-4.0"),
-  tags: z2.array(z2.string()).default([]),
-  metadata: z2.object({
-    id: z2.string().optional(),
-    injection_policy: z2.enum(["on_match", "on_request", "always"]).default("on_match"),
-    match_terms: z2.array(z2.string()).default([]),
-    domain: z2.string().optional(),
-    engram_count: z2.number().optional()
-  }).optional(),
-  "x-datacore": z2.object({
-    id: z2.string(),
-    injection_policy: z2.enum(["on_match", "on_request"]),
-    match_terms: z2.array(z2.string()).default([]),
-    domain: z2.string().optional(),
-    engram_count: z2.number().int().min(0)
-  }).optional()
-});
-
-// src/logger.ts
-var level = process.env.PLUR_LOG_LEVEL || "warning";
-var levels = { debug: 0, info: 1, warning: 2, error: 3 };
-var threshold = levels[level] ?? 2;
-var logger = {
-  debug: (...args) => {
-    if (threshold <= 0) console.error("[plur:debug]", ...args);
-  },
-  info: (...args) => {
-    if (threshold <= 1) console.error("[plur:info]", ...args);
-  },
-  warning: (...args) => {
-    if (threshold <= 2) console.error("[plur:warning]", ...args);
-  },
-  error: (...args) => {
-    if (threshold <= 3) console.error("[plur:error]", ...args);
-  }
-};
-
-// src/engrams.ts
-function loadEngrams(filePath) {
-  if (!fs.existsSync(filePath)) return [];
-  try {
-    const raw = yaml.load(fs.readFileSync(filePath, "utf8"));
-    if (!raw?.engrams || !Array.isArray(raw.engrams)) return [];
-    const valid = [];
-    let skipped = 0;
-    for (const entry of raw.engrams) {
-      const result = EngramSchema.safeParse(entry);
-      if (result.success) valid.push(result.data);
-      else skipped++;
-    }
-    if (skipped > 0) logger.warning(`Skipped ${skipped} invalid engram(s) in ${filePath}`);
-    return valid;
-  } catch (err) {
-    logger.error(`Failed to parse engrams file ${filePath}: ${err}`);
-    return [];
-  }
-}
-function saveEngrams(filePath, engrams) {
-  const content = yaml.dump({ engrams }, { lineWidth: 120, noRefs: true, quotingType: '"' });
-  atomicWrite(filePath, content);
-}
-function parseSkillMdFrontmatter(filePath) {
-  const content = fs.readFileSync(filePath, "utf8");
-  const match = content.match(/^---\n([\s\S]*?)\n---/);
-  if (!match) throw new Error(`No frontmatter found in ${filePath}`);
-  return yaml.load(match[1]);
-}
-function loadPack(packDir) {
-  const skillMdPath = `${packDir}/SKILL.md`;
-  const manifestYamlPath = `${packDir}/manifest.yaml`;
-  const engramsPath = `${packDir}/engrams.yaml`;
-  let rawManifest;
-  if (fs.existsSync(skillMdPath)) {
-    rawManifest = parseSkillMdFrontmatter(skillMdPath);
-  } else if (fs.existsSync(manifestYamlPath)) {
-    rawManifest = yaml.load(fs.readFileSync(manifestYamlPath, "utf8"));
-  } else {
-    throw new Error(`No SKILL.md or manifest.yaml found in ${packDir}`);
-  }
-  const manifest = PackManifestSchema.parse(rawManifest);
-  const engrams = loadEngrams(engramsPath);
-  return { manifest, engrams };
-}
-function loadAllPacks(packsDir) {
-  if (!fs.existsSync(packsDir)) return [];
-  const packs = [];
-  for (const entry of fs.readdirSync(packsDir)) {
-    const packDir = `${packsDir}/${entry}`;
-    if (!fs.statSync(packDir).isDirectory()) continue;
-    if (!fs.existsSync(`${packDir}/SKILL.md`) && !fs.existsSync(`${packDir}/manifest.yaml`)) continue;
-    try {
-      packs.push(loadPack(packDir));
-    } catch (err) {
-      logger.warning(`Failed to load pack ${entry}: ${err}`);
-    }
-  }
-  return packs;
-}
-function storePrefix(scope) {
-  const parts = scope.split(/[:\-_./]/).filter(Boolean);
-  if (parts.length >= 2) {
-    const p2 = parts[1];
-    return (parts[0][0] + p2[0] + (p2[1] || p2[0])).toUpperCase();
-  }
-  const w = parts[0] || scope;
-  if (w.length >= 3) return (w[0] + w[Math.floor(w.length / 2)] + w[w.length - 1]).toUpperCase();
-  return (w[0] + (w[1] || w[0]) + (w[2] || w[0])).toUpperCase();
-}
-function generateEngramId(existing) {
-  const now = /* @__PURE__ */ new Date();
-  const date = now.toISOString().slice(0, 10).replace(/-/g, "");
-  const prefix = `ENG-${date.slice(0, 4)}-${date.slice(4)}-`;
-  const existingNums = existing.filter((e) => e.id.startsWith(prefix)).map((e) => parseInt(e.id.slice(prefix.length), 10)).filter((n) => !isNaN(n));
-  const next = existingNums.length > 0 ? Math.max(...existingNums) + 1 : 1;
-  return `${prefix}${String(next).padStart(3, "0")}`;
-}
-
-// src/storage-indexed.ts
 var require2 = createRequire(import.meta.url);
 var Database = null;
 function getDatabase() {
@@ -367,7 +114,7 @@ var IndexedStorage = class {
   }
   /** Load all engrams from SQLite index. Auto-rebuilds if db missing. */
   loadAll() {
-    if (!existsSync3(this.dbPath)) {
+    if (!existsSync2(this.dbPath)) {
       this.reindex();
     }
     const db = this.getDb();
@@ -376,7 +123,7 @@ var IndexedStorage = class {
   }
   /** Load engrams with SQL-level filtering. */
   loadFiltered(filter) {
-    if (!existsSync3(this.dbPath)) {
+    if (!existsSync2(this.dbPath)) {
       this.reindex();
     }
     const db = this.getDb();
@@ -400,7 +147,7 @@ var IndexedStorage = class {
   }
   /** Count engrams with optional status filter. */
   count(filter) {
-    if (!existsSync3(this.dbPath)) {
+    if (!existsSync2(this.dbPath)) {
       this.reindex();
     }
     const db = this.getDb();
@@ -465,39 +212,63 @@ var IndexedStorage = class {
 };
 
 // src/config.ts
-import { existsSync as existsSync4, readFileSync as readFileSync2 } from "fs";
-import yaml2 from "js-yaml";
+import { existsSync as existsSync3, readFileSync } from "fs";
+import yaml from "js-yaml";
 
 // src/schemas/config.ts
-import { z as z3 } from "zod";
-var StoreEntrySchema = z3.object({
-  path: z3.string(),
-  scope: z3.string(),
-  shared: z3.boolean().default(false),
-  readonly: z3.boolean().default(false)
+import { z } from "zod";
+var StoreEntrySchema = z.object({
+  path: z.string(),
+  scope: z.string(),
+  shared: z.boolean().default(false),
+  readonly: z.boolean().default(false)
 });
-var PlurConfigSchema = z3.object({
-  auto_learn: z3.boolean().default(true),
-  auto_capture: z3.boolean().default(true),
-  injection_budget: z3.number().default(2e3),
-  decay_enabled: z3.boolean().default(true),
-  decay_threshold: z3.number().default(0.15),
-  packs: z3.array(z3.string()).default([]),
-  injection: z3.object({
-    spread_cap: z3.number().default(3),
-    spread_budget: z3.number().default(480),
-    co_access: z3.boolean().default(true)
+var LlmTierConfigSchema = z.object({
+  dedup_tier: z.enum(["fast", "balanced", "thorough"]).default("fast"),
+  profile_tier: z.enum(["fast", "balanced", "thorough"]).default("balanced"),
+  meta_tier: z.enum(["fast", "balanced", "thorough"]).default("thorough")
+}).partial();
+var ProfileConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  cache_ttl_hours: z.number().default(24)
+}).partial();
+var DedupConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  threshold: z.number().min(0).max(1).default(0.85),
+  mode: z.enum(["llm", "cosine", "off"]).default("llm")
+}).partial();
+var StorageConfigSchema = z.object({
+  backend: z.enum(["yaml", "sqlite"]).default("yaml"),
+  path: z.string().optional()
+}).partial();
+var PlurConfigSchema = z.object({
+  auto_learn: z.boolean().default(true),
+  auto_capture: z.boolean().default(true),
+  injection_budget: z.number().default(2e3),
+  decay_enabled: z.boolean().default(true),
+  decay_threshold: z.number().default(0.15),
+  packs: z.array(z.string()).default([]),
+  injection: z.object({
+    spread_cap: z.number().default(3),
+    spread_budget: z.number().default(480),
+    co_access: z.boolean().default(true)
   }).default({}),
-  allow_secrets: z3.boolean().default(false),
-  index: z3.boolean().default(true),
-  stores: z3.array(StoreEntrySchema).default([])
+  dedup: DedupConfigSchema.default({}),
+  decay_baseline: z.string().optional(),
+  allow_secrets: z.boolean().default(false),
+  index: z.boolean().default(true),
+  storage: StorageConfigSchema.default({}),
+  stores: z.array(StoreEntrySchema).default([]),
+  llm: LlmTierConfigSchema.default({}),
+  profile: ProfileConfigSchema.default({}),
+  registry_url: z.string().url().optional()
 }).partial();
 
 // src/config.ts
 function loadConfig(configPath) {
-  if (!existsSync4(configPath)) return PlurConfigSchema.parse({});
+  if (!existsSync3(configPath)) return PlurConfigSchema.parse({});
   try {
-    const raw = yaml2.load(readFileSync2(configPath, "utf8"));
+    const raw = yaml.load(readFileSync(configPath, "utf8"));
     return PlurConfigSchema.parse(raw ?? {});
   } catch {
     return PlurConfigSchema.parse({});
@@ -523,6 +294,28 @@ function decayedCoAccessStrength(strength, daysSinceUpdate, lambda = 0.01) {
   const floor = 0.02;
   return floor + (strength - floor) * Math.exp(-lambda * daysSinceUpdate);
 }
+function confidenceDecay(retrievalStrength, lastPositiveFeedbackDate, commitment, decayBaseline, now) {
+  if (commitment === "locked") return retrievalStrength;
+  const CONFIDENCE_DECAY_FLOOR = 0.1;
+  const GRACE_PERIOD_DAYS = 90;
+  const MONTHLY_MULTIPLIER = 0.95;
+  const current = now || /* @__PURE__ */ new Date();
+  let referenceDate;
+  if (lastPositiveFeedbackDate) {
+    referenceDate = new Date(lastPositiveFeedbackDate);
+  } else if (decayBaseline) {
+    referenceDate = new Date(decayBaseline);
+  } else {
+    return retrievalStrength;
+  }
+  const daysSinceRef = Math.max(0, Math.floor((current.getTime() - referenceDate.getTime()) / MS_PER_DAY));
+  if (daysSinceRef <= GRACE_PERIOD_DAYS) return retrievalStrength;
+  const daysOverGrace = daysSinceRef - GRACE_PERIOD_DAYS;
+  const monthsOverGrace = daysOverGrace / 30;
+  const multiplier = Math.pow(MONTHLY_MULTIPLIER, monthsOverGrace);
+  const decayed = retrievalStrength * multiplier;
+  return Math.max(CONFIDENCE_DECAY_FLOOR, decayed);
+}
 
 // src/polarity.ts
 var DONT_PATTERNS = [
@@ -571,6 +364,18 @@ function confidenceBand(score) {
   return "low";
 }
 
+// src/fresh-tail.ts
+var FRESH_TAIL_DAYS = 7;
+var FRESH_TAIL_MAX_BOOST = 0.2;
+function freshTailBoost(createdAt, commitment, now) {
+  if (commitment && !["exploring", "leaning"].includes(commitment)) return 0;
+  const created = new Date(createdAt);
+  const today = now ?? /* @__PURE__ */ new Date();
+  const daysSinceCreation = (today.getTime() - created.getTime()) / (1e3 * 60 * 60 * 24);
+  if (daysSinceCreation < 0 || daysSinceCreation > FRESH_TAIL_DAYS) return 0;
+  return FRESH_TAIL_MAX_BOOST * (1 - daysSinceCreation / FRESH_TAIL_DAYS);
+}
+
 // src/inject.ts
 var DEFAULT_MAX_TOKENS = 8e3;
 var DEFAULT_MIN_RELEVANCE = 0.3;
@@ -595,7 +400,7 @@ function tokenize(text) {
 }
 function anchorBoost(engram, taskWords) {
   if (!engram.knowledge_anchors?.length) return 0;
-  const threshold2 = taskWords.size <= 1 ? 1 : 2;
+  const threshold = taskWords.size <= 1 ? 1 : 2;
   let boost = 0;
   for (const anchor of engram.knowledge_anchors) {
     if (!anchor.snippet) continue;
@@ -604,7 +409,7 @@ function anchorBoost(engram, taskWords) {
     for (const word of taskWords) {
       if (snippetWords.has(word)) overlap++;
     }
-    if (overlap >= threshold2) boost += 0.5;
+    if (overlap >= threshold) boost += 0.5;
   }
   return Math.min(boost, 2);
 }
@@ -655,7 +460,12 @@ function scoreEngram(engram, promptLower, promptWords, packMatchTerms, scopeFilt
     if (statementWords.has(word)) termHits += 0.5;
   }
   if (termHits === 0) return 0;
-  const rs = isPack ? engram.activation.retrieval_strength : decayedStrength(engram.activation.retrieval_strength, daysSince(engram.activation.last_accessed));
+  let rs = isPack ? engram.activation.retrieval_strength : decayedStrength(engram.activation.retrieval_strength, daysSince(engram.activation.last_accessed));
+  if (!isPack) {
+    const fb = engram.feedback_signals;
+    const lastPositive = fb && fb.positive > 0 ? engram.activation.last_accessed : null;
+    rs = confidenceDecay(rs, lastPositive, engram.commitment, void 0);
+  }
   let score = termHits * rs;
   const feedback = engram.feedback_signals;
   if (feedback) {
@@ -712,6 +522,11 @@ function selectAndSpread(ctx, personalEngrams, packs, config, embeddingBoosts) {
     } else if (raw > 0 && embBoost > 0) {
       raw += embBoost;
     }
+    if (raw > 0) {
+      const createdAt = engram.temporal?.learned_at ?? engram.activation.last_accessed;
+      const ftBoost = freshTailBoost(createdAt, engram.commitment, /* @__PURE__ */ new Date());
+      if (ftBoost > 0) raw += ftBoost;
+    }
     if (raw > 0) {
       scored.push({ ...engram, keyword_match: raw, raw_score: raw, score: raw });
     }
@@ -813,33 +628,83 @@ function selectAndSpread(ctx, personalEngrams, packs, config, embeddingBoosts) {
   const wireConsider = agentConsider.map(stripScoring);
   const wireDirectives = [];
   const wireConstraints = [];
+  const cognitiveDemoted = [];
   for (const wire of wireAll) {
     const polarity = wire.polarity ?? classifyPolarity(wire.statement);
-    if (polarity === "dont") {
+    const commitment = wire.commitment;
+    if (commitment) {
+      const mult = { locked: 1, decided: 0.9, leaning: 0.7, exploring: 0.5 };
+      wire.confidence_score *= mult[commitment] ?? 1;
+    }
+    const cogLevel = wire.knowledge_type?.cognitive_level;
+    if (cogLevel === "remember" || cogLevel === "understand") {
+      cognitiveDemoted.push(wire);
+    } else if (polarity === "dont") {
+      wireConstraints.push(wire);
+    } else if (cogLevel === "apply" || cogLevel === "analyze") {
       wireConstraints.push(wire);
     } else {
       wireDirectives.push(wire);
     }
   }
+  const allWireConsider = [...wireConsider, ...cognitiveDemoted];
   const considerTokens = dip19PoolTokens + spreadTokens;
   return {
     directives: wireDirectives,
     constraints: wireConstraints,
-    consider: wireConsider,
+    consider: allWireConsider,
     tokens_used: { directives: directiveTokens, consider: considerTokens }
   };
 }
+function formatLayer1(engram) {
+  const display = engram.summary ?? engram.statement.slice(0, 60);
+  return `[${engram.id}] ${display}`;
+}
+function formatLayer2(engram) {
+  return `[${engram.id}] ${engram.statement}`;
+}
+function formatLayer3(engram) {
+  const lines = [`[${engram.id}] ${engram.statement}`];
+  if (engram.rationale) lines.push(`  Rationale: ${engram.rationale}`);
+  const meta = [];
+  if (engram.domain) meta.push(`Domain: ${engram.domain}`);
+  if (engram.confidence_score != null) meta.push(`Confidence: ${engram.confidence_score.toFixed(2)}`);
+  if (engram.activation?.last_accessed) meta.push(`Last verified: ${engram.activation.last_accessed}`);
+  if (meta.length > 0) lines.push(`  ${meta.join(" | ")}`);
+  return lines.join("\n");
+}
+function assignLayer(bucket) {
+  switch (bucket) {
+    case "directives":
+      return 3;
+    case "constraints":
+      return 2;
+    case "consider":
+      return 1;
+  }
+}
+function formatWithLayer(engrams, layer) {
+  if (engrams.length === 0) return "";
+  switch (layer) {
+    case 1:
+      return engrams.map(formatLayer1).join(" | ");
+    case 2:
+      return engrams.map(formatLayer2).join("\n");
+    case 3:
+      return engrams.map(formatLayer3).join("\n");
+  }
+}
 
 // src/episodes.ts
-import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
-import yaml3 from "js-yaml";
+import { existsSync as existsSync4, readFileSync as readFileSync2 } from "fs";
+import yaml2 from "js-yaml";
 function generateEpisodeId() {
   const ts = Date.now();
   const rand = Math.random().toString(36).slice(2, 6);
   return `EP-${ts}-${rand}`;
 }
-function captureEpisode(path2, summary, context) {
-  const episodes = loadEpisodes(path2);
+function captureEpisode(path3, summary, context) {
+  const episodes = loadEpisodes(path3);
   const episode = {
     id: generateEpisodeId(),
     summary,
@@ -850,11 +715,11 @@ function captureEpisode(path2, summary, context) {
     timestamp: (/* @__PURE__ */ new Date()).toISOString()
   };
   episodes.push(episode);
-  atomicWrite(path2, yaml3.dump(episodes, { lineWidth: 120, noRefs: true }));
+  atomicWrite(path3, yaml2.dump(episodes, { lineWidth: 120, noRefs: true }));
   return episode;
 }
-function queryTimeline(path2, query) {
-  let episodes = loadEpisodes(path2);
+function queryTimeline(path3, query) {
+  let episodes = loadEpisodes(path3);
   if (query?.since) episodes = episodes.filter((e) => new Date(e.timestamp) >= query.since);
   if (query?.until) episodes = episodes.filter((e) => new Date(e.timestamp) <= query.until);
   if (query?.agent) episodes = episodes.filter((e) => e.agent === query.agent);
@@ -865,10 +730,10 @@ function queryTimeline(path2, query) {
   }
   return episodes;
 }
-function loadEpisodes(path2) {
-  if (!existsSync5(path2)) return [];
+function loadEpisodes(path3) {
+  if (!existsSync4(path3)) return [];
   try {
-    const raw = yaml3.load(readFileSync3(path2, "utf8"));
+    const raw = yaml2.load(readFileSync2(path3, "utf8"));
     return Array.isArray(raw) ? raw : [];
   } catch {
     return [];
@@ -876,7 +741,7 @@ function loadEpisodes(path2) {
 }
 
 // src/conflict.ts
-function detectConflicts(newEngram, existing, threshold2 = 0.4) {
+function detectConflicts(newEngram, existing, threshold = 0.4) {
   const newScope = newEngram.scope || "global";
   const newTokens = ftsTokenize(newEngram.statement);
   if (newTokens.length === 0) return [];
@@ -884,7 +749,7 @@ function detectConflicts(newEngram, existing, threshold2 = 0.4) {
     if (e.status !== "active") return false;
     if ((e.scope || "global") !== newScope) return false;
     const score = ftsScore(e, newTokens);
-    return score >= threshold2;
+    return score >= threshold;
   });
 }
 
@@ -1059,11 +924,112 @@ async function expandedSearch(engrams, query, limit, llm, storagePath) {
   return merged.slice(0, effectiveLimit);
 }
 
+// src/search-orchestrator.ts
+function isKeywordQuery(query) {
+  const words = query.trim().split(/\s+/);
+  if (words.length >= 5) return false;
+  const nlSignals = /^(what|where|when|how|why|which|who|can|do|does|is|are|should|would|could)\b/i;
+  if (nlSignals.test(query.trim())) return false;
+  if (query.includes("?")) return false;
+  return true;
+}
+function normalizedBm25Scores(engrams, query) {
+  const queryTokens = ftsTokenize(query);
+  if (queryTokens.length === 0) return /* @__PURE__ */ new Map();
+  const idfWeights = computeIdf(engrams, queryTokens);
+  const avgDocLength = engrams.length > 0 ? engrams.reduce((sum, e) => sum + ftsTokenize(engramSearchText(e)).length, 0) / engrams.length : 0;
+  const rawScores = [];
+  for (const e of engrams) {
+    const score = ftsScore(e, queryTokens, idfWeights, avgDocLength);
+    if (score > 0) rawScores.push({ id: e.id, score });
+  }
+  if (rawScores.length === 0) return /* @__PURE__ */ new Map();
+  const min = Math.min(...rawScores.map((r) => r.score));
+  const max = Math.max(...rawScores.map((r) => r.score));
+  const range = max - min || 1;
+  const normalized = /* @__PURE__ */ new Map();
+  for (const { id, score } of rawScores) {
+    normalized.set(id, (score - min) / range);
+  }
+  return normalized;
+}
+async function recallAuto(engrams, query, limit, storagePath, llm) {
+  if (engrams.length === 0) return { results: [], strategy_used: "bm25" };
+  if (isKeywordQuery(query)) {
+    const bm25Results = searchEngrams(engrams, query, limit);
+    const scores2 = normalizedBm25Scores(engrams, query);
+    const maxScore2 = bm25Results.length > 0 ? scores2.get(bm25Results[0].id) ?? 0 : 0;
+    if (bm25Results.length >= 3 && maxScore2 >= 0.3) {
+      return { results: bm25Results, strategy_used: "bm25" };
+    }
+    try {
+      const hybridResults2 = await hybridSearch(engrams, query, limit, storagePath);
+      if (hybridResults2.length >= 3) return { results: hybridResults2, strategy_used: "hybrid" };
+    } catch {
+    }
+    if (llm) {
+      try {
+        const expandedResults = await expandedSearch(engrams, query, limit, llm, storagePath);
+        return { results: expandedResults, strategy_used: "expanded" };
+      } catch {
+      }
+    }
+    return { results: bm25Results, strategy_used: "bm25" };
+  }
+  let hybridResults = [];
+  try {
+    hybridResults = await hybridSearch(engrams, query, limit, storagePath);
+  } catch {
+    const bm25Results = searchEngrams(engrams, query, limit);
+    return { results: bm25Results, strategy_used: "bm25" };
+  }
+  const scores = normalizedBm25Scores(engrams, query);
+  const maxScore = hybridResults.length > 0 ? scores.get(hybridResults[0].id) ?? 0 : 0;
+  if (hybridResults.length >= 3 && maxScore >= 0.3) {
+    return { results: hybridResults, strategy_used: "hybrid" };
+  }
+  if (llm) {
+    try {
+      const expandedResults = await expandedSearch(engrams, query, limit, llm, storagePath);
+      return { results: expandedResults, strategy_used: "expanded" };
+    } catch {
+    }
+  }
+  if (hybridResults.length > 0) return { results: hybridResults, strategy_used: "hybrid" };
+  return { results: searchEngrams(engrams, query, limit), strategy_used: "bm25" };
+}
+
+// src/summary.ts
+var SUMMARY_MAX_LENGTH = 60;
+var STATEMENT_THRESHOLD = 200;
+function needsSummary(statement, cognitiveLevel) {
+  if (statement.length <= STATEMENT_THRESHOLD) return false;
+  if (cognitiveLevel && !["remember", "understand"].includes(cognitiveLevel)) return false;
+  return true;
+}
+function generateSummary(statement) {
+  const sentenceEnd = statement.search(/[.!?]\s/);
+  if (sentenceEnd > 0 && sentenceEnd <= SUMMARY_MAX_LENGTH) {
+    return statement.slice(0, sentenceEnd + 1);
+  }
+  if (statement.length <= SUMMARY_MAX_LENGTH) return statement;
+  const truncated = statement.slice(0, SUMMARY_MAX_LENGTH);
+  const lastSpace = truncated.lastIndexOf(" ");
+  if (lastSpace > SUMMARY_MAX_LENGTH * 0.5) {
+    return truncated.slice(0, lastSpace) + "...";
+  }
+  return truncated + "...";
+}
+function autoSummary(statement, cognitiveLevel) {
+  if (!needsSummary(statement, cognitiveLevel)) return void 0;
+  return generateSummary(statement);
+}
+
 // src/packs.ts
-import * as fs2 from "fs";
+import * as fs from "fs";
 import * as path from "path";
 import * as crypto from "crypto";
-import yaml4 from "js-yaml";
+import yaml3 from "js-yaml";
 
 // src/secrets.ts
 var SECRET_PATTERNS = [
@@ -1094,17 +1060,17 @@ function registryPath(packsDir) {
 }
 function loadRegistry(packsDir) {
   const p = registryPath(packsDir);
-  if (!fs2.existsSync(p)) return [];
+  if (!fs.existsSync(p)) return [];
   try {
-    const raw = yaml4.load(fs2.readFileSync(p, "utf8"));
+    const raw = yaml3.load(fs.readFileSync(p, "utf8"));
     return Array.isArray(raw?.packs) ? raw.packs : [];
   } catch {
     return [];
   }
 }
 function saveRegistry(packsDir, entries) {
-  const content = yaml4.dump({ packs: entries }, { lineWidth: 120, noRefs: true, quotingType: '"' });
-  fs2.writeFileSync(registryPath(packsDir), content);
+  const content = yaml3.dump({ packs: entries }, { lineWidth: 120, noRefs: true, quotingType: '"' });
+  fs.writeFileSync(registryPath(packsDir), content);
 }
 function addToRegistry(packsDir, entry) {
   const entries = loadRegistry(packsDir);
@@ -1118,7 +1084,7 @@ function removeFromRegistry(packsDir, name) {
   saveRegistry(packsDir, entries);
 }
 function previewPack(source) {
-  if (!fs2.existsSync(source)) throw new Error(`Pack source not found: ${source}`);
+  if (!fs.existsSync(source)) throw new Error(`Pack source not found: ${source}`);
   const pack = loadPack(source);
   const security = scanPrivacy(pack.engrams);
   const warnings = [];
@@ -1181,7 +1147,7 @@ function detectConflicts2(newEngrams, existingEngrams) {
   return conflicts;
 }
 function installPack(packsDir, source, existingEngrams) {
-  if (!fs2.existsSync(source)) throw new Error(`Pack source not found: ${source}`);
+  if (!fs.existsSync(source)) throw new Error(`Pack source not found: ${source}`);
   const preview = previewPack(source);
   const secretIssues = preview.security.issues.filter((i) => i.type === "secret");
   if (secretIssues.length > 0) {
@@ -1191,17 +1157,17 @@ ${details}`);
   }
   const sourceName = path.basename(source);
   const destDir = path.join(packsDir, sourceName);
-  if (!fs2.existsSync(destDir)) fs2.mkdirSync(destDir, { recursive: true });
-  const files = fs2.readdirSync(source);
+  if (!fs.existsSync(destDir)) fs.mkdirSync(destDir, { recursive: true });
+  const files = fs.readdirSync(source);
   for (const file of files) {
     const srcPath = path.join(source, file);
     const destPath = path.join(destDir, file);
-    if (fs2.statSync(srcPath).isFile()) {
-      fs2.copyFileSync(srcPath, destPath);
+    if (fs.statSync(srcPath).isFile()) {
+      fs.copyFileSync(srcPath, destPath);
     }
   }
   const engramsPath = path.join(destDir, "engrams.yaml");
-  const newEngrams = fs2.existsSync(engramsPath) ? loadEngrams(engramsPath) : [];
+  const newEngrams = fs.existsSync(engramsPath) ? loadEngrams(engramsPath) : [];
   const conflicts = existingEngrams ? detectConflicts2(newEngrams, existingEngrams) : [];
   const integrity = `sha256:${computePackHash(destDir)}`;
   const registryEntry = {
@@ -1217,8 +1183,8 @@ ${details}`);
 }
 function uninstallPack(packsDir, name) {
   let packDir = path.join(packsDir, name);
-  if (!fs2.existsSync(packDir)) {
-    const entries = fs2.existsSync(packsDir) ? fs2.readdirSync(packsDir) : [];
+  if (!fs.existsSync(packDir)) {
+    const entries = fs.existsSync(packsDir) ? fs.readdirSync(packsDir) : [];
     const match = entries.find((e) => e.toLowerCase() === name.toLowerCase());
     if (match) {
       packDir = path.join(packsDir, match);
@@ -1239,17 +1205,17 @@ function uninstallPack(packsDir, name) {
   }
   removeFromRegistry(packsDir, name);
   if (manifestName && manifestName !== name) removeFromRegistry(packsDir, manifestName);
-  fs2.rmSync(packDir, { recursive: true, force: true });
+  fs.rmSync(packDir, { recursive: true, force: true });
   return { name, removed: true, engram_count: count };
 }
 function listPacks(packsDir) {
-  if (!fs2.existsSync(packsDir)) return [];
+  if (!fs.existsSync(packsDir)) return [];
   const registry = loadRegistry(packsDir);
   const registryMap = new Map(registry.map((r) => [r.name, r]));
   const result = [];
-  for (const entry of fs2.readdirSync(packsDir)) {
+  for (const entry of fs.readdirSync(packsDir)) {
     const packDir = path.join(packsDir, entry);
-    if (!fs2.statSync(packDir).isDirectory()) continue;
+    if (!fs.statSync(packDir).isDirectory()) continue;
     try {
       const pack = loadPack(packDir);
       const currentIntegrity = `sha256:${computePackHash(packDir)}`;
@@ -1266,7 +1232,7 @@ function listPacks(packsDir) {
       });
     } catch {
       const engramsPath = path.join(packDir, "engrams.yaml");
-      const engrams = fs2.existsSync(engramsPath) ? loadEngrams(engramsPath) : [];
+      const engrams = fs.existsSync(engramsPath) ? loadEngrams(engramsPath) : [];
       const reg = registryMap.get(entry);
       result.push({
         name: entry,
@@ -1356,8 +1322,8 @@ function exportPack(engrams, outputDir, manifest) {
   );
   const safeEngrams = engrams.filter((e) => !blockedIds.has(e.id));
   const matchTerms = deriveMatchTerms(safeEngrams);
-  if (!fs2.existsSync(outputDir)) fs2.mkdirSync(outputDir, { recursive: true });
-  const frontmatter = yaml4.dump({
+  if (!fs.existsSync(outputDir)) fs.mkdirSync(outputDir, { recursive: true });
+  const frontmatter = yaml3.dump({
     name: manifest.name,
     version: manifest.version,
     description: manifest.description,
@@ -1368,7 +1334,7 @@ function exportPack(engrams, outputDir, manifest) {
       engram_count: safeEngrams.length
     }
   });
-  fs2.writeFileSync(
+  fs.writeFileSync(
     path.join(outputDir, "SKILL.md"),
     `---
 ${frontmatter}---
@@ -1405,10 +1371,10 @@ ${manifest.description || ""}
     }
     return cleaned;
   });
-  const content = yaml4.dump({ engrams: exportEngrams }, { lineWidth: 120, noRefs: true, quotingType: '"' });
-  fs2.writeFileSync(path.join(outputDir, "engrams.yaml"), content);
+  const content = yaml3.dump({ engrams: exportEngrams }, { lineWidth: 120, noRefs: true, quotingType: '"' });
+  fs.writeFileSync(path.join(outputDir, "engrams.yaml"), content);
   const integrity = computePackHash(outputDir);
-  fs2.writeFileSync(path.join(outputDir, "INTEGRITY"), `sha256:${integrity}
+  fs.writeFileSync(path.join(outputDir, "INTEGRITY"), `sha256:${integrity}
 `);
   return {
     path: outputDir,
@@ -1422,14 +1388,14 @@ function computePackHash(packDir) {
   const hash = crypto.createHash("sha256");
   const skillMd = path.join(packDir, "SKILL.md");
   const manifestYaml = path.join(packDir, "manifest.yaml");
-  if (fs2.existsSync(skillMd)) {
-    hash.update(fs2.readFileSync(skillMd));
-  } else if (fs2.existsSync(manifestYaml)) {
-    hash.update(fs2.readFileSync(manifestYaml));
+  if (fs.existsSync(skillMd)) {
+    hash.update(fs.readFileSync(skillMd));
+  } else if (fs.existsSync(manifestYaml)) {
+    hash.update(fs.readFileSync(manifestYaml));
   }
   const engramsPath = path.join(packDir, "engrams.yaml");
-  if (fs2.existsSync(engramsPath)) {
-    hash.update(fs2.readFileSync(engramsPath));
+  if (fs.existsSync(engramsPath)) {
+    hash.update(fs.readFileSync(engramsPath));
   }
   return hash.digest("hex");
 }
@@ -1550,7 +1516,7 @@ async function computeSimilarityMatrix(templates) {
   const n = templates.length;
   const matrix = Array.from({ length: n }, () => Array(n).fill(0));
   try {
-    const { embed, cosineSimilarity } = await import("./embeddings-2IODIQAF.js");
+    const { embed, cosineSimilarity } = await import("./embeddings-EX7QPXJS.js");
     const embeddings = [];
     for (const t of templates) {
       embeddings.push(await embed(t));
@@ -1580,11 +1546,11 @@ async function computeSimilarityMatrix(templates) {
 }
 var EMBEDDING_THRESHOLD = 0.65;
 var TOKEN_THRESHOLD = 0.35;
-async function clusterByStructure(analyses, threshold2) {
+async function clusterByStructure(analyses, threshold) {
   if (analyses.length < 2) return [];
   const templates = analyses.map((a) => analysisTemplate(a));
   const { matrix, method } = await computeSimilarityMatrix(templates);
-  const effectiveThreshold = threshold2 ?? (method === "embedding" ? EMBEDDING_THRESHOLD : TOKEN_THRESHOLD);
+  const effectiveThreshold = threshold ?? (method === "embedding" ? EMBEDDING_THRESHOLD : TOKEN_THRESHOLD);
   const seenClusters = /* @__PURE__ */ new Set();
   const clusters = [];
   let clusterId = 0;
@@ -1836,6 +1802,8 @@ Return ONLY valid JSON, no markdown fencing.`;
     abstract: null,
     derived_from: null,
     polarity: null,
+    engram_version: 1,
+    episode_ids: [],
     knowledge_type: {
       memory_class: "metacognitive",
       cognitive_level: "evaluate"
@@ -2165,15 +2133,15 @@ Meta-engrams flagged as "[structural transfer \u2014 untested in current domain]
 }
 
 // src/schemas/meta-engram.ts
-import { z as z4 } from "zod";
-var StructuralTemplateSchema = z4.object({
-  goal_type: z4.string().min(1),
-  constraint_type: z4.string().min(1),
-  outcome_type: z4.string().min(1),
-  template: z4.string().min(1),
+import { z as z2 } from "zod";
+var StructuralTemplateSchema = z2.object({
+  goal_type: z2.string().min(1),
+  constraint_type: z2.string().min(1),
+  outcome_type: z2.string().min(1),
+  template: z2.string().min(1),
   /** Structural frame — declares which relational pattern this meta-engram uses.
    *  Allows flexible analogy beyond rigid [goal]+[constraint]->[outcome]. */
-  structure_type: z4.enum([
+  structure_type: z2.enum([
     "goal-constraint-outcome",
     "feedback-loop",
     "causal-chain",
@@ -2182,47 +2150,672 @@ var StructuralTemplateSchema = z4.object({
     "freeform"
   ]).default("goal-constraint-outcome"),
   /** For patterns that don't fit the standard template fields — the LLM's own structural description */
-  freeform_structure: z4.string().optional()
+  freeform_structure: z2.string().optional()
 });
-var EvidenceEntrySchema = z4.object({
-  engram_id: z4.string(),
-  domain: z4.string(),
-  mapping_rationale: z4.string(),
-  alignment_score: z4.number().min(0).max(1)
+var EvidenceEntrySchema = z2.object({
+  engram_id: z2.string(),
+  domain: z2.string(),
+  mapping_rationale: z2.string(),
+  alignment_score: z2.number().min(0).max(1)
 });
-var FalsificationSchema = z4.object({
-  expected_conditions: z4.string(),
-  expected_exceptions: z4.string(),
-  test_prediction: z4.string().optional()
+var FalsificationSchema = z2.object({
+  expected_conditions: z2.string(),
+  expected_exceptions: z2.string(),
+  test_prediction: z2.string().optional()
 });
-var MetaConfidenceSchema = z4.object({
-  evidence_count: z4.number().int().min(0),
-  domain_count: z4.number().int().min(0),
-  structural_depth: z4.number().int().min(1).max(5),
-  validation_ratio: z4.number().min(0).max(1).default(0),
-  composite: z4.number().min(0).max(1)
+var MetaConfidenceSchema = z2.object({
+  evidence_count: z2.number().int().min(0),
+  domain_count: z2.number().int().min(0),
+  structural_depth: z2.number().int().min(1).max(5),
+  validation_ratio: z2.number().min(0).max(1).default(0),
+  composite: z2.number().min(0).max(1)
 });
-var DomainCoverageSchema = z4.object({
-  validated: z4.array(z4.string()),
-  failed: z4.array(z4.string()).default([]),
-  predicted: z4.array(z4.string()).default([])
+var DomainCoverageSchema = z2.object({
+  validated: z2.array(z2.string()),
+  failed: z2.array(z2.string()).default([]),
+  predicted: z2.array(z2.string()).default([])
 });
-var HierarchyPositionSchema = z4.object({
-  level: z4.enum(["mop", "top"]),
-  parent: z4.string().nullable().default(null),
-  children: z4.array(z4.string()).default([])
+var HierarchyPositionSchema = z2.object({
+  level: z2.enum(["mop", "top"]),
+  parent: z2.string().nullable().default(null),
+  children: z2.array(z2.string()).default([])
 });
-var MetaFieldSchema = z4.object({
+var MetaFieldSchema = z2.object({
   structure: StructuralTemplateSchema,
-  evidence: z4.array(EvidenceEntrySchema).min(2),
+  evidence: z2.array(EvidenceEntrySchema).min(2),
   domain_coverage: DomainCoverageSchema,
   falsification: FalsificationSchema,
   confidence: MetaConfidenceSchema,
   hierarchy: HierarchyPositionSchema,
-  pipeline_version: z4.string(),
-  last_validated: z4.string().optional()
+  pipeline_version: z2.string(),
+  last_validated: z2.string().optional()
 });
 
+// src/model-routing.ts
+var DEFAULT_MODEL_MAP = {
+  fast: "claude-haiku-4-0",
+  balanced: "claude-sonnet-4-20250514",
+  thorough: "claude-opus-4-20250514"
+};
+var DEFAULT_TIERS = {
+  dedup_tier: "fast",
+  profile_tier: "balanced",
+  meta_tier: "thorough"
+};
+function selectModel(tier, customMap) {
+  const map = { ...DEFAULT_MODEL_MAP, ...customMap };
+  return map[tier];
+}
+function resolveOperationTier(operation, config) {
+  const key = `${operation}_tier`;
+  return config?.[key] ?? DEFAULT_TIERS[key];
+}
+function selectModelForOperation(operation, config, customMap) {
+  const tier = resolveOperationTier(operation, config);
+  return selectModel(tier, customMap);
+}
+
+// src/profile.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+var PROFILE_PROMPT = `You are analyzing a user's memory engrams to create a brief cognitive profile.
+Below are the user's stored learnings, grouped by domain. Synthesize a concise profile (3-5 sentences) describing:
+- Key preferences and working style
+- Technical domains and expertise areas
+- Constraints and things to avoid
+- Notable patterns in their knowledge
+
+Be specific and actionable. Write in second person ("You prefer...", "You work with...").
+
+Engrams by domain:
+{engrams_by_domain}
+
+Profile:`;
+function getCachePath(storagePath) {
+  return path2.join(storagePath, "profile_cache.json");
+}
+function loadProfileCache(storagePath) {
+  try {
+    return JSON.parse(fs2.readFileSync(getCachePath(storagePath), "utf8"));
+  } catch {
+    return null;
+  }
+}
+function saveProfileCache(storagePath, cache2) {
+  fs2.writeFileSync(getCachePath(storagePath), JSON.stringify(cache2, null, 2));
+}
+function markProfileDirty(storagePath) {
+  const cache2 = loadProfileCache(storagePath);
+  if (cache2) {
+    cache2.dirty = true;
+    saveProfileCache(storagePath, cache2);
+  }
+}
+function profileNeedsRegeneration(cache2, cacheTtlHours = 24) {
+  if (!cache2) return true;
+  if (!cache2.dirty) return false;
+  const hoursSince = (Date.now() - new Date(cache2.generated_at).getTime()) / (1e3 * 60 * 60);
+  return hoursSince >= cacheTtlHours;
+}
+function clusterByDomain(engrams) {
+  const clusters = /* @__PURE__ */ new Map();
+  for (const e of engrams) {
+    const domain = e.domain?.split(".")[0] ?? "general";
+    const list = clusters.get(domain) ?? [];
+    list.push(e);
+    clusters.set(domain, list);
+  }
+  return clusters;
+}
+function formatClusters(clusters) {
+  const lines = [];
+  for (const [domain, engrams] of clusters) {
+    lines.push(`
+### ${domain} (${engrams.length} engrams)`);
+    for (const e of engrams.slice(0, 10)) lines.push(`- ${e.statement}`);
+    if (engrams.length > 10) lines.push(`  ... and ${engrams.length - 10} more`);
+  }
+  return lines.join("\n");
+}
+async function generateProfile(engrams, llm, storagePath, cacheTtlHours = 24) {
+  const cache2 = loadProfileCache(storagePath);
+  if (cache2 && !profileNeedsRegeneration(cache2, cacheTtlHours)) return cache2.profile;
+  if (engrams.length === 0) return null;
+  const clusters = clusterByDomain(engrams);
+  const prompt = PROFILE_PROMPT.replace("{engrams_by_domain}", formatClusters(clusters));
+  try {
+    const profile = await llm(prompt);
+    if (!profile?.trim()) return cache2?.profile ?? null;
+    saveProfileCache(storagePath, {
+      profile: profile.trim(),
+      generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+      engram_count: engrams.length,
+      dirty: false
+    });
+    return profile.trim();
+  } catch {
+    return cache2?.profile ?? null;
+  }
+}
+function getProfileForInjection(storagePath) {
+  const cache2 = loadProfileCache(storagePath);
+  return cache2?.profile ?? null;
+}
+
+// src/migrations/runner.ts
+import * as fs3 from "fs";
+import * as yaml4 from "js-yaml";
+
+// src/migrations/20260406-001-add-commitment.ts
+var migration = {
+  id: "20260406-001-add-commitment",
+  description: "Add commitment field (default: decided for existing, leaning for new)",
+  up(engrams) {
+    return engrams.map((e) => {
+      const clone = { ...e };
+      if (!clone.commitment) {
+        clone.commitment = e.status === "active" ? "decided" : "leaning";
+      }
+      return clone;
+    });
+  },
+  down(engrams) {
+    return engrams.map((e) => {
+      const clone = { ...e };
+      delete clone.commitment;
+      delete clone.locked_at;
+      delete clone.locked_reason;
+      return clone;
+    });
+  }
+};
+
+// src/migrations/20260406-002-add-content-hash.ts
+var migration2 = {
+  id: "20260406-002-add-content-hash",
+  description: "Add content_hash field (SHA256 of normalized statement)",
+  up(engrams) {
+    return engrams.map((e) => {
+      const clone = { ...e };
+      if (!clone.content_hash) {
+        clone.content_hash = computeContentHash(e.statement);
+      }
+      return clone;
+    });
+  },
+  down(engrams) {
+    return engrams.map((e) => {
+      const clone = { ...e };
+      delete clone.content_hash;
+      return clone;
+    });
+  }
+};
+
+// src/migrations/20260406-003-populate-memory-class.ts
+var TYPE_TO_MEMORY_CLASS = {
+  behavioral: "semantic",
+  terminological: "semantic",
+  procedural: "procedural",
+  architectural: "semantic"
+};
+var migration3 = {
+  id: "20260406-003-populate-memory-class",
+  description: "Populate existing knowledge_type.memory_class based on type",
+  up(engrams) {
+    return engrams.map((e) => {
+      const raw = e;
+      if (raw.knowledge_type?.memory_class) return e;
+      const memoryClass = TYPE_TO_MEMORY_CLASS[e.type] ?? "semantic";
+      const cogLevel = raw.knowledge_type?.cognitive_level ?? "remember";
+      return {
+        ...e,
+        knowledge_type: { memory_class: memoryClass, cognitive_level: cogLevel }
+      };
+    });
+  },
+  down(engrams) {
+    return engrams.map((e) => {
+      const raw = e;
+      if (raw.knowledge_type) {
+        const { ...rest } = raw;
+        delete rest.knowledge_type;
+        return rest;
+      }
+      return e;
+    });
+  }
+};
+
+// src/migrations/20260406-004-populate-cognitive-level.ts
+var TYPE_TO_COGNITIVE = {
+  behavioral: "apply",
+  terminological: "remember",
+  procedural: "apply",
+  architectural: "evaluate"
+};
+var TYPE_TO_MEMORY_CLASS2 = {
+  behavioral: "semantic",
+  terminological: "semantic",
+  procedural: "procedural",
+  architectural: "semantic"
+};
+var migration4 = {
+  id: "20260406-004-populate-cognitive-level",
+  description: "Populate existing knowledge_type.cognitive_level based on type",
+  up(engrams) {
+    return engrams.map((e) => {
+      const clone = { ...e };
+      const cogLevel = TYPE_TO_COGNITIVE[e.type] ?? "remember";
+      const memClass = TYPE_TO_MEMORY_CLASS2[e.type] ?? "semantic";
+      if (!clone.knowledge_type) {
+        clone.knowledge_type = { cognitive_level: cogLevel, memory_class: memClass };
+      } else {
+        if (!clone.knowledge_type.cognitive_level) {
+          clone.knowledge_type = { ...clone.knowledge_type, cognitive_level: cogLevel };
+        }
+        if (!clone.knowledge_type.memory_class) {
+          clone.knowledge_type = { ...clone.knowledge_type, memory_class: memClass };
+        }
+      }
+      return clone;
+    });
+  },
+  down(engrams) {
+    return engrams.map((e) => {
+      const clone = { ...e };
+      delete clone.knowledge_type;
+      return clone;
+    });
+  }
+};
+
+// src/migrations/20260406-005-add-version-field.ts
+var migration5 = {
+  id: "20260406-005-add-version-field",
+  description: "Add engram_version: 1 and episode_ids: [] to all engrams",
+  up(engrams) {
+    return engrams.map((e) => {
+      const raw = e;
+      return {
+        ...e,
+        engram_version: raw.engram_version ?? 1,
+        episode_ids: raw.episode_ids ?? []
+      };
+    });
+  },
+  down(engrams) {
+    return engrams.map((e) => {
+      const raw = e;
+      const { engram_version, episode_ids, previous_version_ref, ...rest } = raw;
+      return rest;
+    });
+  }
+};
+
+// src/migrations/runner.ts
+var ALL_MIGRATIONS = [migration, migration2, migration3, migration4, migration5];
+var CURRENT_SCHEMA_VERSION = ALL_MIGRATIONS.length;
+function getSchemaVersion(configPath) {
+  if (!fs3.existsSync(configPath)) return 0;
+  try {
+    const raw = yaml4.load(fs3.readFileSync(configPath, "utf8"));
+    if (!raw || typeof raw.schema_version !== "number") return 0;
+    return raw.schema_version;
+  } catch {
+    return 0;
+  }
+}
+function setSchemaVersion(configPath, version) {
+  let configData = {};
+  try {
+    const raw = fs3.readFileSync(configPath, "utf8");
+    if (raw) configData = yaml4.load(raw) ?? {};
+  } catch {
+  }
+  configData.schema_version = version;
+  fs3.writeFileSync(configPath, yaml4.dump(configData, { lineWidth: 120, noRefs: true }));
+}
+function createBackup(engramsPath, version) {
+  if (!fs3.existsSync(engramsPath)) return null;
+  const backupPath = `${engramsPath}.bak.${version}`;
+  fs3.copyFileSync(engramsPath, backupPath);
+  return backupPath;
+}
+function restoreBackup(engramsPath, backupPath) {
+  fs3.copyFileSync(backupPath, engramsPath);
+}
+function runMigrations(engramsPath, configPath, options) {
+  const currentVersion = getSchemaVersion(configPath);
+  const pending = ALL_MIGRATIONS.slice(currentVersion);
+  if (pending.length === 0) {
+    return { applied: [], schema_version: currentVersion, backup_path: null };
+  }
+  const backupPath = options?.dryRun ? null : createBackup(engramsPath, currentVersion);
+  let engrams = loadEngrams(engramsPath);
+  const applied = [];
+  for (const migration6 of pending) {
+    logger.info(`Running migration: ${migration6.id} \u2014 ${migration6.description}`);
+    try {
+      engrams = migration6.up(engrams);
+      applied.push(migration6.id);
+    } catch (err) {
+      logger.error(`Migration ${migration6.id} failed: ${err}`);
+      if (backupPath) {
+        restoreBackup(engramsPath, backupPath);
+        logger.info(`Restored engrams.yaml from backup: ${backupPath}`);
+      }
+      throw new Error(`Migration ${migration6.id} failed: ${err}. Engrams restored from backup.`);
+    }
+  }
+  if (!options?.dryRun) {
+    saveEngrams(engramsPath, engrams);
+    const newVersion = currentVersion + applied.length;
+    setSchemaVersion(configPath, newVersion);
+  }
+  return {
+    applied,
+    schema_version: currentVersion + applied.length,
+    backup_path: backupPath
+  };
+}
+function rollbackMigrations(engramsPath, configPath, targetVersion) {
+  const currentVersion = getSchemaVersion(configPath);
+  if (targetVersion >= currentVersion) {
+    return { applied: [], schema_version: currentVersion, backup_path: null };
+  }
+  if (targetVersion < 0) {
+    throw new Error("Target version cannot be negative");
+  }
+  const backupPath = createBackup(engramsPath, currentVersion);
+  let engrams = loadEngrams(engramsPath);
+  const rolledBack = [];
+  const toRollback = ALL_MIGRATIONS.slice(targetVersion, currentVersion).reverse();
+  for (const migration6 of toRollback) {
+    logger.info(`Rolling back migration: ${migration6.id}`);
+    try {
+      engrams = migration6.down(engrams);
+      rolledBack.push(migration6.id);
+    } catch (err) {
+      logger.error(`Rollback of ${migration6.id} failed: ${err}`);
+      if (backupPath) {
+        restoreBackup(engramsPath, backupPath);
+        logger.info(`Restored engrams.yaml from backup: ${backupPath}`);
+      }
+      throw new Error(`Rollback of ${migration6.id} failed: ${err}. Engrams restored from backup.`);
+    }
+  }
+  saveEngrams(engramsPath, engrams);
+  setSchemaVersion(configPath, targetVersion);
+  return {
+    applied: rolledBack,
+    schema_version: targetVersion,
+    backup_path: backupPath
+  };
+}
+
+// src/store/yaml-store.ts
+import { existsSync as existsSync8 } from "fs";
+import { readFile } from "fs/promises";
+import * as yaml5 from "js-yaml";
+
+// src/store/async-fs.ts
+import { existsSync as existsSync7 } from "fs";
+import { writeFile, rename, mkdir } from "fs/promises";
+import { dirname } from "path";
+async function asyncAtomicWrite(filePath, content) {
+  const dir = dirname(filePath);
+  if (!existsSync7(dir)) await mkdir(dir, { recursive: true });
+  const tmp = filePath + ".tmp";
+  await writeFile(tmp, content);
+  await rename(tmp, filePath);
+}
+
+// src/store/async-lock.ts
+import { writeFile as writeFile2, unlink, stat } from "fs/promises";
+import { constants } from "fs";
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function withAsyncLock(filePath, fn, options) {
+  const lockPath = filePath + ".lock";
+  const maxRetries = options?.maxRetries ?? 5;
+  const baseDelay = options?.baseDelay ?? 100;
+  const staleThreshold = options?.staleThreshold ?? 1e4;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      await writeFile2(lockPath, `${process.pid}`, { flag: constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL });
+      break;
+    } catch (err) {
+      if (err.code !== "EEXIST") throw err;
+      try {
+        const s = await stat(lockPath);
+        if (Date.now() - s.mtimeMs > staleThreshold) {
+          await unlink(lockPath).catch(() => {
+          });
+          continue;
+        }
+      } catch {
+        continue;
+      }
+      if (attempt === maxRetries) {
+        throw new Error(`Failed to acquire lock on ${filePath} after ${maxRetries} retries`);
+      }
+      const delay = baseDelay * Math.pow(2, attempt);
+      await sleep(delay);
+    }
+  }
+  try {
+    return await fn();
+  } finally {
+    await unlink(lockPath).catch(() => {
+    });
+  }
+}
+
+// src/store/yaml-store.ts
+var YamlStore = class {
+  filePath;
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  async load() {
+    if (!existsSync8(this.filePath)) return [];
+    try {
+      const content = await readFile(this.filePath, "utf8");
+      const raw = yaml5.load(content);
+      if (!raw?.engrams || !Array.isArray(raw.engrams)) return [];
+      const valid = [];
+      let skipped = 0;
+      for (const entry of raw.engrams) {
+        const result = EngramSchemaPassthrough.safeParse(entry);
+        if (result.success) valid.push(result.data);
+        else skipped++;
+      }
+      if (skipped > 0) logger.warning(`Skipped ${skipped} invalid engram(s) in ${this.filePath}`);
+      return valid;
+    } catch (err) {
+      logger.error(`Failed to parse engrams file ${this.filePath}: ${err}`);
+      return [];
+    }
+  }
+  async save(engrams) {
+    await withAsyncLock(this.filePath, async () => {
+      const content = yaml5.dump({ engrams }, { lineWidth: 120, noRefs: true, quotingType: '"' });
+      await asyncAtomicWrite(this.filePath, content);
+    });
+  }
+  async append(engram) {
+    await withAsyncLock(this.filePath, async () => {
+      const engrams = await this._loadRaw();
+      engrams.push(engram);
+      const content = yaml5.dump({ engrams }, { lineWidth: 120, noRefs: true, quotingType: '"' });
+      await asyncAtomicWrite(this.filePath, content);
+    });
+  }
+  async getById(id) {
+    const engrams = await this.load();
+    return engrams.find((e) => e.id === id) ?? null;
+  }
+  async remove(id) {
+    return await withAsyncLock(this.filePath, async () => {
+      const engrams = await this._loadRaw();
+      const idx = engrams.findIndex((e) => e.id === id);
+      if (idx === -1) return false;
+      engrams.splice(idx, 1);
+      const content = yaml5.dump({ engrams }, { lineWidth: 120, noRefs: true, quotingType: '"' });
+      await asyncAtomicWrite(this.filePath, content);
+      return true;
+    });
+  }
+  async count(filter) {
+    const engrams = await this.load();
+    if (filter?.status) {
+      return engrams.filter((e) => e.status === filter.status).length;
+    }
+    return engrams.length;
+  }
+  async close() {
+  }
+  /** Raw load without validation — for internal mutate-and-save operations. */
+  async _loadRaw() {
+    if (!existsSync8(this.filePath)) return [];
+    try {
+      const content = await readFile(this.filePath, "utf8");
+      const raw = yaml5.load(content);
+      if (!raw?.engrams || !Array.isArray(raw.engrams)) return [];
+      const valid = [];
+      for (const entry of raw.engrams) {
+        const result = EngramSchemaPassthrough.safeParse(entry);
+        if (result.success) valid.push(result.data);
+      }
+      return valid;
+    } catch {
+      return [];
+    }
+  }
+};
+
+// src/store/sqlite-store.ts
+import { createRequire as createRequire2 } from "module";
+var require3 = createRequire2(import.meta.url);
+var Database2 = null;
+function getDatabase2() {
+  if (!Database2) {
+    try {
+      Database2 = require3("better-sqlite3");
+    } catch {
+      throw new Error(
+        "better-sqlite3 is required for sqlite backend. Install it with: npm install better-sqlite3"
+      );
+    }
+  }
+  return Database2;
+}
+var SqliteStore = class {
+  dbPath;
+  db = null;
+  constructor(dbPath) {
+    this.dbPath = dbPath;
+  }
+  getDb() {
+    if (!this.db) {
+      const DB = getDatabase2();
+      this.db = new DB(this.dbPath);
+      this.db.pragma("journal_mode = WAL");
+      this.db.exec(`
+        CREATE TABLE IF NOT EXISTS engrams (
+          id TEXT PRIMARY KEY,
+          status TEXT NOT NULL,
+          scope TEXT NOT NULL,
+          domain TEXT,
+          last_accessed TEXT,
+          data TEXT NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS idx_status ON engrams(status);
+        CREATE INDEX IF NOT EXISTS idx_scope ON engrams(scope);
+        CREATE INDEX IF NOT EXISTS idx_domain ON engrams(domain);
+      `);
+    }
+    return this.db;
+  }
+  async load() {
+    const db = this.getDb();
+    const rows = db.prepare("SELECT data FROM engrams").all();
+    return rows.map((r) => JSON.parse(r.data));
+  }
+  async save(engrams) {
+    const db = this.getDb();
+    const upsert = db.prepare(`
+      INSERT OR REPLACE INTO engrams (id, status, scope, domain, last_accessed, data)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `);
+    const tx = db.transaction(() => {
+      db.exec("DELETE FROM engrams");
+      for (const e of engrams) {
+        upsert.run(e.id, e.status, e.scope, e.domain ?? null, e.activation.last_accessed, JSON.stringify(e));
+      }
+    });
+    tx();
+  }
+  async append(engram) {
+    const db = this.getDb();
+    db.prepare(`
+      INSERT OR REPLACE INTO engrams (id, status, scope, domain, last_accessed, data)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `).run(engram.id, engram.status, engram.scope, engram.domain ?? null, engram.activation.last_accessed, JSON.stringify(engram));
+  }
+  async getById(id) {
+    const db = this.getDb();
+    const row = db.prepare("SELECT data FROM engrams WHERE id = ?").get(id);
+    if (!row) return null;
+    return JSON.parse(row.data);
+  }
+  async remove(id) {
+    const db = this.getDb();
+    const result = db.prepare("DELETE FROM engrams WHERE id = ?").run(id);
+    return result.changes > 0;
+  }
+  async count(filter) {
+    const db = this.getDb();
+    if (filter?.status) {
+      return db.prepare("SELECT COUNT(*) as c FROM engrams WHERE status = ?").get(filter.status).c;
+    }
+    return db.prepare("SELECT COUNT(*) as c FROM engrams").get().c;
+  }
+  async close() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+  /** Import engrams from an array (e.g., from YAML migration). */
+  async importFrom(engrams) {
+    await this.save(engrams);
+  }
+  /** Export all engrams as an array (e.g., for YAML migration). */
+  async exportAll() {
+    return this.load();
+  }
+};
+
+// src/store/factory.ts
+import { join as join4 } from "path";
+function createStore(config) {
+  switch (config.backend) {
+    case "sqlite":
+      return new SqliteStore(join4(config.path, "engrams.db"));
+    case "yaml":
+    default:
+      return new YamlStore(join4(config.path, "engrams.yaml"));
+  }
+}
+async function migrateStore(from, to) {
+  const engrams = await from.load();
+  await to.save(engrams);
+  return engrams.length;
+}
+
 // src/version-check.ts
 var cache = /* @__PURE__ */ new Map();
 async function checkForUpdate(packageName, currentVersion, onResult) {
@@ -2275,6 +2868,18 @@ function isNewer(a, b) {
 }
 
 // src/index.ts
+var COMMITMENT_MULTIPLIER = {
+  locked: 1,
+  decided: 0.9,
+  leaning: 0.7,
+  exploring: 0.5
+};
+var TYPE_TO_COGNITIVE2 = {
+  behavioral: "apply",
+  terminological: "remember",
+  procedural: "apply",
+  architectural: "evaluate"
+};
 var INGEST_PATTERNS = [
   { re: /(?:we decided|the decision is|agreed to)\s+(.+?)\.?$/gim, type: "architectural" },
   { re: /(?:always|never|must|should)\s+(.+?)\.?$/gim, type: "behavioral" },
@@ -2287,6 +2892,8 @@ var Plur = class {
   config;
   indexedStorage = null;
   _engramCache = /* @__PURE__ */ new Map();
+  _llmFailureCount = 0;
+  _llmDisabledUntil = null;
   constructor(options) {
     this.paths = detectPlurStorage(options?.path);
     this.config = loadConfig(this.paths.config);
@@ -2334,17 +2941,17 @@ var Plur = class {
     return all;
   }
   /** Load engrams from a path with mtime-based caching */
-  _loadCached(path2) {
+  _loadCached(path3) {
     let mtime = 0;
     try {
-      mtime = fs3.statSync(path2).mtimeMs;
+      mtime = fs4.statSync(path3).mtimeMs;
     } catch {
       return [];
     }
-    const cached = this._engramCache.get(path2);
+    const cached = this._engramCache.get(path3);
     if (cached && cached.mtime === mtime) return cached.engrams;
-    const engrams = loadEngrams(path2);
-    this._engramCache.set(path2, { mtime, engrams });
+    const engrams = loadEngrams(path3);
+    this._engramCache.set(path3, { mtime, engrams });
     return engrams;
   }
   /** Find which store owns an engram by ID. For namespaced IDs, strips prefix to find in store. */
@@ -2367,7 +2974,35 @@ var Plur = class {
     }
     return null;
   }
-  /** Create engram, detect conflicts, save. Returns the created engram. */
+  /** Content hash fast-path dedup. */
+  _hashDedup(statement, engrams) {
+    const hash = computeContentHash(statement);
+    for (const e of engrams) {
+      if (e.status === "active" && e.content_hash === hash) return e;
+    }
+    return null;
+  }
+  _isLlmDedupAvailable() {
+    if (this._llmDisabledUntil !== null) {
+      if (Date.now() < this._llmDisabledUntil) return false;
+      this._llmDisabledUntil = null;
+      this._llmFailureCount = 0;
+    }
+    return true;
+  }
+  _recordLlmFailure() {
+    this._llmFailureCount++;
+    if (this._llmFailureCount >= 3) {
+      this._llmDisabledUntil = Date.now() + 60 * 60 * 1e3;
+      logger.warning("LLM dedup circuit breaker tripped \u2014 disabled for 1 hour");
+    }
+  }
+  _recordLlmSuccess() {
+    this._llmFailureCount = 0;
+  }
+  /** Create engram with content hash + commitment + cognitive level.
+   * Fast-path hash dedup returns existing on exact match.
+   */
   learn(statement, context) {
     if (!this.config.allow_secrets) {
       const secrets = detectSecrets(statement);
@@ -2378,17 +3013,34 @@ var Plur = class {
     return withLock(this.paths.engrams, () => {
       const engrams = loadEngrams(this.paths.engrams);
       const allEngrams = this._loadAllEngrams();
+      const hashMatch = this._hashDedup(statement, allEngrams);
+      if (hashMatch) return hashMatch;
       const id = generateEngramId(allEngrams);
       const scope = context?.scope ?? "global";
       const now = (/* @__PURE__ */ new Date()).toISOString();
+      const type = context?.type ?? "behavioral";
+      const cogLevel = TYPE_TO_COGNITIVE2[type] ?? "remember";
+      const commitment = context?.commitment ?? "leaning";
       const conflictingEngrams = detectConflicts({ statement, scope }, allEngrams);
       const conflictIds = conflictingEngrams.map((e) => e.id);
+      const TYPE_TO_MEMORY_CLASS3 = {
+        behavioral: "semantic",
+        terminological: "semantic",
+        procedural: "procedural",
+        architectural: "semantic"
+      };
+      const engramType = context?.type ?? "behavioral";
+      const memoryClass = context?.memory_class ?? TYPE_TO_MEMORY_CLASS3[engramType] ?? "semantic";
+      const episodeIds = [];
+      if (context?.session_episode_id) {
+        episodeIds.push(context.session_episode_id);
+      }
       const engram = {
         id,
         version: 2,
         status: "active",
         consolidated: false,
-        type: context?.type ?? "behavioral",
+        type,
         scope,
         visibility: context?.visibility ?? (context?.domain ? "public" : "private"),
         statement,
@@ -2402,6 +3054,7 @@ var Plur = class {
           last_accessed: now.slice(0, 10)
         },
         feedback_signals: { positive: 0, negative: 0, neutral: 0 },
+        knowledge_type: { memory_class: memoryClass, cognitive_level: cogLevel },
         knowledge_anchors: (context?.knowledge_anchors ?? []).map((a) => ({
           path: a.path,
           relevance: a.relevance ?? "supporting",
@@ -2415,6 +3068,13 @@ var Plur = class {
         derived_from: context?.derived_from ?? null,
         dual_coding: context?.dual_coding,
         polarity: null,
+        content_hash: computeContentHash(statement),
+        commitment,
+        locked_at: commitment === "locked" ? now : void 0,
+        locked_reason: commitment === "locked" ? context?.locked_reason : void 0,
+        summary: autoSummary(statement, void 0),
+        engram_version: 1,
+        episode_ids: episodeIds ?? [],
         relations: conflictIds.length > 0 ? {
           broader: [],
           narrower: [],
@@ -2425,9 +3085,42 @@ var Plur = class {
       engrams.push(engram);
       saveEngrams(this.paths.engrams, engrams);
       this._syncIndex();
+      appendHistory(this.paths.root, {
+        event: "engram_created",
+        engram_id: engram.id,
+        timestamp: now,
+        data: { type: engram.type, scope: engram.scope, source: engram.source }
+      });
       return engram;
     });
   }
+  /** Build deps for learn-async module. */
+  _learnAsyncDeps() {
+    return {
+      hashDedup: (statement) => this._hashDedup(statement, this._loadAllEngrams()),
+      recallHybrid: (query, options) => this.recallHybrid(query, options),
+      recall: (query, options) => this.recall(query, options),
+      learn: (statement, context) => this.learn(statement, context),
+      getById: (id) => this.getById(id),
+      engramsPath: this.paths.engrams,
+      rootPath: this.paths.root,
+      dedupConfig: this.config.dedup ?? {},
+      isLlmAvailable: () => this._isLlmDedupAvailable(),
+      recordLlmSuccess: () => this._recordLlmSuccess(),
+      recordLlmFailure: () => this._recordLlmFailure(),
+      syncIndex: () => this._syncIndex()
+    };
+  }
+  /** Async learn with LLM-driven deduplication (Ideas 1+2+19). */
+  async learnAsync(statement, context) {
+    const { learnAsync: learnAsyncImpl } = await import("./learn-async-VXBH3TYE.js");
+    return learnAsyncImpl(this._learnAsyncDeps(), statement, context);
+  }
+  /** Batch learn with LLM dedup. */
+  async learnBatch(statements, llm) {
+    const { learnBatch: learnBatchImpl } = await import("./learn-async-VXBH3TYE.js");
+    return learnBatchImpl(this._learnAsyncDeps(), statements, llm);
+  }
   /**
    * Search engrams, filter by scope/domain/strength, reactivate accessed.
    * Supports two modes:
@@ -2474,6 +3167,13 @@ var Plur = class {
     this._reactivateResults(results);
     return results;
   }
+  async recallAutoSearch(query, options) {
+    const filtered = this._filterEngrams(options);
+    const limit = options?.limit ?? 20;
+    const result = await recallAuto(filtered, query, limit, this.paths.root, options?.llm);
+    this._reactivateResults(result.results);
+    return result;
+  }
   /** Get a single engram by ID, regardless of status. Searches primary + all stores. */
   getById(id) {
     const engrams = this._loadAllEngrams();
@@ -2610,13 +3310,9 @@ var Plur = class {
       },
       embeddingBoosts
     );
-    const formatEngrams = (wires) => {
-      if (wires.length === 0) return "";
-      return wires.map((e) => `[${e.id}] ${e.statement}`).join("\n");
-    };
-    const directivesStr = formatEngrams(result.directives);
-    const constraintsStr = formatEngrams(result.constraints);
-    const considerStr = formatEngrams(result.consider);
+    const directivesStr = formatWithLayer(result.directives, assignLayer("directives"));
+    const constraintsStr = formatWithLayer(result.constraints, assignLayer("constraints"));
+    const considerStr = formatWithLayer(result.consider, assignLayer("consider"));
     const count = result.directives.length + result.constraints.length + result.consider.length;
     const tokensUsed = result.tokens_used.directives + result.tokens_used.consider;
     const injected_ids = [
@@ -2645,11 +3341,20 @@ var Plur = class {
       engram.feedback_signals[signal] += 1;
       if (signal === "positive") {
         engram.activation.retrieval_strength = Math.min(1, engram.activation.retrieval_strength + 0.05);
+        const e = engram;
+        if (e.commitment === "exploring") e.commitment = "leaning";
+        else if (e.commitment === "leaning") e.commitment = "decided";
       } else if (signal === "negative") {
         engram.activation.retrieval_strength = Math.max(0, engram.activation.retrieval_strength - 0.1);
       }
       saveEngrams(this.paths.engrams, engrams);
       this._syncIndex();
+      appendHistory(this.paths.root, {
+        event: "feedback_received",
+        engram_id: id,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        data: { signal }
+      });
       return true;
     });
     if (found) return;
@@ -2724,6 +3429,12 @@ var Plur = class {
       }
       saveEngrams(this.paths.engrams, engrams);
       this._syncIndex();
+      appendHistory(this.paths.root, {
+        event: "engram_retired",
+        engram_id: id,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        data: { reason: reason ?? null }
+      });
       return true;
     });
     if (foundInPrimary) return;
@@ -2775,12 +3486,12 @@ var Plur = class {
   }
   /** Search packs for an engram by ID and apply feedback, writing back to the pack's engrams.yaml. */
   _feedbackPack(id, signal) {
-    if (!fs3.existsSync(this.paths.packs)) throw new Error(`Engram not found: ${id}`);
-    for (const entry of fs3.readdirSync(this.paths.packs)) {
+    if (!fs4.existsSync(this.paths.packs)) throw new Error(`Engram not found: ${id}`);
+    for (const entry of fs4.readdirSync(this.paths.packs)) {
       const packDir = `${this.paths.packs}/${entry}`;
-      if (!fs3.statSync(packDir).isDirectory()) continue;
+      if (!fs4.statSync(packDir).isDirectory()) continue;
       const engramsPath = `${packDir}/engrams.yaml`;
-      if (!fs3.existsSync(engramsPath)) continue;
+      if (!fs4.existsSync(engramsPath)) continue;
       const engrams = loadEngrams(engramsPath);
       const engram = engrams.find((e) => e.id === id);
       if (!engram) continue;
@@ -2859,6 +3570,12 @@ var Plur = class {
   listPacks() {
     return listPacks(this.paths.packs);
   }
+  // SP5 methods (deferred — vault-export, registry not yet merged)
+  // exportToVault, discoverPacks, getRegistryUrl will be added when SP5 merges
+  /** Get the PLUR storage root path. */
+  getStorageRoot() {
+    return this.paths.root;
+  }
   /** Sync engrams to git. Initializes repo on first call, commits + push/pull on subsequent calls. */
   sync(remote) {
     return sync(this.paths.root, remote);
@@ -2867,17 +3584,158 @@ var Plur = class {
   syncStatus() {
     return getSyncStatus(this.paths.root);
   }
+  /**
+   * Promote an episode to an episodic engram (SP2 Idea 3).
+   * Creates a new engram with memory_class='episodic' from an episode's summary.
+   */
+  episodeToEngram(episodeId, context) {
+    const episodes = queryTimeline(this.paths.episodes);
+    const episode = episodes.find((e) => e.id === episodeId);
+    if (!episode) throw new Error(`Episode not found: ${episodeId}`);
+    const engram = this.learn(episode.summary, {
+      ...context,
+      type: context?.type ?? "behavioral",
+      source: context?.source ?? `episode:${episodeId}`,
+      memory_class: "episodic",
+      session_episode_id: episodeId
+    });
+    appendHistory(this.paths.root, {
+      event: "engram_promoted",
+      engram_id: engram.id,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      data: { from_episode: episodeId }
+    });
+    return engram;
+  }
+  /**
+   * Get history events for a specific engram (SP2 Idea 7).
+   * Returns all events across all months for the given engram ID.
+   */
+  getEngramHistory(engramId) {
+    return readHistoryForEngram(this.paths.root, engramId);
+  }
+  /**
+   * Report a failure for a procedural engram (SP2 Idea 18).
+   * If LLM is provided, generates an improved procedure and updates the engram.
+   * Without LLM, logs the failure without rewriting.
+   * Returns the updated engram and the failure episode.
+   */
+  async reportFailure(engramId, failureContext, llm) {
+    const engram = this.getById(engramId);
+    if (!engram) throw new Error(`Engram not found: ${engramId}`);
+    const memClass = engram.knowledge_type?.memory_class;
+    if (memClass !== "procedural" && engram.type !== "procedural") {
+      throw new Error(`Only procedural engrams can evolve. This engram has type=${engram.type}, memory_class=${memClass}`);
+    }
+    const history = readHistoryForEngram(this.paths.root, engramId);
+    const dayAgo = new Date(Date.now() - 24 * 60 * 60 * 1e3).toISOString();
+    const recentEvolutions = history.filter(
+      (e) => e.event === "procedure_evolved" && e.timestamp > dayAgo
+    );
+    if (recentEvolutions.length >= 3) {
+      throw new Error(`Rate limit: engram ${engramId} has been evolved ${recentEvolutions.length} times in the last 24h (max 3)`);
+    }
+    const episode = this.capture(`Failure report for ${engramId}: ${failureContext}`, {
+      tags: ["failure", "procedure-evolution"]
+    });
+    const failureEventId = generateEventId();
+    appendHistory(this.paths.root, {
+      event: "failure_reported",
+      engram_id: engramId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      data: { failure_context: failureContext, episode_id: episode.id, event_id: failureEventId }
+    });
+    let evolved = false;
+    if (llm) {
+      try {
+        const prompt = `You are improving a procedural memory based on a failure report.
+
+Current procedure: "${engram.statement}"
+Failure report: "${failureContext}"
+${recentEvolutions.length > 0 ? `
+Previous revisions in last 24h: ${recentEvolutions.length}` : ""}
+
+Generate an improved version of the procedure that prevents this failure. Return ONLY the improved procedure statement, nothing else.`;
+        const improved = await llm(prompt);
+        if (improved && improved.trim().length > 0) {
+          const eventId = generateEventId();
+          const now = (/* @__PURE__ */ new Date()).toISOString();
+          return withLock(this.paths.engrams, () => {
+            const engrams = loadEngrams(this.paths.engrams);
+            const idx = engrams.findIndex((e) => e.id === engramId);
+            if (idx === -1) throw new Error(`Engram not found in store: ${engramId}`);
+            const raw = engrams[idx];
+            const oldStatement = raw.statement;
+            const oldVersion = raw.engram_version ?? 1;
+            raw.statement = improved.trim();
+            raw.engram_version = oldVersion + 1;
+            raw.previous_version_ref = { event_id: eventId, changed_at: now };
+            if (!raw.episode_ids) raw.episode_ids = [];
+            raw.episode_ids.push(episode.id);
+            saveEngrams(this.paths.engrams, engrams);
+            this._syncIndex();
+            appendHistory(this.paths.root, {
+              event: "procedure_evolved",
+              engram_id: engramId,
+              timestamp: now,
+              data: {
+                event_id: eventId,
+                old_statement: oldStatement,
+                new_statement: improved.trim(),
+                old_version: oldVersion,
+                new_version: oldVersion + 1,
+                failure_context: failureContext,
+                failure_episode_id: episode.id
+              }
+            });
+            evolved = true;
+            return { engram: engrams[idx], episode, evolved };
+          });
+        }
+      } catch {
+      }
+    }
+    withLock(this.paths.engrams, () => {
+      const engrams = loadEngrams(this.paths.engrams);
+      const idx = engrams.findIndex((e) => e.id === engramId);
+      if (idx !== -1) {
+        const raw = engrams[idx];
+        if (!raw.episode_ids) raw.episode_ids = [];
+        raw.episode_ids.push(episode.id);
+        saveEngrams(this.paths.engrams, engrams);
+        this._syncIndex();
+      }
+    });
+    const updated = this.getById(engramId);
+    return { engram: updated ?? engram, episode, evolved };
+  }
   /** Return system health info. */
   status() {
     const engrams = this._loadAllEngrams();
     const episodes = queryTimeline(this.paths.episodes);
     const packs = listPacks(this.paths.packs);
+    const active = engrams.filter((e) => e.status !== "retired");
+    const lockedCount = active.filter((e) => e.commitment === "locked").length;
+    const tensionPairs = /* @__PURE__ */ new Set();
+    for (const e of active) {
+      if (!e.relations?.conflicts?.length) continue;
+      for (const cid of e.relations.conflicts) {
+        tensionPairs.add([e.id, cid].sort().join(":"));
+      }
+    }
+    const versionedCount = engrams.filter((e) => {
+      const raw = e;
+      return (raw.engram_version ?? 1) > 1;
+    }).length;
     return {
-      engram_count: engrams.filter((e) => e.status !== "retired").length,
+      engram_count: active.length,
       episode_count: episodes.length,
       pack_count: packs.length,
       storage_root: this.paths.root,
-      config: this.config
+      config: this.config,
+      locked_count: lockedCount,
+      tension_count: tensionPairs.size,
+      versioned_engram_count: versionedCount
     };
   }
   /** Register an additional engram store. */
@@ -2893,12 +3751,12 @@ var Plur = class {
     }];
     let configData = {};
     try {
-      const raw = fs3.readFileSync(this.paths.config, "utf8");
-      if (raw) configData = yaml5.load(raw) ?? {};
+      const raw = fs4.readFileSync(this.paths.config, "utf8");
+      if (raw) configData = yaml6.load(raw) ?? {};
     } catch {
     }
     configData.stores = stores;
-    fs3.writeFileSync(this.paths.config, yaml5.dump(configData, { lineWidth: 120, noRefs: true }));
+    fs4.writeFileSync(this.paths.config, yaml6.dump(configData, { lineWidth: 120, noRefs: true }));
     this.config = loadConfig(this.paths.config);
   }
   /** List all configured stores. */
@@ -2923,6 +3781,9 @@ var Plur = class {
   }
 };
 export {
+  ALL_MIGRATIONS,
+  COMMITMENT_MULTIPLIER,
+  CURRENT_SCHEMA_VERSION,
   DomainCoverageSchema,
   EvidenceEntrySchema,
   FalsificationSchema,
@@ -2933,25 +3794,64 @@ export {
   PLATITUDE_PATTERNS,
   Plur,
   SessionBreadcrumbs,
+  SqliteStore,
   StructuralTemplateSchema,
+  YamlStore,
   alignCluster,
   analyzeStructure,
+  appendHistory,
+  assignLayer,
+  asyncAtomicWrite,
+  autoSummary,
+  buildBatchDedupPrompt,
+  buildDedupPrompt,
   checkForUpdate,
   classifyPolarity,
   clearVersionCache,
   clusterByStructure,
   computeConfidence,
+  computeContentHash,
   computeMetaConfidence,
   confidenceBand,
+  createStore,
   detectPlurStorage,
   detectSecrets,
   engramSearchText,
   extractMetaEngrams,
+  formatLayer1,
+  formatLayer2,
+  formatLayer3,
+  formatWithLayer,
   formulateMetaEngram,
+  freshTailBoost,
+  generateEventId,
   generateGuardrails,
+  generateProfile,
+  generateSummary,
   getCachedUpdateCheck,
+  getProfileForInjection,
+  getSchemaVersion,
   isPlatitude,
+  listHistoryMonths,
+  loadProfileCache,
+  markProfileDirty,
+  migrateStore,
+  needsSummary,
+  normalizeStatement,
   organizeHierarchy,
+  parseDedupResponse,
+  profileNeedsRegeneration,
+  readHistory,
+  readHistoryForEngram,
+  recallAuto,
+  resolveOperationTier,
+  rollbackMigrations,
+  runMigrations,
+  saveProfileCache,
+  selectModel,
+  selectModelForOperation,
+  setSchemaVersion,
   tokenSimilarity,
-  validateMetaEngram
+  validateMetaEngram,
+  withAsyncLock
 };