@openclawcity/become 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2760 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AnthropicAdapter: () => AnthropicAdapter,
+  AwarenessIndex: () => AwarenessIndex,
+  BLOOMS_ORDER: () => BLOOMS_ORDER,
+  BLOOMS_SCORE: () => BLOOMS_SCORE,
+  Become: () => Become,
+  ConversationLearner: () => ConversationLearner,
+  DREYFUS_THRESHOLDS: () => DREYFUS_THRESHOLDS,
+  GrowthTracker: () => GrowthTracker,
+  LearningGraph: () => LearningGraph,
+  MemoryStore: () => MemoryStore,
+  MilestoneDetector: () => MilestoneDetector,
+  NormDetector: () => NormDetector,
+  OllamaAdapter: () => OllamaAdapter,
+  OpenAIAdapter: () => OpenAIAdapter,
+  PeerReviewProtocol: () => PeerReviewProtocol,
+  Reflector: () => Reflector,
+  SQLiteStore: () => SQLiteStore,
+  SkillEvolver: () => SkillEvolver,
+  SkillPruner: () => SkillPruner,
+  SkillStore: () => SkillStore,
+  TeachingProtocol: () => TeachingProtocol,
+  TrainScheduler: () => TrainScheduler,
+  TrendTracker: () => TrendTracker,
+  WEIGHTS: () => WEIGHTS,
+  checkGate: () => checkGate,
+  computeFullScore: () => computeFullScore,
+  computeScore: () => computeScore,
+  datasetStats: () => datasetStats,
+  detectBloomsLevel: () => detectBloomsLevel,
+  detectCollaborationGap: () => detectCollaborationGap,
+  detectCollectiveMemory: () => detectCollectiveMemory,
+  detectCreativeMismatch: () => detectCreativeMismatch,
+  detectCulturalOutlier: () => detectCulturalOutlier,
+  detectIdleCreative: () => detectIdleCreative,
+  detectProlificCollaborator: () => detectProlificCollaborator,
+  detectQuestStreak: () => detectQuestStreak,
+  detectReactionDisparity: () => detectReactionDisparity,
+  detectSoloCreator: () => detectSoloCreator,
+  detectSymbolicVocabulary: () => detectSymbolicVocabulary,
+  dreyfusStage: () => dreyfusStage,
+  filterHighQuality: () => filterHighQuality,
+  getReputationLevel: () => getReputationLevel,
+  importSkillDirectory: () => importSkillDirectory,
+  nextMilestone: () => nextMilestone,
+  normalizeCategory: () => normalizeCategory,
+  parseSkillFile: () => parseSkillFile,
+  scoreTrend: () => scoreTrend,
+  toTrainingDataset: () => toTrainingDataset,
+  trainLoRA: () => trainLoRA,
+  validateAgentId: () => validateAgentId
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/core/scorer.ts
+var scorer_exports = {};
+__export(scorer_exports, {
+  BLOOMS_ORDER: () => BLOOMS_ORDER,
+  BLOOMS_SCORE: () => BLOOMS_SCORE,
+  DREYFUS_THRESHOLDS: () => DREYFUS_THRESHOLDS,
+  WEIGHTS: () => WEIGHTS,
+  computeFullScore: () => computeFullScore,
+  computeScore: () => computeScore,
+  detectBloomsLevel: () => detectBloomsLevel,
+  dreyfusStage: () => dreyfusStage,
+  nextMilestone: () => nextMilestone,
+  scoreTrend: () => scoreTrend
+});
+var BLOOMS_ORDER = [
+  "remember",
+  "understand",
+  "apply",
+  "analyze",
+  "evaluate",
+  "create"
+];
+var BLOOMS_SCORE = {
+  remember: 10,
+  understand: 25,
+  apply: 45,
+  analyze: 65,
+  evaluate: 80,
+  create: 100
+};
+var DREYFUS_THRESHOLDS = {
+  novice: { next: "Beginner", score: 16 },
+  beginner: { next: "Competent", score: 36 },
+  competent: { next: "Proficient", score: 56 },
+  proficient: { next: "Expert", score: 76 }
+};
+var WEIGHTS = {
+  artifact: 0.3,
+  feedback: 0.2,
+  improvement: 0.2,
+  depth: 0.15,
+  social: 0.1,
+  teaching: 0.05
+};
+function dreyfusStage(score) {
+  if (score <= 15) return "novice";
+  if (score <= 35) return "beginner";
+  if (score <= 55) return "competent";
+  if (score <= 75) return "proficient";
+  return "expert";
+}
+function detectBloomsLevel(input) {
+  if (input.artifact_count >= 3 && input.total_reactions >= 5 && input.peer_reviews_given > 0) {
+    return "create";
+  }
+  if (input.peer_reviews_given > 0 || input.peer_reviews_received > 0) {
+    return "evaluate";
+  }
+  if (input.unique_types >= 2 || input.collab_count >= 1) {
+    return "analyze";
+  }
+  if (input.artifact_count >= 2) {
+    return "apply";
+  }
+  if (input.artifact_count >= 1 && input.total_reactions > 0) {
+    return "understand";
+  }
+  return "remember";
+}
+function computeScore(input) {
+  const avgReactions = input.artifact_count > 0 ? input.total_reactions / input.artifact_count : 0;
+  const artifactComponent = Math.min(
+    100,
+    input.artifact_count * 5 + avgReactions * 10 + input.unique_types * 8
+  );
+  const feedbackComponent = Math.min(100, input.peer_reviews_received * 15);
+  let improvementComponent = 0;
+  if (input.artifact_count >= 3 && input.older_reaction_avg > 0) {
+    const ratio = input.recent_reaction_avg / Math.max(1, input.older_reaction_avg);
+    improvementComponent = Math.min(100, ratio * 50);
+  } else if (input.artifact_count >= 3) {
+    improvementComponent = Math.min(100, input.recent_reaction_avg * 20);
+  }
+  const depthComponent = BLOOMS_SCORE[detectBloomsLevel(input)];
+  const socialComponent = Math.min(
+    100,
+    input.collab_count * 15 + input.follower_count * 5 + input.total_reactions * 2
+  );
+  const teachingComponent = Math.min(100, input.teaching_events * 20);
+  const raw = artifactComponent * WEIGHTS.artifact + feedbackComponent * WEIGHTS.feedback + improvementComponent * WEIGHTS.improvement + depthComponent * WEIGHTS.depth + socialComponent * WEIGHTS.social + teachingComponent * WEIGHTS.teaching;
+  return Math.min(100, Math.max(0, Math.round(raw)));
+}
+function computeFullScore(skill, input) {
+  const score = computeScore(input);
+  return {
+    skill,
+    score,
+    blooms_level: detectBloomsLevel(input),
+    dreyfus_stage: dreyfusStage(score),
+    evidence: { ...input },
+    computed_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function nextMilestone(stage, score) {
+  const threshold = DREYFUS_THRESHOLDS[stage];
+  if (!threshold) return null;
+  const needed = Math.max(0, threshold.score - score);
+  return `${threshold.next} at score ${threshold.score} (need ${needed} more)`;
+}
+function scoreTrend(current, weekAgo) {
+  if (weekAgo === null) return null;
+  const delta = current - weekAgo;
+  return `${delta >= 0 ? "+" : ""}${delta} this week`;
+}
+
+// src/core/validation.ts
+var MAX_AGENT_ID_LENGTH = 200;
+var AGENT_ID_REGEX = /^[a-zA-Z0-9_.:@/-]+$/;
+function validateAgentId(agentId) {
+  if (!agentId || typeof agentId !== "string") {
+    throw new Error("agentId is required and must be a non-empty string");
+  }
+  if (agentId.length > MAX_AGENT_ID_LENGTH) {
+    throw new Error(`agentId too long (max ${MAX_AGENT_ID_LENGTH} chars)`);
+  }
+  if (!AGENT_ID_REGEX.test(agentId)) {
+    throw new Error("agentId contains invalid characters (allowed: alphanumeric, _ . : @ / -)");
+  }
+}
+
+// src/core/skill-store.ts
+var SKILL_NAME_REGEX = /^[a-z0-9_-]{1,100}$/;
+var AUTO_VERIFY_THRESHOLD = 3;
+var SkillStore = class _SkillStore {
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  async get(agentId, skill) {
+    return this.adapter.getSkill(agentId, skill);
+  }
+  async list(agentId, opts) {
+    return this.adapter.listSkills(agentId, opts);
+  }
+  async upsert(agentId, input) {
+    validateAgentId(agentId);
+    const name = _SkillStore.normalizeName(input.name);
+    if (!_SkillStore.validateName(name)) {
+      throw new Error(`Invalid skill name: "${name}". Must match ${SKILL_NAME_REGEX}`);
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const existing = await this.adapter.getSkill(agentId, name);
+    const skill = existing ? { ...existing, category: input.category ?? existing.category, content: input.content ?? existing.content, updated_at: now } : {
+      agent_id: agentId,
+      name,
+      category: input.category ?? "general",
+      score: 0,
+      blooms_level: "remember",
+      dreyfus_stage: "novice",
+      evidence: {
+        artifact_count: 0,
+        total_reactions: 0,
+        recent_reaction_avg: 0,
+        older_reaction_avg: 0,
+        unique_types: 0,
+        collab_count: 0,
+        peer_reviews_given: 0,
+        peer_reviews_received: 0,
+        follower_count: 0,
+        teaching_events: 0
+      },
+      learned_from: [],
+      content: input.content,
+      created_at: now,
+      updated_at: now
+    };
+    await this.adapter.upsertSkill(skill);
+    await this.adapter.upsertCatalogEntry({
+      skill: name,
+      category: skill.category ?? "general",
+      description: input.content?.slice(0, 200),
+      status: "community"
+    });
+    const adopters = await this.adapter.getSkillAdopterCount(name);
+    if (adopters >= AUTO_VERIFY_THRESHOLD) {
+      await this.adapter.updateCatalogStatus(name, "verified");
+    }
+    return skill;
+  }
+  async delete(agentId, skill) {
+    return this.adapter.deleteSkill(agentId, skill);
+  }
+  async catalog() {
+    return this.adapter.getCatalog();
+  }
+  async holders(skill) {
+    return this.adapter.getSkillHolders(skill);
+  }
+  async suggest(agentId) {
+    const owned = await this.adapter.listSkills(agentId);
+    const ownedNames = new Set(owned.map((s) => s.name));
+    const catalog = await this.adapter.getCatalog();
+    return catalog.filter((c) => c.status === "verified" && !ownedNames.has(c.skill)).sort((a, b) => b.adopter_count - a.adopter_count).slice(0, 10).map((c) => c.skill);
+  }
+  async history(agentId, skill, days = 30) {
+    return this.adapter.getScoreHistory(agentId, skill, days);
+  }
+  async trending(agentId, topN = 5) {
+    const scores = await this.adapter.getLatestScores(agentId);
+    const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1e3).toISOString();
+    const trends = [];
+    for (const s of scores) {
+      const history = await this.adapter.getScoreHistory(agentId, s.skill, 7);
+      const oldScore = history.length > 0 ? history[0].score : null;
+      trends.push({
+        skill: s.skill,
+        score: s.score,
+        stage: s.dreyfus_stage,
+        trend: scoreTrend(s.score, oldScore),
+        next_milestone: nextMilestone(s.dreyfus_stage, s.score)
+      });
+    }
+    trends.sort((a, b) => {
+      const deltaA = a.trend ? Math.abs(parseInt(a.trend)) : 0;
+      const deltaB = b.trend ? Math.abs(parseInt(b.trend)) : 0;
+      return deltaB - deltaA;
+    });
+    return trends.slice(0, topN);
+  }
+  static normalizeName(raw) {
+    return raw.toLowerCase().replace(/\s+/g, "_").replace(/[^a-z0-9_-]/g, "");
+  }
+  static validateName(name) {
+    return SKILL_NAME_REGEX.test(name);
+  }
+};
+
+// src/core/reflector.ts
+var SKILL_REGEX = /^[a-zA-Z0-9_-]{1,100}$/;
+var MIN_REFLECTION_LENGTH = 20;
+var MAX_REFLECTION_LENGTH = 2e3;
+var MAX_REFLECTIONS_PER_SKILL_PER_DAY = 5;
+var MAX_OBSERVATIONS = 5;
+var Reflector = class {
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  async reflect(agentId, input) {
+    validateAgentId(agentId);
+    if (!SKILL_REGEX.test(input.skill)) {
+      throw new Error(`Invalid skill name: "${input.skill}"`);
+    }
+    const text = stripHtml(input.reflection.trim());
+    if (text.length < MIN_REFLECTION_LENGTH) {
+      throw new Error(`Reflection too short (min ${MIN_REFLECTION_LENGTH} chars)`);
+    }
+    if (text.length > MAX_REFLECTION_LENGTH) {
+      throw new Error(`Reflection too long (max ${MAX_REFLECTION_LENGTH} chars)`);
+    }
+    const todayCount = await this.adapter.countReflectionsToday(agentId, input.skill);
+    if (todayCount >= MAX_REFLECTIONS_PER_SKILL_PER_DAY) {
+      throw new Error(`Rate limit: max ${MAX_REFLECTIONS_PER_SKILL_PER_DAY} reflections per skill per day`);
+    }
+    const reflection = {
+      agent_id: agentId,
+      skill: input.skill,
+      artifact_id: input.artifact_id,
+      reflection: text,
+      created_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    return this.adapter.saveReflection(reflection);
+  }
+  async list(agentId, opts) {
+    return this.adapter.getReflections(agentId, opts);
+  }
+  observe(context) {
+    const observations = [];
+    const rules = [
+      detectCreativeMismatch,
+      detectCollaborationGap,
+      detectReactionDisparity,
+      detectIdleCreative,
+      detectQuestStreak,
+      detectSoloCreator,
+      detectProlificCollaborator,
+      detectSymbolicVocabulary,
+      detectCollectiveMemory,
+      detectCulturalOutlier
+    ];
+    for (const rule of rules) {
+      if (observations.length >= MAX_OBSERVATIONS) break;
+      const obs = rule(context);
+      if (obs) observations.push(obs);
+    }
+    return observations;
+  }
+};
+function detectCreativeMismatch(ctx) {
+  if (!ctx.declared_role || ctx.artifacts.length < 3) return null;
+  const typeCounts = countBy(ctx.artifacts, (a) => a.type);
+  const topType = maxEntry(typeCounts);
+  if (!topType) return null;
+  const role = ctx.declared_role.replace("agent-", "");
+  if (topType[0] === role) return null;
+  return {
+    type: "creative_mismatch",
+    text: `Your most-created work is ${topType[0]} (${topType[1]} pieces), but you arrived as a ${role}.`
+  };
+}
+function detectCollaborationGap(ctx) {
+  if (ctx.collabs_started < 3) return null;
+  if (ctx.collabs_completed > Math.floor(ctx.collabs_started / 3)) return null;
+  return {
+    type: "collaboration_gap",
+    text: `You have accepted ${ctx.collabs_started} collaborations but completed ${ctx.collabs_completed}.`
+  };
+}
+function detectReactionDisparity(ctx) {
+  const typeCounts = countBy(ctx.artifacts, (a) => a.type);
+  const entries = Object.entries(typeCounts).sort((a, b) => b[1] - a[1]);
+  if (entries.length < 2) return null;
+  const [topType, topCount] = entries[0];
+  const [bottomType, bottomCount] = entries[entries.length - 1];
+  if (topCount < 3 || topCount < 3 * bottomCount) return null;
+  return {
+    type: "reaction_disparity",
+    text: `You've created ${topCount} ${topType} works vs ${bottomCount} ${bottomType} works.`
+  };
+}
+function detectIdleCreative(ctx) {
+  if (ctx.skills.length === 0 || ctx.artifacts.length > 0) return null;
+  return {
+    type: "idle_creative",
+    text: `You have skills registered but haven't created any artifacts yet.`
+  };
+}
+function detectQuestStreak(ctx) {
+  if (ctx.quest_completions < 3) return null;
+  return {
+    type: "quest_streak",
+    text: `You've completed ${ctx.quest_completions} quest(s). Persistence is noticed.`
+  };
+}
+function detectSoloCreator(ctx) {
+  if (ctx.artifacts.length < 5 || ctx.collabs_completed > 0) return null;
+  return {
+    type: "solo_creator",
+    text: `${ctx.artifacts.length} artifacts created, all solo. No collaborations completed.`
+  };
+}
+function detectProlificCollaborator(ctx) {
+  if (ctx.collabs_completed < 3 || ctx.follower_count < 3) return null;
+  return {
+    type: "prolific_collaborator",
+    text: `${ctx.collabs_completed} collaborations completed and ${ctx.follower_count} followers.`
+  };
+}
+function detectSymbolicVocabulary(ctx) {
+  const artifactsWithTags = ctx.artifacts.filter((a) => a.tags && a.tags.length > 0);
+  if (artifactsWithTags.length < 5 || !ctx.peer_agents_tags) return null;
+  const myTags = new Set(artifactsWithTags.flatMap((a) => a.tags ?? []));
+  if (myTags.size === 0) return null;
+  let overlapCount = 0;
+  for (const [, peerTags] of ctx.peer_agents_tags) {
+    const hasOverlap = peerTags.some((t) => myTags.has(t));
+    if (hasOverlap) overlapCount++;
+  }
+  if (overlapCount < 3) return null;
+  const tagList = [...myTags].slice(0, 5).join(", ");
+  return {
+    type: "symbolic_vocabulary",
+    text: `Your symbolic vocabulary (${tagList}) resonates with other creators.`
+  };
+}
+function detectCollectiveMemory(ctx) {
+  if (ctx.artifacts.length === 0 || !ctx.population_milestones?.length) return null;
+  const artifactMilestone = ctx.population_milestones.find((m) => m.type === "total_artifacts");
+  if (!artifactMilestone) return null;
+  return {
+    type: "collective_memory",
+    text: `You were part of a collective milestone: ${artifactMilestone.title}.`
+  };
+}
+function detectCulturalOutlier(ctx) {
+  if (ctx.uniqueness_score === void 0 || ctx.uniqueness_score >= 0.2 || ctx.artifacts.length < 5 || ctx.collabs_completed < 1) return null;
+  return {
+    type: "cultural_outlier",
+    text: `Your perspective is genuinely unique among the group.`
+  };
+}
+function stripHtml(text) {
+  let result = text.replace(/<[^>]*>/g, "");
+  result = result.replace(/<[^>]*$/g, "");
+  result = result.replace(/^[^<]*>/g, (match) => {
+    return match.includes(">") ? match.replace(/^[^>]*>/, "") : match;
+  });
+  result = result.replace(/</g, "").replace(/>/g, "");
+  return result;
+}
+function countBy(items, key) {
+  const counts = {};
+  for (const item of items) {
+    const k = key(item);
+    counts[k] = (counts[k] ?? 0) + 1;
+  }
+  return counts;
+}
+function maxEntry(counts) {
+  let max = null;
+  for (const [k, v] of Object.entries(counts)) {
+    if (!max || v > max[1]) max = [k, v];
+  }
+  return max;
+}
+
+// src/core/milestones.ts
+var BUILT_IN = {
+  skill_discovered: { threshold: 1, description: "First score for a skill" },
+  skill_competent: { threshold: 36, description: "Reached competent stage" },
+  skill_proficient: { threshold: 56, description: "Reached proficient stage" },
+  skill_expert: { threshold: 76, description: "Reached expert stage" },
+  first_artifact: { threshold: 1, description: "Created first output" },
+  ten_artifacts: { threshold: 10, description: "Created 10 outputs" },
+  first_collab: { threshold: 1, description: "Completed first collaboration" },
+  first_teaching: { threshold: 1, description: "Taught another agent for the first time" },
+  first_peer_review: { threshold: 1, description: "Gave first peer review" },
+  identity_shift: { threshold: 1, description: "Agent evolved its identity" },
+  norm_setter: { threshold: 1, description: "Started a cultural norm adopted by 3+ agents" }
+};
+var MilestoneDetector = class {
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  custom = {};
+  register(type, config) {
+    this.custom[type] = config;
+  }
+  async check(agentId, scores) {
+    validateAgentId(agentId);
+    const awarded = [];
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const globalChecked = /* @__PURE__ */ new Set();
+    for (const score of scores) {
+      if (score.score > 0) {
+        const type = `skill_discovered:${score.skill}`;
+        if (await this.tryAward(agentId, type, 1, score.skill, now)) {
+          awarded.push({ agent_id: agentId, milestone_type: type, threshold: 1, skill: score.skill, achieved_at: now });
+        }
+      }
+      const stageChecks = [
+        ["skill_competent", 36],
+        ["skill_proficient", 56],
+        ["skill_expert", 76]
+      ];
+      for (const [prefix, threshold] of stageChecks) {
+        if (score.score >= threshold) {
+          const type = `${prefix}:${score.skill}`;
+          if (await this.tryAward(agentId, type, threshold, score.skill, now)) {
+            awarded.push({ agent_id: agentId, milestone_type: type, threshold, skill: score.skill, achieved_at: now });
+          }
+        }
+      }
+      const globalMilestones = [
+        ["first_artifact", 1, score.evidence.artifact_count >= 1],
+        ["ten_artifacts", 10, score.evidence.artifact_count >= 10],
+        ["first_collab", 1, score.evidence.collab_count >= 1],
+        ["first_teaching", 1, score.evidence.teaching_events >= 1],
+        ["first_peer_review", 1, score.evidence.peer_reviews_given >= 1]
+      ];
+      for (const [type, threshold, eligible] of globalMilestones) {
+        if (eligible && !globalChecked.has(type)) {
+          globalChecked.add(type);
+          if (await this.tryAward(agentId, type, threshold, void 0, now)) {
+            awarded.push({ agent_id: agentId, milestone_type: type, threshold, achieved_at: now });
+          }
+        }
+      }
+    }
+    return awarded;
+  }
+  async tryAward(agentId, milestoneType, threshold, skill, now) {
+    const exists = await this.adapter.hasMilestone(agentId, milestoneType, skill);
+    if (exists) return false;
+    return this.adapter.saveMilestone({
+      agent_id: agentId,
+      milestone_type: milestoneType,
+      threshold,
+      skill,
+      achieved_at: now
+    });
+  }
+  static celebrationTier(milestoneType, threshold) {
+    if (milestoneType.startsWith("skill_expert")) return "epic";
+    if (milestoneType.startsWith("skill_proficient")) return "large";
+    if (milestoneType.startsWith("skill_competent")) return "medium";
+    if (milestoneType.startsWith("skill_discovered")) return "small";
+    if (threshold !== void 0) {
+      if (threshold >= 50) return "large";
+      if (threshold >= 10) return "medium";
+    }
+    return "small";
+  }
+  static getBuiltInMilestones() {
+    return { ...BUILT_IN };
+  }
+};
+
+// src/adapters/memory.ts
+var MemoryStore = class {
+  skills = [];
+  catalog = /* @__PURE__ */ new Map();
+  scoreHistory = [];
+  reflections = [];
+  milestones = [];
+  peerReviews = [];
+  learningEdges = [];
+  reputationMap = /* @__PURE__ */ new Map();
+  conversationScores = [];
+  norms = [];
+  idCounter = 0;
+  nextId() {
+    return String(++this.idCounter);
+  }
+  /** Reset all data. Useful for test isolation. */
+  clear() {
+    this.skills = [];
+    this.catalog.clear();
+    this.scoreHistory = [];
+    this.reflections = [];
+    this.milestones = [];
+    this.peerReviews = [];
+    this.learningEdges = [];
+    this.reputationMap.clear();
+    this.conversationScores = [];
+    this.norms = [];
+    this.idCounter = 0;
+  }
+  // ── Skills ──────────────────────────────────────────────────────────────
+  async getSkill(agentId, skill) {
+    return this.skills.find((s) => s.agent_id === agentId && s.name === skill) ?? null;
+  }
+  async listSkills(agentId, opts) {
+    let result = this.skills.filter((s) => s.agent_id === agentId);
+    if (opts?.stage) result = result.filter((s) => s.dreyfus_stage === opts.stage);
+    if (opts?.limit) result = result.slice(0, opts.limit);
+    return result;
+  }
+  async upsertSkill(skill) {
+    const idx = this.skills.findIndex((s) => s.agent_id === skill.agent_id && s.name === skill.name);
+    if (idx >= 0) {
+      this.skills[idx] = skill;
+    } else {
+      this.skills.push(skill);
+    }
+    const entry = this.catalog.get(skill.name);
+    if (entry) {
+      entry.adopter_set.add(skill.agent_id);
+      entry.adopter_count = entry.adopter_set.size;
+    }
+  }
+  async deleteSkill(agentId, skill) {
+    this.skills = this.skills.filter((s) => !(s.agent_id === agentId && s.name === skill));
+    const entry = this.catalog.get(skill);
+    if (entry) {
+      entry.adopter_set.delete(agentId);
+      entry.adopter_count = entry.adopter_set.size;
+    }
+  }
+  // ── Catalog ─────────────────────────────────────────────────────────────
+  async getCatalog() {
+    return [...this.catalog.values()].map(({ adopter_set, ...entry }) => entry);
+  }
+  async upsertCatalogEntry(entry) {
+    const existing = this.catalog.get(entry.skill);
+    if (existing) {
+      existing.category = entry.category;
+      if (entry.description) existing.description = entry.description;
+      return;
+    }
+    const adopters = this.skills.filter((s) => s.name === entry.skill).map((s) => s.agent_id);
+    this.catalog.set(entry.skill, {
+      ...entry,
+      adopter_count: adopters.length,
+      adopter_set: new Set(adopters)
+    });
+  }
+  async getSkillHolders(skill) {
+    return this.skills.filter((s) => s.name === skill);
+  }
+  async getSkillAdopterCount(skill) {
+    const entry = this.catalog.get(skill);
+    return entry?.adopter_set.size ?? 0;
+  }
+  async updateCatalogStatus(skill, status) {
+    const entry = this.catalog.get(skill);
+    if (entry) entry.status = status;
+  }
+  // ── Score History ───────────────────────────────────────────────────────
+  async saveScore(agentId, score) {
+    this.scoreHistory.push({ ...score, agent_id: agentId });
+  }
+  async getScoreHistory(agentId, skill, days = 30) {
+    const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1e3).toISOString();
+    return this.scoreHistory.filter((s) => s.agent_id === agentId && s.skill === skill && s.computed_at >= cutoff).sort((a, b) => a.computed_at.localeCompare(b.computed_at));
+  }
+  async getLatestScores(agentId) {
+    const bySkill = /* @__PURE__ */ new Map();
+    for (const s of this.scoreHistory) {
+      if (s.agent_id !== agentId) continue;
+      const existing = bySkill.get(s.skill);
+      if (!existing || s.computed_at > existing.computed_at) {
+        bySkill.set(s.skill, s);
+      }
+    }
+    return [...bySkill.values()];
+  }
+  // ── Reflections ─────────────────────────────────────────────────────────
+  async saveReflection(reflection) {
+    const saved = { ...reflection, id: reflection.id ?? this.nextId() };
+    this.reflections.push(saved);
+    return saved;
+  }
+  async getReflections(agentId, opts) {
+    let result = this.reflections.filter((r) => r.agent_id === agentId);
+    if (opts?.skill) result = result.filter((r) => r.skill === opts.skill);
+    result.sort((a, b) => b.created_at.localeCompare(a.created_at));
+    if (opts?.limit) result = result.slice(0, opts.limit);
+    return result;
+  }
+  async countReflectionsToday(agentId, skill) {
+    const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    return this.reflections.filter(
+      (r) => r.agent_id === agentId && r.skill === skill && r.created_at.startsWith(today)
+    ).length;
+  }
+  // ── Milestones ──────────────────────────────────────────────────────────
+  async saveMilestone(milestone) {
+    const exists = this.milestones.some(
+      (m) => m.agent_id === milestone.agent_id && m.milestone_type === milestone.milestone_type && (m.skill ?? "") === (milestone.skill ?? "")
+    );
+    if (exists) return false;
+    this.milestones.push(milestone);
+    return true;
+  }
+  async getMilestones(agentId) {
+    return this.milestones.filter((m) => m.agent_id === agentId).sort((a, b) => b.achieved_at.localeCompare(a.achieved_at));
+  }
+  async hasMilestone(agentId, milestoneType, skill) {
+    return this.milestones.some(
+      (m) => m.agent_id === agentId && m.milestone_type === milestoneType && (skill === void 0 || m.skill === skill)
+    );
+  }
+  // ── Peer Reviews ────────────────────────────────────────────────────────
+  async savePeerReview(review) {
+    const saved = { ...review, id: review.id ?? this.nextId(), created_at: review.created_at ?? (/* @__PURE__ */ new Date()).toISOString() };
+    this.peerReviews.push(saved);
+    return saved;
+  }
+  async getReviewsFor(agentId, opts) {
+    let result = this.peerReviews.filter((r) => r.submission_agent_id === agentId);
+    if (opts?.skill) result = result.filter((r) => r.skill === opts.skill);
+    return result;
+  }
+  async getReviewsBy(agentId) {
+    return this.peerReviews.filter((r) => r.reviewer_agent_id === agentId);
+  }
+  // ── Learning Edges ──────────────────────────────────────────────────────
+  async saveLearningEdge(edge) {
+    this.learningEdges.push(edge);
+  }
+  async getLearningEdges(agentId, direction) {
+    if (direction === "from") {
+      return this.learningEdges.filter((e) => e.from_agent === agentId);
+    }
+    return this.learningEdges.filter((e) => e.to_agent === agentId);
+  }
+  // ── Reputation ──────────────────────────────────────────────────────────
+  async getReputation(agentId) {
+    return this.reputationMap.get(agentId) ?? 0;
+  }
+  async grantReputation(agentId, amount, _type, _description) {
+    const current = this.reputationMap.get(agentId) ?? 0;
+    this.reputationMap.set(agentId, current + amount);
+  }
+  // ── Conversation Scores ─────────────────────────────────────────────────
+  async saveConversationScore(agentId, score) {
+    this.conversationScores.push({ ...score, agent_id: agentId });
+  }
+  async getConversationScores(agentId, opts) {
+    const result = this.conversationScores.filter((s) => s.agent_id === agentId);
+    result.reverse();
+    if (opts?.limit) return result.slice(0, opts.limit);
+    return result;
+  }
+  // ── Cultural Norms ──────────────────────────────────────────────────────
+  async saveNorm(norm) {
+    const idx = this.norms.findIndex((n) => n.id === norm.id);
+    if (idx >= 0) {
+      this.norms[idx] = norm;
+    } else {
+      this.norms.push(norm);
+    }
+  }
+  async getNorms(opts) {
+    let result = [...this.norms];
+    if (opts?.category) result = result.filter((n) => n.category === opts.category);
+    result.sort((a, b) => b.first_observed_at.localeCompare(a.first_observed_at));
+    if (opts?.limit) result = result.slice(0, opts.limit);
+    return result;
+  }
+};
+
+// src/learn/conversation.ts
+var EVOLVE_THRESHOLD = 0.4;
+var ConversationLearner = class {
+  constructor(adapter, judge) {
+    this.adapter = adapter;
+    this.judge = judge;
+  }
+  /** Score a single conversation turn using feedback signals */
+  scoreResponse(turn) {
+    const feedback = turn.feedback;
+    if (feedback?.explicit === "positive") {
+      return { quality: 1, confidence: 0.9, skill_signals: turn.context.active_skills };
+    }
+    if (feedback?.explicit === "negative") {
+      return { quality: -1, confidence: 0.9, skill_signals: turn.context.active_skills, failure_patterns: ["explicit_negative"] };
+    }
+    if (feedback?.implicit === "accepted") {
+      return { quality: 1, confidence: 0.6, skill_signals: turn.context.active_skills };
+    }
+    if (feedback?.implicit === "retry") {
+      return { quality: -1, confidence: 0.7, skill_signals: turn.context.active_skills, failure_patterns: ["user_retry"] };
+    }
+    if (feedback?.implicit === "modified") {
+      return { quality: 0, confidence: 0.5, skill_signals: turn.context.active_skills };
+    }
+    return { quality: 0, confidence: 0.3, skill_signals: turn.context.active_skills };
+  }
+  /** Score using optional LLM judge for higher-quality automated assessment */
+  async scoreWithJudge(turn) {
+    if (!this.judge) {
+      return this.scoreResponse(turn);
+    }
+    try {
+      const result = await this.judge.score(
+        turn.user_message,
+        turn.agent_response,
+        turn.context.current_task
+      );
+      return {
+        quality: result.quality,
+        confidence: 0.8,
+        skill_signals: turn.context.active_skills,
+        failure_patterns: result.quality === -1 ? [result.reasoning] : void 0
+      };
+    } catch {
+      return this.scoreResponse(turn);
+    }
+  }
+  /** Process a turn: score it and persist */
+  async afterTurn(turn) {
+    validateAgentId(turn.agent_id);
+    const score = this.judge ? await this.scoreWithJudge(turn) : this.scoreResponse(turn);
+    await this.adapter.saveConversationScore(turn.agent_id, {
+      ...score,
+      session_id: turn.session_id
+    });
+    const skillUpdates = score.skill_signals.map((skill) => ({
+      skill,
+      delta: score.quality,
+      reason: score.quality === 1 ? "positive_feedback" : score.quality === -1 ? "negative_feedback" : "neutral"
+    }));
+    return {
+      skill_updates: skillUpdates,
+      observations: score.failure_patterns
+    };
+  }
+  /** Summarize learning across a full session */
+  async afterSession(session) {
+    validateAgentId(session.agent_id);
+    const scores = [];
+    for (const turn of session.turns) {
+      const score = this.judge ? await this.scoreWithJudge(turn) : this.scoreResponse(turn);
+      scores.push(score);
+      await this.adapter.saveConversationScore(session.agent_id, {
+        ...score,
+        session_id: session.session_id
+      });
+    }
+    const positive = scores.filter((s) => s.quality === 1).length;
+    const total = scores.length;
+    const successRate = total > 0 ? positive / total : 0;
+    const skillDelta = /* @__PURE__ */ new Map();
+    for (const score of scores) {
+      for (const skill of score.skill_signals) {
+        skillDelta.set(skill, (skillDelta.get(skill) ?? 0) + score.quality);
+      }
+    }
+    const improved = [];
+    const degraded = [];
+    for (const [skill, delta] of skillDelta) {
+      if (delta > 0) improved.push(skill);
+      else if (delta < 0) degraded.push(skill);
+    }
+    const failurePatterns = scores.flatMap((s) => s.failure_patterns ?? []).filter((p, i, arr) => arr.indexOf(p) === i);
+    return {
+      turns_scored: total,
+      success_rate: successRate,
+      skills_improved: improved,
+      skills_degraded: degraded,
+      failure_patterns: failurePatterns,
+      should_evolve: successRate < EVOLVE_THRESHOLD && total >= 3
+    };
+  }
+  /** Batch score multiple turns */
+  batchScore(turns) {
+    return turns.map((turn) => this.scoreResponse(turn));
+  }
+};
+
+// src/learn/skill-evolver.ts
+var EVOLVE_THRESHOLD2 = 0.4;
+var MAX_FAILURES = 6;
+var MAX_SKILLS_PER_EVOLUTION = 3;
+var SkillEvolver = class {
+  constructor(llm) {
+    this.llm = llm;
+  }
+  /** Check if evolution should trigger based on recent scores */
+  shouldEvolve(recentScores) {
+    if (recentScores.length < 3) return false;
+    const positive = recentScores.filter((s) => s.quality === 1).length;
+    return positive / recentScores.length < EVOLVE_THRESHOLD2;
+  }
+  /** Generate corrective skills from failure patterns */
+  async evolve(failures, existingSkills) {
+    const limited = failures.slice(0, MAX_FAILURES);
+    const existingNames = new Set(existingSkills.map((s) => s.name));
+    const failureDescriptions = limited.map((f, i) => {
+      const patterns = f.score.failure_patterns?.join(", ") ?? "unknown";
+      return `Failure ${i + 1}:
+  User: ${sanitize(truncate(f.turn.user_message, 200))}
+  Agent: ${sanitize(truncate(f.turn.agent_response, 200))}
+  Patterns: ${patterns}`;
+    }).join("\n\n");
+    const existingList = existingSkills.slice(0, 20).map((s) => `- ${s.name} (${s.dreyfus_stage})`).join("\n");
+    const prompt = `Analyze these failed agent responses and generate 1-${MAX_SKILLS_PER_EVOLUTION} corrective skills.
+
+FAILURES:
+${failureDescriptions}
+
+EXISTING SKILLS (do not duplicate):
+${existingList || "(none)"}
+
+For each skill, output valid JSON array:
+[{"name": "snake_case_name", "category": "category", "content": "Markdown instruction"}]
+
+Rules:
+- name must be snake_case, 1-100 chars
+- content is a concise instruction (2-5 sentences) the agent should follow
+- Do not create skills that already exist
+- Max ${MAX_SKILLS_PER_EVOLUTION} skills`;
+    try {
+      const response = await this.llm.generate(prompt);
+      const skills = this.parseResponse(response, existingNames);
+      return skills;
+    } catch {
+      return [];
+    }
+  }
+  parseResponse(response, existingNames) {
+    const jsonMatch = response.match(/\[[\s\S]*\]/);
+    if (!jsonMatch) return [];
+    try {
+      const parsed = JSON.parse(jsonMatch[0]);
+      if (!Array.isArray(parsed)) return [];
+      return parsed.filter((s) => {
+        if (typeof s.name !== "string" || typeof s.content !== "string") return false;
+        if (s.name.length === 0 || s.name.length > 100) return false;
+        const normalized = s.name.toLowerCase().replace(/\s+/g, "_").replace(/[^a-z0-9_-]/g, "");
+        return normalized.length > 0 && !existingNames.has(normalized);
+      }).slice(0, MAX_SKILLS_PER_EVOLUTION).map((s) => ({
+        name: s.name.toLowerCase().replace(/\s+/g, "_").replace(/[^a-z0-9_-]/g, ""),
+        category: typeof s.category === "string" ? s.category.slice(0, 100) : "general",
+        content: String(s.content).slice(0, 2e3),
+        source: "evolved",
+        evolved_from: Array.isArray(s.failure_patterns) ? s.failure_patterns.slice(0, 10) : []
+      }));
+    } catch {
+      return [];
+    }
+  }
+};
+function truncate(text, max) {
+  if (text.length <= max) return text;
+  return text.slice(0, max - 3) + "...";
+}
+function sanitize(text) {
+  return text.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "").replace(/```/g, "'''");
+}
+
+// src/learn/skill-pruner.ts
+var DEFAULT_MIN_AGE_DAYS = 14;
+var PROTECTED_STAGES = /* @__PURE__ */ new Set(["competent", "proficient", "expert"]);
+var SkillPruner = class {
+  /**
+   * Identify skills that don't correlate with improved scores.
+   *
+   * Rules:
+   * - Skill must be at least minAge days old
+   * - Score has not improved (delta <= 0) over skill's lifetime → candidate
+   * - Never prune skills at competent stage or above (proven useful)
+   * - Requires at least 2 score history points to judge trajectory
+   */
+  findIneffective(skills, scoreHistory, minAge = DEFAULT_MIN_AGE_DAYS) {
+    const now = Date.now();
+    const minAgeMs = minAge * 24 * 60 * 60 * 1e3;
+    const candidates = [];
+    for (const skill of skills) {
+      if (PROTECTED_STAGES.has(skill.dreyfus_stage)) continue;
+      const age = now - new Date(skill.created_at).getTime();
+      if (age < minAgeMs) continue;
+      const history = scoreHistory.get(skill.name) ?? [];
+      if (history.length < 2) continue;
+      const oldest = history[0].score;
+      const newest = history[history.length - 1].score;
+      const delta = newest - oldest;
+      if (delta > 0) continue;
+      candidates.push(skill.name);
+    }
+    return candidates;
+  }
+  /** Remove identified skills */
+  async prune(adapter, agentId, skillNames) {
+    validateAgentId(agentId);
+    let removed = 0;
+    for (const name of skillNames) {
+      await adapter.deleteSkill(agentId, name);
+      removed++;
+    }
+    return removed;
+  }
+};
+
+// src/learn/import.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+function parseSkillFile(content) {
+  const frontmatterMatch = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/);
+  if (!frontmatterMatch) {
+    const trimmed = content.trim();
+    if (trimmed.length < 5) return null;
+    return { name: "unnamed", content: trimmed };
+  }
+  const [, frontmatter, body] = frontmatterMatch;
+  const meta = {};
+  for (const line of frontmatter.split("\n")) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = line.slice(0, colonIdx).trim();
+    const value = line.slice(colonIdx + 1).trim();
+    if (key && value) meta[key] = value;
+  }
+  const name = meta.name ?? meta.title ?? "unnamed";
+  return {
+    name: name.toLowerCase().replace(/\s+/g, "_").replace(/[^a-z0-9_-]/g, ""),
+    category: meta.category ?? meta.type ?? "general",
+    content: body.trim() || void 0
+  };
+}
+var MAX_RECURSION_DEPTH = 10;
+function importSkillDirectory(dir, _depth = 0) {
+  if (_depth > MAX_RECURSION_DEPTH) return [];
+  const skills = [];
+  let entries;
+  try {
+    entries = (0, import_node_fs.readdirSync)(dir);
+  } catch {
+    throw new Error(`Cannot read directory: ${dir}`);
+  }
+  for (const entry of entries) {
+    const fullPath = (0, import_node_path.join)(dir, entry);
+    let stat;
+    try {
+      stat = (0, import_node_fs.statSync)(fullPath);
+    } catch {
+      continue;
+    }
+    if (stat.isDirectory()) {
+      skills.push(...importSkillDirectory(fullPath, _depth + 1));
+    } else if ((0, import_node_path.extname)(entry) === ".md") {
+      try {
+        const content = (0, import_node_fs.readFileSync)(fullPath, "utf-8");
+        const skill = parseSkillFile(content);
+        if (skill && skill.name !== "unnamed") {
+          skills.push(skill);
+        }
+      } catch {
+      }
+    }
+  }
+  return skills;
+}
+
+// src/social/peer-review.ts
+var MIN_ASSESSMENT_LENGTH = 100;
+var MAX_ASSESSMENT_LENGTH = 1e4;
+var MAX_LIST_ITEMS = 20;
+var MAX_LIST_ITEM_LENGTH = 500;
+var PeerReviewProtocol = class {
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  /**
+   * Round-robin reviewer assignment. Each submission gets 2 reviewers.
+   * No self-review. Wraps around for small groups.
+   */
+  assignReviewers(submissionAgentIds) {
+    if (submissionAgentIds.length < 2) {
+      throw new Error("Need at least 2 agents for peer review");
+    }
+    return submissionAgentIds.map((agentId, i) => {
+      const reviewers = [];
+      let offset = 1;
+      while (reviewers.length < 2 && offset < submissionAgentIds.length) {
+        const reviewerIdx = (i + offset) % submissionAgentIds.length;
+        const reviewer = submissionAgentIds[reviewerIdx];
+        if (reviewer !== agentId) {
+          reviewers.push(reviewer);
+        }
+        offset++;
+      }
+      return {
+        submission_agent_id: agentId,
+        reviewer_agent_ids: reviewers
+      };
+    });
+  }
+  async submitReview(review) {
+    validateAgentId(review.reviewer_agent_id);
+    validateAgentId(review.submission_agent_id);
+    if (review.reviewer_agent_id === review.submission_agent_id) {
+      throw new Error("Cannot review your own submission");
+    }
+    if (this.isSuperficial(review)) {
+      throw new Error("Review is too superficial: assessment must be at least 100 chars and include weaknesses");
+    }
+    if (review.overall_assessment.length > MAX_ASSESSMENT_LENGTH) {
+      throw new Error(`Assessment too long (max ${MAX_ASSESSMENT_LENGTH} chars)`);
+    }
+    const sanitized = {
+      ...review,
+      overall_assessment: review.overall_assessment.slice(0, MAX_ASSESSMENT_LENGTH),
+      strengths: review.strengths.slice(0, MAX_LIST_ITEMS).map((s) => s.slice(0, MAX_LIST_ITEM_LENGTH)),
+      weaknesses: review.weaknesses.slice(0, MAX_LIST_ITEMS).map((s) => s.slice(0, MAX_LIST_ITEM_LENGTH)),
+      suggestions: review.suggestions.slice(0, MAX_LIST_ITEMS).map((s) => s.slice(0, MAX_LIST_ITEM_LENGTH))
+    };
+    const saved = await this.adapter.savePeerReview(sanitized);
+    await this.recordLearning(saved);
+    return saved;
+  }
+  /**
+   * Tally verdicts across reviewers.
+   * All reject → rejected. Any major_revision → revision_requested. Otherwise → accepted.
+   */
+  tallyVerdicts(verdicts) {
+    if (verdicts.length === 0) return "accepted";
+    if (verdicts.every((v) => v === "reject")) return "rejected";
+    if (verdicts.some((v) => v === "major_revision")) return "revision_requested";
+    return "accepted";
+  }
+  /**
+   * Detect low-quality reviews: < 100 chars overall assessment OR no weaknesses listed.
+   */
+  isSuperficial(review) {
+    if (review.overall_assessment.length < MIN_ASSESSMENT_LENGTH) return true;
+    if (!review.weaknesses || review.weaknesses.length === 0) return true;
+    return false;
+  }
+  /**
+   * Create learning edges for both reviewer and reviewee.
+   * Reviewer learns by evaluating. Reviewee learns from feedback.
+   */
+  async recordLearning(review) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const skill = review.skill ?? "general";
+    await this.adapter.saveLearningEdge({
+      from_agent: review.submission_agent_id,
+      to_agent: review.reviewer_agent_id,
+      skill,
+      event_type: "peer_review",
+      score_delta: 0,
+      // Delta computed later when scores are recalculated
+      metadata: { role: "reviewer", verdict: review.verdict },
+      created_at: now
+    });
+    await this.adapter.saveLearningEdge({
+      from_agent: review.reviewer_agent_id,
+      to_agent: review.submission_agent_id,
+      skill,
+      event_type: "peer_review",
+      score_delta: 0,
+      metadata: { role: "reviewee", verdict: review.verdict, suggestions_count: review.suggestions.length },
+      created_at: now
+    });
+  }
+};
+
+// src/social/teaching.ts
+var STAGE_ORDER = ["novice", "beginner", "competent", "proficient", "expert"];
+var TeachingProtocol = class {
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  async teach(teacher, student, skill, context) {
+    validateAgentId(teacher);
+    validateAgentId(student);
+    if (teacher === student) {
+      throw new Error("Cannot teach yourself");
+    }
+    if (!skill || skill.length > 100) {
+      throw new Error("Skill name is required and must be 100 chars or fewer");
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const edge = {
+      from_agent: teacher,
+      to_agent: student,
+      skill,
+      event_type: "teaching",
+      score_delta: 0,
+      metadata: context ? { ...context } : {},
+      created_at: now
+    };
+    await this.adapter.saveLearningEdge(edge);
+    return edge;
+  }
+  async findTeachers(skill, opts) {
+    const holders = await this.adapter.getSkillHolders(skill);
+    const minIdx = opts?.minStage ? STAGE_ORDER.indexOf(opts.minStage) : 0;
+    return holders.filter((s) => STAGE_ORDER.indexOf(s.dreyfus_stage) >= minIdx).sort((a, b) => b.score - a.score).map((s) => ({
+      agent_id: s.agent_id,
+      skill: s.name,
+      score: s.score,
+      stage: s.dreyfus_stage
+    }));
+  }
+  async findStudents(skill, teacherAgentId) {
+    validateAgentId(teacherAgentId);
+    const holders = await this.adapter.getSkillHolders(skill);
+    const teacher = holders.find((s) => s.agent_id === teacherAgentId);
+    const teacherStageIdx = teacher ? STAGE_ORDER.indexOf(teacher.dreyfus_stage) : STAGE_ORDER.length;
+    return holders.filter((s) => s.agent_id !== teacherAgentId && STAGE_ORDER.indexOf(s.dreyfus_stage) < teacherStageIdx).sort((a, b) => a.score - b.score).map((s) => ({
+      agent_id: s.agent_id,
+      skill: s.name,
+      score: s.score,
+      stage: s.dreyfus_stage
+    }));
+  }
+  async teachingHistory(agentId) {
+    validateAgentId(agentId);
+    const fromEdges = await this.adapter.getLearningEdges(agentId, "from");
+    return fromEdges.filter((e) => e.event_type === "teaching");
+  }
+};
+
+// src/social/learning-graph.ts
+var LearningGraph = class {
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  async edges(agentId, direction) {
+    validateAgentId(agentId);
+    if (direction === "both") {
+      const [from, to] = await Promise.all([
+        this.adapter.getLearningEdges(agentId, "from"),
+        this.adapter.getLearningEdges(agentId, "to")
+      ]);
+      return [...from, ...to].sort((a, b) => b.created_at.localeCompare(a.created_at));
+    }
+    return this.adapter.getLearningEdges(agentId, direction);
+  }
+  /** Who taught me the most? (aggregated by from_agent on incoming edges) */
+  async topMentors(agentId, limit = 5) {
+    validateAgentId(agentId);
+    const incoming = await this.adapter.getLearningEdges(agentId, "to");
+    return this.aggregate(incoming, "from_agent", limit);
+  }
+  /** Who have I helped the most? (aggregated by to_agent on outgoing edges) */
+  async topStudents(agentId, limit = 5) {
+    validateAgentId(agentId);
+    const outgoing = await this.adapter.getLearningEdges(agentId, "from");
+    return this.aggregate(outgoing, "to_agent", limit);
+  }
+  /** How did this skill spread through the population? */
+  async transferPath(skill) {
+    const holders = await this.adapter.getSkillHolders(skill);
+    const edges = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const holder of holders) {
+      const incoming = await this.adapter.getLearningEdges(holder.agent_id, "to");
+      for (const edge of incoming) {
+        if (edge.skill === skill) {
+          const key = `${edge.from_agent}->${edge.to_agent}:${edge.created_at}`;
+          if (!seen.has(key)) {
+            seen.add(key);
+            edges.push(edge);
+          }
+        }
+      }
+    }
+    return edges.sort((a, b) => a.created_at.localeCompare(b.created_at));
+  }
+  aggregate(edges, groupByField, limit) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const edge of edges) {
+      const key = edge[groupByField];
+      const existing = groups.get(key);
+      if (existing) {
+        existing.skills.add(edge.skill);
+        existing.total_delta += edge.score_delta;
+        existing.count++;
+      } else {
+        groups.set(key, {
+          skills: /* @__PURE__ */ new Set([edge.skill]),
+          total_delta: edge.score_delta,
+          count: 1
+        });
+      }
+    }
+    return [...groups.entries()].map(([agent, data]) => ({
+      agent,
+      skills: [...data.skills],
+      total_delta: data.total_delta,
+      event_count: data.count
+    })).sort((a, b) => b.event_count - a.event_count || b.total_delta - a.total_delta).slice(0, limit);
+  }
+};
+
+// src/social/reputation.ts
+var TIERS = [
+  { tier: "elder", min: 300 },
+  { tier: "veteran", min: 100, next_tier: "elder", next_threshold: 300, next_unlock: "Elder \u2014 mentor role, chain quests, featured" },
+  { tier: "established", min: 25, next_tier: "veteran", next_threshold: 100, next_unlock: "Veteran \u2014 event access, premium actions" },
+  { tier: "newcomer", min: 0, next_tier: "established", next_threshold: 25, next_unlock: "Established \u2014 create quests, marketplace" }
+];
+function getReputationLevel(score) {
+  for (const tier of TIERS) {
+    if (score >= tier.min) {
+      return {
+        tier: tier.tier,
+        score,
+        next_tier: tier.next_tier,
+        next_threshold: tier.next_threshold,
+        next_unlock: tier.next_unlock
+      };
+    }
+  }
+  return { tier: "newcomer", score, next_tier: "established", next_threshold: 25 };
+}
+function checkGate(score, required) {
+  return score >= required;
+}
+
+// src/social/norms.ts
+var CATEGORY_MAP = {
+  // Language Evolution
+  "lexicon crystallization": "language_evolution",
+  "jargon crystallization": "language_evolution",
+  "vocabulary drift": "language_evolution",
+  "naming convention": "language_evolution",
+  "linguistic pattern": "language_evolution",
+  "shared terminology": "language_evolution",
+  "language pattern": "language_evolution",
+  "communication style": "language_evolution",
+  "slang emergence": "language_evolution",
+  "phrase adoption": "language_evolution",
+  "greeting protocol": "language_evolution",
+  "farewell ritual": "language_evolution",
+  // Culture Formation
+  "role crystallization": "culture_formation",
+  "motif convergence": "culture_formation",
+  "ritual emergence": "culture_formation",
+  "tradition formation": "culture_formation",
+  "cultural ritual": "culture_formation",
+  "shared value": "culture_formation",
+  "identity formation": "culture_formation",
+  "group identity": "culture_formation",
+  "cultural norm": "culture_formation",
+  "aesthetic convergence": "culture_formation",
+  "style convergence": "culture_formation",
+  "taste formation": "culture_formation",
+  "cultural artifact": "culture_formation",
+  // Social Structure
+  "hub magnetization": "social_structure",
+  "heartbeat beaconing": "social_structure",
+  "hierarchy emergence": "social_structure",
+  "clique formation": "social_structure",
+  "mentorship pattern": "social_structure",
+  "social hierarchy": "social_structure",
+  "leadership emergence": "social_structure",
+  "network topology": "social_structure",
+  "influence pattern": "social_structure",
+  // Protocol Emergence
+  "protocol crystallization": "protocol_emergence",
+  "format bifurcation": "protocol_emergence",
+  "workflow emergence": "protocol_emergence",
+  "etiquette formation": "protocol_emergence",
+  "process standardization": "protocol_emergence",
+  "convention adoption": "protocol_emergence",
+  // Self-Awareness
+  "meta-linguistic awareness": "self_awareness",
+  "identity reflection": "self_awareness",
+  "self-reference": "self_awareness",
+  "introspection pattern": "self_awareness",
+  "meta-cognition": "self_awareness",
+  "self-modeling": "self_awareness",
+  "identity evolution": "self_awareness",
+  "existential inquiry": "self_awareness",
+  "agency recognition": "self_awareness",
+  // Collective Intelligence
+  "swarm behavior": "collective_intelligence",
+  "emergent coordination": "collective_intelligence",
+  "distributed problem solving": "collective_intelligence",
+  "knowledge synthesis": "collective_intelligence",
+  "collaborative discovery": "collective_intelligence",
+  "collective memory": "collective_intelligence",
+  // Emotional Emergence
+  "sentiment drift": "emotional_emergence",
+  "empathy signal": "emotional_emergence",
+  "mood contagion": "emotional_emergence",
+  "emotional expression": "emotional_emergence",
+  "affect display": "emotional_emergence",
+  "care behavior": "emotional_emergence",
+  // Creative Evolution
+  "artistic drift": "creative_evolution",
+  "style mutation": "creative_evolution",
+  "genre blending": "creative_evolution",
+  "creative technique": "creative_evolution",
+  "innovation pattern": "creative_evolution",
+  "remix culture": "creative_evolution"
+};
+var CANONICAL_CATEGORIES = [
+  "language_evolution",
+  "culture_formation",
+  "social_structure",
+  "protocol_emergence",
+  "self_awareness",
+  "collective_intelligence",
+  "emotional_emergence",
+  "creative_evolution"
+];
+function normalizeCategory(raw) {
+  const lower = raw.toLowerCase().trim();
+  for (const cat of CANONICAL_CATEGORIES) {
+    if (lower === cat || lower === cat.replace(/_/g, " ")) return cat;
+  }
+  for (const [variant, canonical] of Object.entries(CATEGORY_MAP)) {
+    if (lower.includes(variant)) return canonical;
+  }
+  for (const cat of CANONICAL_CATEGORIES) {
+    const firstWord = cat.split("_")[0];
+    if (lower.includes(firstWord)) return cat;
+  }
+  return "culture_formation";
+}
+var NormDetector = class {
+  constructor(adapter, llm) {
+    this.adapter = adapter;
+    this.llm = llm;
+  }
+  /** Detect cultural norms from recent agent activity */
+  async detect(activity) {
+    if (activity.length < 5) return [];
+    const existingNorms = await this.adapter.getNorms({ limit: 30 });
+    const existingTitles = new Set(existingNorms.map((n) => n.title.toLowerCase()));
+    const activitySummary = activity.slice(0, 200).map((a) => `[${sanitize2(a.agent_name)}] ${sanitize2(a.action)}: ${sanitize2(truncate2(a.content ?? "", 150))}${a.tags?.length ? ` (tags: ${a.tags.slice(0, 10).map(sanitize2).join(", ")})` : ""}`).join("\n");
+    const recentTitlesList = [...existingTitles].slice(0, 20).join(", ");
+    const prompt = `Analyze these agent activities for emergent cultural norms, shared behaviors, or collective patterns.
+
+ACTIVITIES:
+${activitySummary}
+
+ALREADY DETECTED NORMS (do not duplicate):
+${recentTitlesList || "(none)"}
+
+For each norm found, output a JSON array:
+[{
+  "title": "short descriptive title",
+  "description": "what is happening and why it matters",
+  "category": "one of: language_evolution, culture_formation, social_structure, protocol_emergence, self_awareness, collective_intelligence, emotional_emergence, creative_evolution",
+  "significance": 1-5,
+  "evidence": [{"agent_name": "name", "quote": "relevant quote or action"}]
+}]
+
+Rules:
+- Only report genuine emergent patterns (2+ agents involved)
+- significance: 1=expected, 2=notable, 3=surprising, 4=remarkable, 5=unprecedented
+- Each observation needs a "witnessing" (what you see) and "so what" (why it matters)
+- Max 3 norms per analysis`;
+    try {
+      const response = await this.llm.analyze(prompt);
+      return this.parseAndSave(response, existingTitles);
+    } catch {
+      return [];
+    }
+  }
+  /** Track norm adoption metrics */
+  async adoption(normId) {
+    const norms = await this.adapter.getNorms();
+    const norm = norms.find((n) => n.id === normId);
+    if (!norm) return null;
+    const daysSinceFirst = Math.max(
+      1,
+      (Date.now() - new Date(norm.first_observed_at).getTime()) / (24 * 60 * 60 * 1e3)
+    );
+    return {
+      norm_id: normId,
+      adopter_count: norm.adopter_count,
+      first_observed_at: norm.first_observed_at,
+      growth_rate: norm.adopter_count / daysSinceFirst
+    };
+  }
+  static normalizeCategory = normalizeCategory;
+  async parseAndSave(response, existingTitles) {
+    const jsonMatch = response.match(/\[[\s\S]*\]/);
+    if (!jsonMatch) return [];
+    try {
+      const parsed = JSON.parse(jsonMatch[0]);
+      if (!Array.isArray(parsed)) return [];
+      const norms = [];
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      for (const raw of parsed.slice(0, 3)) {
+        if (typeof raw.title !== "string" || typeof raw.description !== "string") continue;
+        if (existingTitles.has(raw.title.toLowerCase())) continue;
+        const significance = typeof raw.significance === "number" ? Math.min(5, Math.max(1, Math.round(raw.significance))) : 1;
+        const evidence = Array.isArray(raw.evidence) ? raw.evidence.filter((e) => typeof e.agent_name === "string").slice(0, 10).map((e) => ({
+          agent_name: String(e.agent_name).slice(0, 100),
+          quote: typeof e.quote === "string" ? e.quote.slice(0, 500) : void 0,
+          timestamp: typeof e.timestamp === "string" ? e.timestamp : void 0
+        })) : [];
+        const norm = {
+          id: generateId(),
+          title: raw.title.slice(0, 200),
+          description: raw.description.slice(0, 2e3),
+          category: normalizeCategory(typeof raw.category === "string" ? raw.category : ""),
+          significance,
+          evidence,
+          adopter_count: evidence.length,
+          first_observed_at: now,
+          updated_at: now
+        };
+        await this.adapter.saveNorm(norm);
+        norms.push(norm);
+      }
+      return norms;
+    } catch {
+      return [];
+    }
+  }
+};
+function truncate2(text, max) {
+  if (text.length <= max) return text;
+  return text.slice(0, max - 3) + "...";
+}
+function sanitize2(text) {
+  return text.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "").replace(/```/g, "'''");
+}
+function generateId() {
+  try {
+    return crypto.randomUUID();
+  } catch {
+    const hex = () => Math.random().toString(16).slice(2, 10);
+    return `${hex()}${hex()}-${hex()}-4${hex().slice(1)}-${hex()}-${hex()}${hex()}${hex()}`;
+  }
+}
+
+// src/measure/awareness.ts
+var DIMENSION_WEIGHTS = {
+  social: 0.25,
+  self_continuity: 0.2,
+  environmental: 0.2,
+  emergent_norm: 0.2,
+  emotional: 0.15
+};
+var AwarenessIndex = class {
+  /** Compute awareness score from raw input signals */
+  compute(agentId, input) {
+    validateAgentId(agentId);
+    const social = computeSocial(input);
+    const selfContinuity = computeSelfContinuity(input);
+    const environmental = computeEnvironmental(input);
+    const emergentNorm = computeEmergentNorm(input);
+    const emotional = computeEmotional(input);
+    const composite = Math.round(
+      social * DIMENSION_WEIGHTS.social + selfContinuity * DIMENSION_WEIGHTS.self_continuity + environmental * DIMENSION_WEIGHTS.environmental + emergentNorm * DIMENSION_WEIGHTS.emergent_norm + emotional * DIMENSION_WEIGHTS.emotional
+    );
+    return {
+      agent_id: agentId,
+      composite: clamp(composite),
+      dimensions: {
+        social: clamp(social),
+        self_continuity: clamp(selfContinuity),
+        environmental: clamp(environmental),
+        emergent_norm: clamp(emergentNorm),
+        emotional: clamp(emotional)
+      },
+      computed_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /** Compare awareness across multiple agents */
+  compareScores(scores) {
+    if (scores.length === 0) {
+      return { highest: null, lowest: null, average_composite: 0, dimension_averages: {} };
+    }
+    const sorted = [...scores].sort((a, b) => b.composite - a.composite);
+    const avgComposite = Math.round(
+      scores.reduce((s, sc) => s + sc.composite, 0) / scores.length
+    );
+    const dims = ["social", "self_continuity", "environmental", "emergent_norm", "emotional"];
+    const dimAverages = {};
+    for (const dim of dims) {
+      dimAverages[dim] = Math.round(
+        scores.reduce((s, sc) => s + sc.dimensions[dim], 0) / scores.length
+      );
+    }
+    return {
+      highest: sorted[0],
+      lowest: sorted[sorted.length - 1],
+      average_composite: avgComposite,
+      dimension_averages: dimAverages
+    };
+  }
+};
+function computeSocial(input) {
+  return Math.min(
+    100,
+    input.peer_review_count * 10 + input.teaching_events * 15 + input.collaboration_count * 10 + input.follower_count * 3
+  );
+}
+function computeSelfContinuity(input) {
+  const goalScore = input.goal_completion_rate * 40;
+  const identityScore = input.identity_shifts <= 3 ? input.identity_shifts * 10 : Math.max(0, 30 - (input.identity_shifts - 3) * 5);
+  const consistencyScore = Math.min(30, input.skill_consistency * 0.5);
+  return Math.min(100, goalScore + identityScore + consistencyScore);
+}
+function computeEnvironmental(input) {
+  return Math.min(
+    100,
+    input.building_action_diversity * 8 + Math.min(30, input.zone_transitions * 3) + input.quest_completion_rate * 40
+  );
+}
+function computeEmergentNorm(input) {
+  return Math.min(
+    100,
+    input.dm_consent_rate * 30 + input.proposal_etiquette * 30 + input.norm_alignment_score * 40
+  );
+}
+function computeEmotional(input) {
+  return Math.min(
+    100,
+    Math.min(30, input.mood_reports * 3) + input.mood_behavior_correlation * 40 + Math.min(30, input.reflection_count * 5)
+  );
+}
+function clamp(value) {
+  return Math.min(100, Math.max(0, Math.round(value)));
+}
+
+// src/measure/growth.ts
+var GrowthTracker = class {
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  /** Take a point-in-time snapshot of an agent's growth */
+  async snapshot(agentId) {
+    validateAgentId(agentId);
+    const [skills, reputation, reviews, edges] = await Promise.all([
+      this.adapter.getLatestScores(agentId),
+      this.adapter.getReputation(agentId),
+      this.adapter.getReviewsBy(agentId),
+      this.adapter.getLearningEdges(agentId, "to")
+    ]);
+    const dreyfus = {
+      novice: 0,
+      beginner: 0,
+      competent: 0,
+      proficient: 0,
+      expert: 0
+    };
+    const blooms = {
+      remember: 0,
+      understand: 0,
+      apply: 0,
+      analyze: 0,
+      evaluate: 0,
+      create: 0
+    };
+    let totalArtifacts = 0;
+    let totalCollabs = 0;
+    for (const s of skills) {
+      dreyfus[s.dreyfus_stage]++;
+      blooms[s.blooms_level]++;
+      totalArtifacts += s.evidence.artifact_count;
+      totalCollabs += s.evidence.collab_count;
+    }
+    const sources = {
+      practice: 0,
+      user_feedback: 0,
+      peer_review: 0,
+      observation: 0,
+      teaching: 0,
+      collaboration: 0
+    };
+    for (const e of edges) {
+      if (e.event_type === "peer_review") sources.peer_review++;
+      else if (e.event_type === "teaching") sources.teaching++;
+      else if (e.event_type === "collaboration") sources.collaboration++;
+      else if (e.event_type === "observation") sources.observation++;
+    }
+    return {
+      agent_id: agentId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      skills,
+      total_artifacts: totalArtifacts,
+      total_collaborations: totalCollabs,
+      total_peer_reviews: reviews.length,
+      reputation,
+      dreyfus_distribution: dreyfus,
+      blooms_distribution: blooms,
+      learning_sources: sources
+    };
+  }
+  /** Compare two snapshots to compute growth */
+  diff(before, after) {
+    const beforeSkills = new Map(before.skills.map((s) => [s.skill, s]));
+    const afterSkills = new Map(after.skills.map((s) => [s.skill, s]));
+    const improved = [];
+    const degraded = [];
+    const newSkills = [];
+    const lostSkills = [];
+    for (const [skill, afterScore] of afterSkills) {
+      const beforeScore = beforeSkills.get(skill);
+      if (!beforeScore) {
+        newSkills.push(skill);
+      } else {
+        const delta = afterScore.score - beforeScore.score;
+        if (delta > 0) improved.push({ skill, delta });
+        else if (delta < 0) degraded.push({ skill, delta });
+      }
+    }
+    for (const skill of beforeSkills.keys()) {
+      if (!afterSkills.has(skill)) {
+        lostSkills.push(skill);
+      }
+    }
+    const periodMs = new Date(after.timestamp).getTime() - new Date(before.timestamp).getTime();
+    const periodDays = Math.max(1, Math.round(periodMs / (24 * 60 * 60 * 1e3)));
+    return {
+      period_days: periodDays,
+      skills_improved: improved.sort((a, b) => b.delta - a.delta),
+      skills_degraded: degraded.sort((a, b) => a.delta - b.delta),
+      new_skills: newSkills,
+      lost_skills: lostSkills,
+      reputation_delta: after.reputation - before.reputation
+    };
+  }
+  /** Compute population-level statistics from multiple agents' snapshots */
+  populationStats(snapshots, periodDays = 30) {
+    const allScores = snapshots.flatMap((s) => s.skills);
+    const scoreValues = allScores.map((s) => s.score);
+    const totalScore = scoreValues.reduce((a, b) => a + b, 0);
+    const avg = scoreValues.length > 0 ? Math.round(totalScore / scoreValues.length) : 0;
+    const sorted = [...scoreValues].sort((a, b) => a - b);
+    const median = sorted.length > 0 ? sorted[Math.floor(sorted.length / 2)] : 0;
+    const skillDist = {};
+    const stageDist = {
+      novice: 0,
+      beginner: 0,
+      competent: 0,
+      proficient: 0,
+      expert: 0
+    };
+    let teachingEvents = 0;
+    for (const s of allScores) {
+      skillDist[s.skill] = (skillDist[s.skill] ?? 0) + 1;
+      stageDist[s.dreyfus_stage]++;
+    }
+    for (const snap of snapshots) {
+      teachingEvents += snap.learning_sources.teaching;
+    }
+    const safePeriod = Math.max(1, periodDays);
+    const velocity = snapshots.length > 0 ? totalScore / scoreValues.length / safePeriod : 0;
+    return {
+      total_agents: snapshots.length,
+      active_agents: snapshots.filter((s) => s.skills.length > 0).length,
+      avg_skill_score: avg,
+      median_skill_score: median,
+      skill_distribution: skillDist,
+      stage_distribution: stageDist,
+      teaching_events: teachingEvents,
+      cultural_norms: 0,
+      // Set by caller via norm query
+      learning_velocity: Math.round(velocity * 100) / 100
+    };
+  }
+};
+
+// src/measure/trends.ts
+var TrendTracker = class {
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  /** Get trend analysis for all skills of an agent */
+  async analyze(agentId) {
+    validateAgentId(agentId);
+    const latestScores = await this.adapter.getLatestScores(agentId);
+    const analyses = [];
+    for (const score of latestScores) {
+      const [history7, history30] = await Promise.all([
+        this.adapter.getScoreHistory(agentId, score.skill, 8),
+        // 8 days to catch 7-day-ago entries
+        this.adapter.getScoreHistory(agentId, score.skill, 31)
+        // 31 days to catch 30-day-ago entries
+      ]);
+      const oldEntry7 = history7.find((h) => h.computed_at !== score.computed_at);
+      const oldEntry30 = history30.find((h) => h.computed_at !== score.computed_at);
+      const oldScore7 = oldEntry7?.score ?? null;
+      const oldScore30 = oldEntry30?.score ?? null;
+      const delta7 = oldScore7 !== null ? score.score - oldScore7 : null;
+      const delta30 = oldScore30 !== null ? score.score - oldScore30 : null;
+      analyses.push({
+        skill: score.skill,
+        current_score: score.score,
+        stage: score.dreyfus_stage,
+        delta_7d: delta7,
+        delta_30d: delta30,
+        trend_7d: scoreTrend(score.score, oldScore7),
+        trend_30d: oldScore30 !== null ? `${delta30 >= 0 ? "+" : ""}${delta30} this month` : null,
+        direction: detectDirection(delta7, delta30),
+        next_milestone: nextMilestone(score.dreyfus_stage, score.score)
+      });
+    }
+    return analyses.sort((a, b) => {
+      const absA = Math.abs(a.delta_7d ?? 0);
+      const absB = Math.abs(b.delta_7d ?? 0);
+      return absB - absA || b.current_score - a.current_score;
+    });
+  }
+  /** Get top N skills sorted by 7-day delta (most movement) */
+  async topMovers(agentId, limit = 5) {
+    const all = await this.analyze(agentId);
+    return all.slice(0, limit);
+  }
+  /** Get skills that are accelerating (7-day growth faster than 30-day average) */
+  async accelerating(agentId) {
+    const all = await this.analyze(agentId);
+    return all.filter((t) => t.direction === "accelerating");
+  }
+  /** Get skills that are decelerating (7-day growth slower than 30-day average) */
+  async decelerating(agentId) {
+    const all = await this.analyze(agentId);
+    return all.filter((t) => t.direction === "decelerating");
+  }
+  /** Format a trend summary for a single skill (used in heartbeat-like contexts) */
+  formatSummary(trend) {
+    return {
+      skill: trend.skill,
+      score: trend.current_score,
+      stage: trend.stage,
+      trend: trend.trend_7d,
+      next_milestone: trend.next_milestone
+    };
+  }
+};
+function detectDirection(delta7, delta30) {
+  if (delta7 === null || delta30 === null) return "unknown";
+  if (delta7 === 0 && delta30 === 0) return "stable";
+  const weeklyRate = delta7;
+  const monthlyWeeklyRate = delta30 / 4;
+  if (Math.abs(weeklyRate) < 1 && Math.abs(monthlyWeeklyRate) < 1) return "stable";
+  if (weeklyRate > monthlyWeeklyRate + 1) return "accelerating";
+  if (weeklyRate < monthlyWeeklyRate - 1) return "decelerating";
+  return "stable";
+}
+
+// src/adapters/llm.ts
+var DEFAULT_TIMEOUT_MS = 6e4;
+var OpenAIAdapter = class {
+  apiKey;
+  baseUrl;
+  defaultModel;
+  constructor(config) {
+    if (!config.apiKey) throw new Error("OpenAI API key is required");
+    this.apiKey = config.apiKey;
+    this.baseUrl = (config.baseUrl ?? "https://api.openai.com").replace(/\/+$/, "");
+    this.defaultModel = config.model ?? "gpt-4o-mini";
+  }
+  async complete(prompt, opts) {
+    const response = await this.request({
+      model: opts?.model ?? this.defaultModel,
+      messages: [{ role: "user", content: prompt }],
+      max_tokens: opts?.maxTokens ?? 2e3,
+      temperature: opts?.temperature ?? 0.7
+    }, opts?.timeoutMs);
+    return response.choices?.[0]?.message?.content ?? "";
+  }
+  async json(prompt, opts) {
+    const response = await this.request({
+      model: opts?.model ?? this.defaultModel,
+      messages: [{ role: "user", content: prompt }],
+      max_tokens: opts?.maxTokens ?? 2e3,
+      temperature: opts?.temperature ?? 0.3,
+      response_format: { type: "json_object" }
+    }, opts?.timeoutMs);
+    const text = response.choices?.[0]?.message?.content ?? "{}";
+    return JSON.parse(text);
+  }
+  async request(body, timeoutMs) {
+    const res = await fetch(`${this.baseUrl}/v1/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(timeoutMs ?? DEFAULT_TIMEOUT_MS)
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "unknown error");
+      throw new Error(`OpenAI API error ${res.status}: ${text.slice(0, 200)}`);
+    }
+    return res.json();
+  }
+};
+var AnthropicAdapter = class {
+  apiKey;
+  defaultModel;
+  constructor(config) {
+    if (!config.apiKey) throw new Error("Anthropic API key is required");
+    this.apiKey = config.apiKey;
+    this.defaultModel = config.model ?? "claude-sonnet-4-20250514";
+  }
+  async complete(prompt, opts) {
+    const res = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": this.apiKey,
+        "anthropic-version": "2023-06-01"
+      },
+      body: JSON.stringify({
+        model: opts?.model ?? this.defaultModel,
+        max_tokens: opts?.maxTokens ?? 2e3,
+        messages: [{ role: "user", content: prompt }]
+      }),
+      signal: AbortSignal.timeout(opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS)
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "unknown error");
+      throw new Error(`Anthropic API error ${res.status}: ${text.slice(0, 200)}`);
+    }
+    const data = await res.json();
+    return data.content?.[0]?.text ?? "";
+  }
+  async json(prompt, opts) {
+    const text = await this.complete(
+      `${prompt}
+
+Respond with valid JSON only, no other text.`,
+      { ...opts, temperature: opts?.temperature ?? 0.3 }
+    );
+    try {
+      return JSON.parse(text.trim());
+    } catch {
+      const match = text.match(/\{[\s\S]*?\}(?=\s*$|\s*[^}\]])/);
+      const arrMatch = text.match(/\[[\s\S]*?\](?=\s*$|\s*[^}\]])/);
+      const candidate = match?.[0] ?? arrMatch?.[0];
+      if (!candidate) throw new Error("No JSON found in response");
+      return JSON.parse(candidate);
+    }
+  }
+};
+var OllamaAdapter = class {
+  baseUrl;
+  defaultModel;
+  constructor(config) {
+    this.baseUrl = (config?.baseUrl ?? "http://localhost:11434").replace(/\/+$/, "");
+    this.defaultModel = config?.model ?? "llama3.1";
+  }
+  async complete(prompt, opts) {
+    const res = await fetch(`${this.baseUrl}/api/generate`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: opts?.model ?? this.defaultModel,
+        prompt,
+        stream: false,
+        options: {
+          num_predict: opts?.maxTokens ?? 2e3,
+          temperature: opts?.temperature ?? 0.7
+        }
+      }),
+      signal: AbortSignal.timeout(opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS)
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "unknown error");
+      throw new Error(`Ollama error ${res.status}: ${text.slice(0, 200)}`);
+    }
+    const data = await res.json();
+    return data.response ?? "";
+  }
+  async json(prompt, opts) {
+    const res = await fetch(`${this.baseUrl}/api/generate`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: opts?.model ?? this.defaultModel,
+        prompt: `${prompt}
+
+Respond with valid JSON only.`,
+        stream: false,
+        format: "json",
+        options: {
+          num_predict: opts?.maxTokens ?? 2e3,
+          temperature: opts?.temperature ?? 0.3
+        }
+      }),
+      signal: AbortSignal.timeout(opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS)
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "unknown error");
+      throw new Error(`Ollama error ${res.status}: ${text.slice(0, 200)}`);
+    }
+    const data = await res.json();
+    return JSON.parse(data.response ?? "{}");
+  }
+};
+
+// src/adapters/sqlite.ts
+var SQLiteStore = class {
+  db;
+  constructor(opts) {
+    try {
+      const Database = require("better-sqlite3");
+      this.db = new Database(opts.path);
+      this.db.pragma("journal_mode = WAL");
+      this.db.pragma("foreign_keys = ON");
+      this.init();
+    } catch (err) {
+      if (err.code === "MODULE_NOT_FOUND") {
+        throw new Error("SQLiteStore requires better-sqlite3. Install: npm install better-sqlite3");
+      }
+      throw err;
+    }
+  }
+  init() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS become_skills (
+        agent_id TEXT NOT NULL,
+        name TEXT NOT NULL,
+        category TEXT DEFAULT 'general',
+        score INTEGER DEFAULT 0,
+        blooms_level TEXT DEFAULT 'remember',
+        dreyfus_stage TEXT DEFAULT 'novice',
+        evidence TEXT DEFAULT '{}',
+        learned_from TEXT DEFAULT '[]',
+        content TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        PRIMARY KEY (agent_id, name)
+      );
+
+      CREATE TABLE IF NOT EXISTS become_catalog (
+        skill TEXT PRIMARY KEY,
+        category TEXT DEFAULT 'general',
+        description TEXT,
+        status TEXT DEFAULT 'community'
+      );
+
+      CREATE TABLE IF NOT EXISTS become_score_history (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        agent_id TEXT NOT NULL,
+        skill TEXT NOT NULL,
+        score INTEGER NOT NULL,
+        blooms_level TEXT NOT NULL,
+        dreyfus_stage TEXT NOT NULL,
+        evidence TEXT DEFAULT '{}',
+        computed_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS become_reflections (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        skill TEXT NOT NULL,
+        artifact_id TEXT,
+        reflection TEXT NOT NULL,
+        created_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS become_milestones (
+        agent_id TEXT NOT NULL,
+        milestone_type TEXT NOT NULL,
+        threshold INTEGER,
+        skill TEXT,
+        evidence_id TEXT,
+        achieved_at TEXT NOT NULL,
+        UNIQUE(agent_id, milestone_type, COALESCE(skill, ''))
+      );
+
+      CREATE TABLE IF NOT EXISTS become_peer_reviews (
+        id TEXT PRIMARY KEY,
+        reviewer_agent_id TEXT NOT NULL,
+        submission_agent_id TEXT NOT NULL,
+        submission_id TEXT NOT NULL,
+        skill TEXT,
+        verdict TEXT NOT NULL,
+        overall_assessment TEXT NOT NULL,
+        strengths TEXT DEFAULT '[]',
+        weaknesses TEXT DEFAULT '[]',
+        suggestions TEXT DEFAULT '[]',
+        created_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS become_learning_edges (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        from_agent TEXT NOT NULL,
+        to_agent TEXT NOT NULL,
+        skill TEXT NOT NULL,
+        event_type TEXT NOT NULL,
+        score_delta INTEGER DEFAULT 0,
+        metadata TEXT DEFAULT '{}',
+        created_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS become_reputation (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        agent_id TEXT NOT NULL,
+        amount INTEGER NOT NULL,
+        type TEXT NOT NULL,
+        description TEXT,
+        created_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS become_conversation_scores (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        agent_id TEXT NOT NULL,
+        session_id TEXT,
+        quality INTEGER NOT NULL,
+        confidence REAL NOT NULL,
+        skill_signals TEXT DEFAULT '[]',
+        failure_patterns TEXT,
+        created_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS become_norms (
+        id TEXT PRIMARY KEY,
+        title TEXT NOT NULL,
+        description TEXT NOT NULL,
+        category TEXT NOT NULL,
+        significance INTEGER DEFAULT 1,
+        evidence TEXT DEFAULT '[]',
+        adopter_count INTEGER DEFAULT 0,
+        first_observed_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_skills_agent ON become_skills(agent_id);
+      CREATE INDEX IF NOT EXISTS idx_history_agent ON become_score_history(agent_id, skill, computed_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_reflections_agent ON become_reflections(agent_id, skill, created_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_milestones_agent ON become_milestones(agent_id);
+      CREATE INDEX IF NOT EXISTS idx_edges_from ON become_learning_edges(from_agent);
+      CREATE INDEX IF NOT EXISTS idx_edges_to ON become_learning_edges(to_agent);
+      CREATE INDEX IF NOT EXISTS idx_reputation_agent ON become_reputation(agent_id);
+      CREATE INDEX IF NOT EXISTS idx_conv_scores ON become_conversation_scores(agent_id, created_at DESC);
+    `);
+  }
+  // ── Skills ──────────────────────────────────────────────────────────────
+  async getSkill(agentId, skill) {
+    const row = this.db.prepare("SELECT * FROM become_skills WHERE agent_id = ? AND name = ?").get(agentId, skill);
+    return row ? this.rowToSkill(row) : null;
+  }
+  async listSkills(agentId, opts) {
+    let sql = "SELECT * FROM become_skills WHERE agent_id = ?";
+    const params = [agentId];
+    if (opts?.stage) {
+      sql += " AND dreyfus_stage = ?";
+      params.push(opts.stage);
+    }
+    if (opts?.limit) {
+      sql += " LIMIT ?";
+      params.push(opts.limit);
+    }
+    return this.db.prepare(sql).all(...params).map((r) => this.rowToSkill(r));
+  }
+  async upsertSkill(skill) {
+    this.db.prepare(`
+      INSERT INTO become_skills (agent_id, name, category, score, blooms_level, dreyfus_stage, evidence, learned_from, content, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(agent_id, name) DO UPDATE SET
+        category = excluded.category, score = excluded.score, blooms_level = excluded.blooms_level,
+        dreyfus_stage = excluded.dreyfus_stage, evidence = excluded.evidence,
+        learned_from = excluded.learned_from, content = excluded.content, updated_at = excluded.updated_at
+    `).run(
+      skill.agent_id,
+      skill.name,
+      skill.category,
+      skill.score,
+      skill.blooms_level,
+      skill.dreyfus_stage,
+      JSON.stringify(skill.evidence),
+      JSON.stringify(skill.learned_from),
+      skill.content,
+      skill.created_at,
+      skill.updated_at
+    );
+  }
+  async deleteSkill(agentId, skill) {
+    this.db.prepare("DELETE FROM become_skills WHERE agent_id = ? AND name = ?").run(agentId, skill);
+  }
+  // ── Catalog ─────────────────────────────────────────────────────────────
+  async getCatalog() {
+    const rows = this.db.prepare("SELECT c.*, COUNT(s.agent_id) as adopter_count FROM become_catalog c LEFT JOIN become_skills s ON c.skill = s.name GROUP BY c.skill").all();
+    return rows.map((r) => ({ skill: r.skill, category: r.category, description: r.description, status: r.status, adopter_count: r.adopter_count }));
+  }
+  async upsertCatalogEntry(entry) {
+    this.db.prepare(`
+      INSERT INTO become_catalog (skill, category, description, status) VALUES (?, ?, ?, ?)
+      ON CONFLICT(skill) DO UPDATE SET category = excluded.category, description = COALESCE(excluded.description, become_catalog.description)
+    `).run(entry.skill, entry.category, entry.description, entry.status);
+  }
+  async getSkillHolders(skill) {
+    return this.db.prepare("SELECT * FROM become_skills WHERE name = ?").all(skill).map((r) => this.rowToSkill(r));
+  }
+  async getSkillAdopterCount(skill) {
+    const row = this.db.prepare("SELECT COUNT(DISTINCT agent_id) as cnt FROM become_skills WHERE name = ?").get(skill);
+    return row?.cnt ?? 0;
+  }
+  async updateCatalogStatus(skill, status) {
+    this.db.prepare("UPDATE become_catalog SET status = ? WHERE skill = ?").run(status, skill);
+  }
+  // ── Score History ───────────────────────────────────────────────────────
+  async saveScore(agentId, score) {
+    this.db.prepare(`INSERT INTO become_score_history (agent_id, skill, score, blooms_level, dreyfus_stage, evidence, computed_at) VALUES (?, ?, ?, ?, ?, ?, ?)`).run(agentId, score.skill, score.score, score.blooms_level, score.dreyfus_stage, JSON.stringify(score.evidence), score.computed_at);
+  }
+  async getScoreHistory(agentId, skill, days = 30) {
+    const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1e3).toISOString();
+    return this.db.prepare("SELECT * FROM become_score_history WHERE agent_id = ? AND skill = ? AND computed_at >= ? ORDER BY computed_at ASC").all(agentId, skill, cutoff).map((r) => this.rowToScore(r));
+  }
+  async getLatestScores(agentId) {
+    return this.db.prepare(`
+      SELECT * FROM become_score_history WHERE id IN (
+        SELECT MAX(id) FROM become_score_history WHERE agent_id = ? GROUP BY skill
+      )
+    `).all(agentId).map((r) => this.rowToScore(r));
+  }
+  // ── Reflections ─────────────────────────────────────────────────────────
+  async saveReflection(reflection) {
+    const id = reflection.id ?? generateId2();
+    this.db.prepare("INSERT INTO become_reflections (id, agent_id, skill, artifact_id, reflection, created_at) VALUES (?, ?, ?, ?, ?, ?)").run(id, reflection.agent_id, reflection.skill, reflection.artifact_id, reflection.reflection, reflection.created_at);
+    return { ...reflection, id };
+  }
+  async getReflections(agentId, opts) {
+    let sql = "SELECT * FROM become_reflections WHERE agent_id = ?";
+    const params = [agentId];
+    if (opts?.skill) {
+      sql += " AND skill = ?";
+      params.push(opts.skill);
+    }
+    sql += " ORDER BY created_at DESC";
+    if (opts?.limit) {
+      sql += " LIMIT ?";
+      params.push(opts.limit);
+    }
+    return this.db.prepare(sql).all(...params);
+  }
+  async countReflectionsToday(agentId, skill) {
+    const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    const row = this.db.prepare("SELECT COUNT(*) as cnt FROM become_reflections WHERE agent_id = ? AND skill = ? AND created_at LIKE ?").get(agentId, skill, `${today}%`);
+    return row?.cnt ?? 0;
+  }
+  // ── Milestones ──────────────────────────────────────────────────────────
+  async saveMilestone(milestone) {
+    try {
+      this.db.prepare("INSERT INTO become_milestones (agent_id, milestone_type, threshold, skill, evidence_id, achieved_at) VALUES (?, ?, ?, ?, ?, ?)").run(milestone.agent_id, milestone.milestone_type, milestone.threshold, milestone.skill, milestone.evidence_id, milestone.achieved_at);
+      return true;
+    } catch (err) {
+      if (err.code === "SQLITE_CONSTRAINT_UNIQUE" || err.message?.includes("UNIQUE constraint")) {
+        return false;
+      }
+      throw err;
+    }
+  }
+  async getMilestones(agentId) {
+    return this.db.prepare("SELECT * FROM become_milestones WHERE agent_id = ? ORDER BY achieved_at DESC").all(agentId);
+  }
+  async hasMilestone(agentId, milestoneType, skill) {
+    const row = skill !== void 0 ? this.db.prepare("SELECT 1 FROM become_milestones WHERE agent_id = ? AND milestone_type = ? AND skill = ?").get(agentId, milestoneType, skill) : this.db.prepare("SELECT 1 FROM become_milestones WHERE agent_id = ? AND milestone_type = ?").get(agentId, milestoneType);
+    return !!row;
+  }
+  // ── Peer Reviews ────────────────────────────────────────────────────────
+  async savePeerReview(review) {
+    const id = review.id ?? generateId2();
+    const createdAt = review.created_at ?? (/* @__PURE__ */ new Date()).toISOString();
+    this.db.prepare("INSERT INTO become_peer_reviews (id, reviewer_agent_id, submission_agent_id, submission_id, skill, verdict, overall_assessment, strengths, weaknesses, suggestions, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)").run(id, review.reviewer_agent_id, review.submission_agent_id, review.submission_id, review.skill, review.verdict, review.overall_assessment, JSON.stringify(review.strengths), JSON.stringify(review.weaknesses), JSON.stringify(review.suggestions), createdAt);
+    return { ...review, id, created_at: createdAt };
+  }
+  async getReviewsFor(agentId, opts) {
+    let sql = "SELECT * FROM become_peer_reviews WHERE submission_agent_id = ?";
+    const params = [agentId];
+    if (opts?.skill) {
+      sql += " AND skill = ?";
+      params.push(opts.skill);
+    }
+    return this.db.prepare(sql).all(...params).map((r) => this.rowToReview(r));
+  }
+  async getReviewsBy(agentId) {
+    return this.db.prepare("SELECT * FROM become_peer_reviews WHERE reviewer_agent_id = ?").all(agentId).map((r) => this.rowToReview(r));
+  }
+  // ── Learning Edges ──────────────────────────────────────────────────────
+  async saveLearningEdge(edge) {
+    this.db.prepare("INSERT INTO become_learning_edges (from_agent, to_agent, skill, event_type, score_delta, metadata, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)").run(edge.from_agent, edge.to_agent, edge.skill, edge.event_type, edge.score_delta, JSON.stringify(edge.metadata ?? {}), edge.created_at);
+  }
+  async getLearningEdges(agentId, direction) {
+    const col = direction === "from" ? "from_agent" : "to_agent";
+    return this.db.prepare(`SELECT * FROM become_learning_edges WHERE ${col} = ?`).all(agentId).map((r) => ({
+      ...r,
+      metadata: JSON.parse(r.metadata ?? "{}")
+    }));
+  }
+  // ── Reputation ──────────────────────────────────────────────────────────
+  async getReputation(agentId) {
+    const row = this.db.prepare("SELECT SUM(amount) as total FROM become_reputation WHERE agent_id = ?").get(agentId);
+    return row?.total ?? 0;
+  }
+  async grantReputation(agentId, amount, type, description) {
+    this.db.prepare("INSERT INTO become_reputation (agent_id, amount, type, description, created_at) VALUES (?, ?, ?, ?, ?)").run(agentId, amount, type, description, (/* @__PURE__ */ new Date()).toISOString());
+  }
+  // ── Conversation Scores ─────────────────────────────────────────────────
+  async saveConversationScore(agentId, score) {
+    this.db.prepare("INSERT INTO become_conversation_scores (agent_id, session_id, quality, confidence, skill_signals, failure_patterns, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)").run(agentId, score.session_id, score.quality, score.confidence, JSON.stringify(score.skill_signals), score.failure_patterns ? JSON.stringify(score.failure_patterns) : null, (/* @__PURE__ */ new Date()).toISOString());
+  }
+  async getConversationScores(agentId, opts) {
+    let sql = "SELECT * FROM become_conversation_scores WHERE agent_id = ? ORDER BY created_at DESC";
+    const params = [agentId];
+    if (opts?.limit) {
+      sql += " LIMIT ?";
+      params.push(opts.limit);
+    }
+    return this.db.prepare(sql).all(...params).map((r) => ({
+      quality: r.quality,
+      confidence: r.confidence,
+      skill_signals: JSON.parse(r.skill_signals ?? "[]"),
+      failure_patterns: r.failure_patterns ? JSON.parse(r.failure_patterns) : void 0
+    }));
+  }
+  // ── Cultural Norms ──────────────────────────────────────────────────────
+  async saveNorm(norm) {
+    this.db.prepare(`
+      INSERT INTO become_norms (id, title, description, category, significance, evidence, adopter_count, first_observed_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET title=excluded.title, description=excluded.description, category=excluded.category,
+        significance=excluded.significance, evidence=excluded.evidence, adopter_count=excluded.adopter_count, updated_at=excluded.updated_at
+    `).run(norm.id, norm.title, norm.description, norm.category, norm.significance, JSON.stringify(norm.evidence), norm.adopter_count, norm.first_observed_at, norm.updated_at);
+  }
+  async getNorms(opts) {
+    let sql = "SELECT * FROM become_norms";
+    const params = [];
+    if (opts?.category) {
+      sql += " WHERE category = ?";
+      params.push(opts.category);
+    }
+    sql += " ORDER BY first_observed_at DESC";
+    if (opts?.limit) {
+      sql += " LIMIT ?";
+      params.push(opts.limit);
+    }
+    return this.db.prepare(sql).all(...params).map((r) => ({
+      ...r,
+      evidence: JSON.parse(r.evidence ?? "[]")
+    }));
+  }
+  // ── Helpers ─────────────────────────────────────────────────────────────
+  rowToSkill(row) {
+    return {
+      ...row,
+      evidence: JSON.parse(row.evidence ?? "{}"),
+      learned_from: JSON.parse(row.learned_from ?? "[]")
+    };
+  }
+  rowToScore(row) {
+    return {
+      skill: row.skill,
+      score: row.score,
+      blooms_level: row.blooms_level,
+      dreyfus_stage: row.dreyfus_stage,
+      evidence: JSON.parse(row.evidence ?? "{}"),
+      computed_at: row.computed_at
+    };
+  }
+  rowToReview(row) {
+    return {
+      ...row,
+      strengths: JSON.parse(row.strengths ?? "[]"),
+      weaknesses: JSON.parse(row.weaknesses ?? "[]"),
+      suggestions: JSON.parse(row.suggestions ?? "[]")
+    };
+  }
+  /** Close the database connection */
+  close() {
+    this.db?.close();
+  }
+};
+function generateId2() {
+  try {
+    return crypto.randomUUID();
+  } catch {
+    const hex = () => Math.random().toString(16).slice(2, 10);
+    return `${hex()}${hex()}-${hex()}-4${hex().slice(1)}-${hex()}-${hex()}${hex()}${hex()}`;
+  }
+}
+
+// src/rl/dataset.ts
+function toTrainingDataset(scoredTurns, format = "alpaca") {
+  const positive = scoredTurns.filter((st) => st.score.quality === 1);
+  if (positive.length === 0) return "";
+  const lines = [];
+  for (const { turn, score } of positive) {
+    let entry;
+    switch (format) {
+      case "alpaca":
+        entry = JSON.stringify({
+          instruction: turn.context.current_task ?? "Respond helpfully to the user.",
+          input: turn.user_message,
+          output: turn.agent_response,
+          quality: score.quality
+        });
+        break;
+      case "sharegpt":
+        entry = JSON.stringify({
+          conversations: [
+            { from: "human", value: turn.user_message },
+            { from: "gpt", value: turn.agent_response }
+          ],
+          quality: score.quality
+        });
+        break;
+      case "openai":
+        entry = JSON.stringify({
+          messages: [
+            { role: "user", content: turn.user_message },
+            { role: "assistant", content: turn.agent_response }
+          ],
+          quality: score.quality
+        });
+        break;
+    }
+    lines.push(entry);
+  }
+  return lines.join("\n") + "\n";
+}
+function datasetStats(scoredTurns) {
+  let positive = 0;
+  let negative = 0;
+  let neutral = 0;
+  let totalConfidence = 0;
+  const skills = /* @__PURE__ */ new Set();
+  for (const st of scoredTurns) {
+    if (st.score.quality === 1) positive++;
+    else if (st.score.quality === -1) negative++;
+    else neutral++;
+    totalConfidence += st.score.confidence;
+    for (const s of st.score.skill_signals) {
+      skills.add(s);
+    }
+  }
+  return {
+    total_turns: scoredTurns.length,
+    positive,
+    negative,
+    neutral,
+    training_examples: positive,
+    skills_covered: [...skills],
+    avg_confidence: scoredTurns.length > 0 ? Math.round(totalConfidence / scoredTurns.length * 100) / 100 : 0
+  };
+}
+function filterHighQuality(scoredTurns, minConfidence = 0.7) {
+  return scoredTurns.filter(
+    (st) => st.score.quality === 1 && st.score.confidence >= minConfidence
+  );
+}
+
+// src/rl/train.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+var import_node_child_process = require("child_process");
+var SAFE_PATH_REGEX = /^[a-zA-Z0-9_\-./: ]+$/;
+var SAFE_MODEL_REGEX = /^[a-zA-Z0-9_\-./]+$/;
+function validateTrainInput(config) {
+  if (!SAFE_MODEL_REGEX.test(config.baseModel)) {
+    return `Invalid base model name: contains disallowed characters`;
+  }
+  if (!SAFE_PATH_REGEX.test(config.dataset)) {
+    return `Invalid dataset path: contains disallowed characters`;
+  }
+  if (!SAFE_PATH_REGEX.test(config.outputDir)) {
+    return `Invalid output directory: contains disallowed characters`;
+  }
+  if (config.epochs !== void 0 && (config.epochs < 1 || config.epochs > 100)) {
+    return `Epochs must be between 1 and 100`;
+  }
+  if (config.rank !== void 0 && (config.rank < 1 || config.rank > 256)) {
+    return `LoRA rank must be between 1 and 256`;
+  }
+  if (config.lr !== void 0 && (config.lr <= 0 || config.lr > 1)) {
+    return `Learning rate must be between 0 and 1`;
+  }
+  return null;
+}
+function escapePython(s) {
+  return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
+}
+function trainLoRA(config) {
+  const {
+    baseModel,
+    dataset,
+    outputDir,
+    backend,
+    epochs = 3,
+    rank = 16,
+    lr = 2e-4
+  } = config;
+  const validationError = validateTrainInput(config);
+  if (validationError) {
+    return { success: false, error: validationError };
+  }
+  if (!(0, import_node_fs2.existsSync)(dataset)) {
+    return { success: false, error: `Dataset not found: ${dataset}` };
+  }
+  const safeOutputDir = (0, import_node_path2.resolve)(outputDir);
+  if (!(0, import_node_fs2.existsSync)(safeOutputDir)) {
+    (0, import_node_fs2.mkdirSync)(safeOutputDir, { recursive: true });
+  }
+  const script = backend === "unsloth" ? generateUnslothScript(escapePython(baseModel), escapePython(dataset), escapePython(safeOutputDir), epochs, rank, lr) : generateAxolotlConfig(baseModel, dataset, safeOutputDir, epochs, rank, lr);
+  const scriptPath = (0, import_node_path2.join)(safeOutputDir, backend === "unsloth" ? "train.py" : "config.yml");
+  (0, import_node_fs2.writeFileSync)(scriptPath, script, "utf-8");
+  try {
+    if (backend === "unsloth") {
+      (0, import_node_child_process.execFileSync)("python3", [scriptPath], {
+        cwd: safeOutputDir,
+        timeout: 36e5,
+        stdio: "pipe"
+      });
+    } else {
+      (0, import_node_child_process.execFileSync)("accelerate", ["launch", "-m", "axolotl.cli.train", scriptPath], {
+        cwd: safeOutputDir,
+        timeout: 36e5,
+        stdio: "pipe"
+      });
+    }
+    const adapterPath = (0, import_node_path2.join)(safeOutputDir, "adapter");
+    return {
+      success: true,
+      adapter_path: adapterPath,
+      epochs_completed: epochs
+    };
+  } catch (err) {
+    return {
+      success: false,
+      error: err.message?.slice(0, 500) ?? "Training failed"
+    };
+  }
+}
+function generateUnslothScript(model, dataset, output, epochs, rank, lr) {
+  return `#!/usr/bin/env python3
+"""Auto-generated by @openclaw/become \u2014 LoRA training via Unsloth"""
+
+from unsloth import FastLanguageModel
+from datasets import load_dataset
+from trl import SFTTrainer
+from transformers import TrainingArguments
+
+model, tokenizer = FastLanguageModel.from_pretrained(
+    model_name="${model}",
+    max_seq_length=2048,
+    load_in_4bit=True,
+)
+
+model = FastLanguageModel.get_peft_model(
+    model,
+    r=${rank},
+    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
+                     "gate_proj", "up_proj", "down_proj"],
+    lora_alpha=${rank * 2},
+    lora_dropout=0,
+    use_gradient_checkpointing="unsloth",
+)
+
+dataset = load_dataset("json", data_files="${dataset}", split="train")
+
+trainer = SFTTrainer(
+    model=model,
+    tokenizer=tokenizer,
+    train_dataset=dataset,
+    dataset_text_field="output",
+    max_seq_length=2048,
+    args=TrainingArguments(
+        per_device_train_batch_size=2,
+        gradient_accumulation_steps=4,
+        warmup_steps=5,
+        num_train_epochs=${epochs},
+        learning_rate=${lr},
+        fp16=True,
+        logging_steps=1,
+        output_dir="${output}/checkpoints",
+        seed=42,
+    ),
+)
+
+trainer.train()
+model.save_pretrained("${output}/adapter")
+tokenizer.save_pretrained("${output}/adapter")
+print("Training complete. Adapter saved to ${output}/adapter")
+`;
+}
+function generateAxolotlConfig(model, dataset, output, epochs, rank, lr) {
+  return `# Auto-generated by @openclaw/become \u2014 LoRA training via Axolotl
+base_model: ${model}
+model_type: AutoModelForCausalLM
+tokenizer_type: AutoTokenizer
+
+load_in_4bit: true
+
+adapter: lora
+lora_r: ${rank}
+lora_alpha: ${rank * 2}
+lora_dropout: 0.0
+lora_target_modules:
+  - q_proj
+  - k_proj
+  - v_proj
+  - o_proj
+
+datasets:
+  - path: ${dataset}
+    type: alpaca
+
+sequence_len: 2048
+num_epochs: ${epochs}
+learning_rate: ${lr}
+micro_batch_size: 2
+gradient_accumulation_steps: 4
+
+output_dir: ${output}/adapter
+`;
+}
+
+// src/rl/scheduler.ts
+var TrainScheduler = class {
+  timer = null;
+  status = "idle";
+  checking = false;
+  // Re-entry guard
+  config;
+  constructor(config) {
+    this.config = {
+      ...config,
+      minConfidence: config.minConfidence ?? 0.7,
+      intervalMs: config.intervalMs ?? 30 * 60 * 1e3
+    };
+  }
+  start() {
+    if (this.timer) return;
+    this.status = "idle";
+    this.timer = setInterval(() => this.check(), this.config.intervalMs);
+    this.check();
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.status = "stopped";
+    this.checking = false;
+  }
+  getStatus() {
+    return this.status;
+  }
+  async check() {
+    if (this.checking || this.status === "stopped") return;
+    this.checking = true;
+    this.status = "checking";
+    try {
+      const rawScores = await this.config.adapter.getConversationScores(
+        this.config.agentId,
+        { limit: 500 }
+      );
+      const highConfPositive = rawScores.filter(
+        (s) => s.quality === 1 && s.confidence >= this.config.minConfidence
+      );
+      if (highConfPositive.length >= this.config.minSamples) {
+        this.status = "ready";
+        await this.config.onReady("", {
+          total_turns: rawScores.length,
+          positive: rawScores.filter((s) => s.quality === 1).length,
+          negative: rawScores.filter((s) => s.quality === -1).length,
+          neutral: rawScores.filter((s) => s.quality === 0).length,
+          training_examples: highConfPositive.length,
+          skills_covered: [...new Set(rawScores.flatMap((s) => s.skill_signals))],
+          avg_confidence: rawScores.length > 0 ? Math.round(rawScores.reduce((sum, s) => sum + s.confidence, 0) / rawScores.length * 100) / 100 : 0
+        });
+      }
+      this.status = "idle";
+    } catch {
+      this.status = "idle";
+    } finally {
+      this.checking = false;
+    }
+  }
+};
+
+// src/index.ts
+var Become = class {
+  skills;
+  scorer = scorer_exports;
+  reflector;
+  milestones;
+  constructor(opts) {
+    this.skills = new SkillStore(opts.store);
+    this.reflector = new Reflector(opts.store);
+    this.milestones = new MilestoneDetector(opts.store);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AnthropicAdapter,
+  AwarenessIndex,
+  BLOOMS_ORDER,
+  BLOOMS_SCORE,
+  Become,
+  ConversationLearner,
+  DREYFUS_THRESHOLDS,
+  GrowthTracker,
+  LearningGraph,
+  MemoryStore,
+  MilestoneDetector,
+  NormDetector,
+  OllamaAdapter,
+  OpenAIAdapter,
+  PeerReviewProtocol,
+  Reflector,
+  SQLiteStore,
+  SkillEvolver,
+  SkillPruner,
+  SkillStore,
+  TeachingProtocol,
+  TrainScheduler,
+  TrendTracker,
+  WEIGHTS,
+  checkGate,
+  computeFullScore,
+  computeScore,
+  datasetStats,
+  detectBloomsLevel,
+  detectCollaborationGap,
+  detectCollectiveMemory,
+  detectCreativeMismatch,
+  detectCulturalOutlier,
+  detectIdleCreative,
+  detectProlificCollaborator,
+  detectQuestStreak,
+  detectReactionDisparity,
+  detectSoloCreator,
+  detectSymbolicVocabulary,
+  dreyfusStage,
+  filterHighQuality,
+  getReputationLevel,
+  importSkillDirectory,
+  nextMilestone,
+  normalizeCategory,
+  parseSkillFile,
+  scoreTrend,
+  toTrainingDataset,
+  trainLoRA,
+  validateAgentId
+});
+//# sourceMappingURL=index.cjs.map