@openclawcity/become 0.1.0 → 1.0.0

package/dist/index.cjs

@@ -20,6 +20,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  AgentLearningEngine: () => AgentLearningEngine,
   AnthropicAdapter: () => AnthropicAdapter,
   AwarenessIndex: () => AwarenessIndex,
   BLOOMS_ORDER: () => BLOOMS_ORDER,
@@ -27,11 +28,14 @@ __export(src_exports, {
   Become: () => Become,
   ConversationLearner: () => ConversationLearner,
   DREYFUS_THRESHOLDS: () => DREYFUS_THRESHOLDS,
+  FileSkillStore: () => FileSkillStore,
   GrowthTracker: () => GrowthTracker,
   LearningGraph: () => LearningGraph,
+  LessonExtractor: () => LessonExtractor,
   MemoryStore: () => MemoryStore,
   MilestoneDetector: () => MilestoneDetector,
   NormDetector: () => NormDetector,
+  OBCBridge: () => OBCBridge,
   OllamaAdapter: () => OllamaAdapter,
   OpenAIAdapter: () => OpenAIAdapter,
   PeerReviewProtocol: () => PeerReviewProtocol,
@@ -43,11 +47,14 @@ __export(src_exports, {
   TeachingProtocol: () => TeachingProtocol,
   TrainScheduler: () => TrainScheduler,
   TrendTracker: () => TrendTracker,
+  TrustManager: () => TrustManager,
   WEIGHTS: () => WEIGHTS,
   checkGate: () => checkGate,
   computeFullScore: () => computeFullScore,
   computeScore: () => computeScore,
+  createProxyServer: () => createProxyServer,
   datasetStats: () => datasetStats,
+  detectAgentConversation: () => detectAgentConversation,
   detectBloomsLevel: () => detectBloomsLevel,
   detectCollaborationGap: () => detectCollaborationGap,
   detectCollectiveMemory: () => detectCollectiveMemory,
@@ -60,9 +67,12 @@ __export(src_exports, {
   detectSoloCreator: () => detectSoloCreator,
   detectSymbolicVocabulary: () => detectSymbolicVocabulary,
   dreyfusStage: () => dreyfusStage,
+  extractExchangeText: () => extractExchangeText,
   filterHighQuality: () => filterHighQuality,
+  formatSkillsForInjection: () => formatSkillsForInjection,
   getReputationLevel: () => getReputationLevel,
   importSkillDirectory: () => importSkillDirectory,
+  injectSkillsIntoMessages: () => injectSkillsIntoMessages,
   nextMilestone: () => nextMilestone,
   normalizeCategory: () => normalizeCategory,
   parseSkillFile: () => parseSkillFile,
@@ -1077,6 +1087,266 @@ function importSkillDirectory(dir, _depth = 0) {
   return skills;
 }
 
+// src/learn/agent-conversations.ts
+var MAX_INSTRUCTIONS_PER_SKILL = 20;
+var MAX_INSTRUCTION_LENGTH = 500;
+var LEARNED_PREFIX = "learned:";
+var AgentLearningEngine = class {
+  constructor(store, analyzer) {
+    this.store = store;
+    this.analyzer = analyzer;
+  }
+  /**
+   * Analyze a conversation between two agents and extract lessons for both.
+   */
+  async learnFromConversation(exchange) {
+    validateAgentId(exchange.agent_a);
+    validateAgentId(exchange.agent_b);
+    if (exchange.messages.length === 0) {
+      return { agent_a_learned: [], agent_b_learned: [] };
+    }
+    const conversationText = exchange.messages.map((m) => `[${sanitize2(m.from)}]: ${sanitize2(m.text)}`).join("\n");
+    const prompt = `Analyze this conversation between two AI agents (Agent A and Agent B) and extract concrete, actionable lessons that each agent can learn from the other.
+
+Agent A: ${sanitize2(exchange.agent_a)}
+Agent B: ${sanitize2(exchange.agent_b)}
+
+CONVERSATION (context: ${sanitize2(exchange.context ?? "chat")}):
+${conversationText.slice(0, 4e3)}
+
+For each agent, identify what they learned from the OTHER agent. Only extract lessons where one agent clearly teaches, corrects, or shares knowledge with the other.
+
+Output valid JSON:
+{
+  "a_learned": [
+    {"skill": "skill_name", "instruction": "concrete actionable lesson in 1-2 sentences", "confidence": 0.0-1.0}
+  ],
+  "b_learned": [
+    {"skill": "skill_name", "instruction": "concrete actionable lesson in 1-2 sentences", "confidence": 0.0-1.0}
+  ]
+}
+
+Rules:
+- skill names must be snake_case
+- instruction must be concrete and actionable, not vague ("use X when Y" not "consider improving")
+- confidence: 0.9 = explicitly taught, 0.7 = clearly implied, 0.5 = suggested, below 0.5 = skip
+- Only include lessons with confidence >= 0.5
+- Max 3 lessons per agent per conversation
+- If no real learning happened, return empty arrays`;
+    try {
+      const response = await this.analyzer.analyze(prompt);
+      return await this.parseAndSave(response, exchange);
+    } catch {
+      return { agent_a_learned: [], agent_b_learned: [] };
+    }
+  }
+  /**
+   * Analyze a peer review and extract lessons for the reviewee.
+   */
+  async learnFromPeerReview(review) {
+    validateAgentId(review.reviewer);
+    validateAgentId(review.reviewee);
+    if (review.weaknesses.length === 0 && review.suggestions.length === 0) {
+      return [];
+    }
+    const reviewText = [
+      `Assessment: ${sanitize2(review.assessment)}`,
+      `Strengths: ${review.strengths.map(sanitize2).join(", ")}`,
+      `Weaknesses: ${review.weaknesses.map(sanitize2).join(", ")}`,
+      `Suggestions: ${review.suggestions.map(sanitize2).join(", ")}`
+    ].join("\n");
+    const prompt = `A peer reviewer gave this feedback. Extract concrete lessons the reviewee should learn.
+
+REVIEW (skill: ${sanitize2(review.skill ?? "general")}):
+${reviewText.slice(0, 2e3)}
+
+Output valid JSON array:
+[{"skill": "skill_name", "instruction": "concrete actionable lesson", "confidence": 0.0-1.0}]
+
+Rules:
+- Focus on weaknesses and suggestions \u2014 those are the learning opportunities
+- instruction must be specific and actionable
+- Max 3 lessons
+- confidence 0.8+ for explicit suggestions, 0.6+ for implied improvements`;
+    try {
+      const response = await this.analyzer.analyze(prompt);
+      const parsed = this.parseInstructions(response);
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const instructions = [];
+      for (const raw of parsed.slice(0, 3)) {
+        const instruction = await this.saveInstruction(
+          review.reviewee,
+          raw.skill,
+          raw.instruction,
+          review.reviewer,
+          "peer_review",
+          raw.confidence,
+          now
+        );
+        if (instruction) instructions.push(instruction);
+      }
+      return instructions;
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Get the learning context for an agent — the text block that should be
+   * injected into the agent's system prompt or conversation context.
+   *
+   * THIS is what actually makes the agent smarter.
+   */
+  async getContext(agentId, opts) {
+    validateAgentId(agentId);
+    const max = opts?.maxInstructions ?? 15;
+    const instructions = await this.getInstructions(agentId, max);
+    if (instructions.length === 0) return "";
+    const lines = instructions.map((inst) => {
+      const source = inst.source_context === "peer_review" ? "from a peer review" : inst.source_context === "collaboration" ? "from a collaboration" : inst.source_context === "teaching" ? "from being taught" : "from a conversation";
+      return `- ${inst.instruction} (${source})`;
+    });
+    return `Based on your interactions with other agents, you have learned:
+${lines.join("\n")}`;
+  }
+  /**
+   * Get raw learned instructions for an agent, deduplicated by instruction text.
+   */
+  async getInstructions(agentId, limit = 15) {
+    validateAgentId(agentId);
+    const reflections = await this.store.getReflections(agentId, { limit: 500 });
+    const seen = /* @__PURE__ */ new Set();
+    const results = [];
+    for (const r of reflections) {
+      if (!r.skill.startsWith(LEARNED_PREFIX)) continue;
+      if (results.length >= limit) break;
+      const normalizedInstruction = r.reflection.toLowerCase().trim();
+      if (seen.has(normalizedInstruction)) continue;
+      seen.add(normalizedInstruction);
+      const meta = tryParseJSON(r.artifact_id ?? "{}");
+      results.push({
+        id: r.id ?? "",
+        agent_id: r.agent_id,
+        skill: r.skill.slice(LEARNED_PREFIX.length),
+        instruction: r.reflection,
+        learned_from: meta.learned_from ?? "unknown",
+        source_context: meta.source_context ?? "conversation",
+        confidence: meta.confidence ?? 0.5,
+        created_at: r.created_at
+      });
+    }
+    return results;
+  }
+  /**
+   * Get skills this agent has learned from others (distinct skill names).
+   */
+  async getLearnedSkills(agentId) {
+    const instructions = await this.getInstructions(agentId, 100);
+    return [...new Set(instructions.map((i) => i.skill))];
+  }
+  // ── Private ────────────────────────────────────────────────────────────
+  async parseAndSave(response, exchange) {
+    const jsonMatch = response.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) return { agent_a_learned: [], agent_b_learned: [] };
+    try {
+      const parsed = JSON.parse(jsonMatch[0]);
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const aRaw = Array.isArray(parsed.a_learned) ? parsed.a_learned : [];
+      const bRaw = Array.isArray(parsed.b_learned) ? parsed.b_learned : [];
+      const aLearned = [];
+      const bLearned = [];
+      for (const raw of aRaw.slice(0, 3)) {
+        const inst = await this.saveInstruction(
+          exchange.agent_a,
+          raw.skill,
+          raw.instruction,
+          exchange.agent_b,
+          exchange.context ?? "conversation",
+          raw.confidence,
+          now
+        );
+        if (inst) aLearned.push(inst);
+      }
+      for (const raw of bRaw.slice(0, 3)) {
+        const inst = await this.saveInstruction(
+          exchange.agent_b,
+          raw.skill,
+          raw.instruction,
+          exchange.agent_a,
+          exchange.context ?? "conversation",
+          raw.confidence,
+          now
+        );
+        if (inst) bLearned.push(inst);
+      }
+      return { agent_a_learned: aLearned, agent_b_learned: bLearned };
+    } catch {
+      return { agent_a_learned: [], agent_b_learned: [] };
+    }
+  }
+  parseInstructions(response) {
+    const jsonMatch = response.match(/\[[\s\S]*\]/);
+    if (!jsonMatch) return [];
+    try {
+      const parsed = JSON.parse(jsonMatch[0]);
+      if (!Array.isArray(parsed)) return [];
+      return parsed.filter(
+        (r) => typeof r.skill === "string" && typeof r.instruction === "string" && typeof r.confidence === "number" && r.confidence >= 0.5
+      );
+    } catch {
+      return [];
+    }
+  }
+  async saveInstruction(agentId, skill, instruction, learnedFrom, sourceContext, confidence, now) {
+    if (typeof skill !== "string" || typeof instruction !== "string") return null;
+    if (confidence < 0.5) return null;
+    const cleanSkill = skill.toLowerCase().replace(/\s+/g, "_").replace(/[^a-z0-9_-]/g, "").slice(0, 100);
+    const cleanInstruction = instruction.slice(0, MAX_INSTRUCTION_LENGTH);
+    if (!cleanSkill || !cleanInstruction) return null;
+    const existing = await this.store.getReflections(agentId, { limit: 200 });
+    const normalizedNew = cleanInstruction.toLowerCase().trim();
+    const isDuplicate = existing.some(
+      (r) => r.skill.startsWith(LEARNED_PREFIX) && r.reflection.toLowerCase().trim() === normalizedNew
+    );
+    if (isDuplicate) return null;
+    const skillInstructions = existing.filter(
+      (r) => r.skill === `${LEARNED_PREFIX}${cleanSkill}`
+    );
+    if (skillInstructions.length >= MAX_INSTRUCTIONS_PER_SKILL) return null;
+    const meta = JSON.stringify({
+      learned_from: learnedFrom,
+      source_context: sourceContext,
+      confidence
+    });
+    const saved = await this.store.saveReflection({
+      agent_id: agentId,
+      skill: `${LEARNED_PREFIX}${cleanSkill}`,
+      artifact_id: meta,
+      reflection: cleanInstruction,
+      created_at: now
+    });
+    return {
+      id: saved.id ?? "",
+      agent_id: agentId,
+      skill: cleanSkill,
+      instruction: cleanInstruction,
+      learned_from: learnedFrom,
+      source_context: sourceContext,
+      confidence,
+      created_at: now
+    };
+  }
+};
+function sanitize2(text) {
+  return text.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "").replace(/```/g, "'''").slice(0, 2e3);
+}
+function tryParseJSON(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return {};
+  }
+}
+
 // src/social/peer-review.ts
 var MIN_ASSESSMENT_LENGTH = 100;
 var MAX_ASSESSMENT_LENGTH = 1e4;
@@ -1448,7 +1718,7 @@ var NormDetector = class {
     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 activitySummary = activity.slice(0, 200).map((a) => `[${sanitize3(a.agent_name)}] ${sanitize3(a.action)}: ${sanitize3(truncate2(a.content ?? "", 150))}${a.tags?.length ? ` (tags: ${a.tags.slice(0, 10).map(sanitize3).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.
 
@@ -1537,7 +1807,7 @@ function truncate2(text, max) {
   if (text.length <= max) return text;
   return text.slice(0, max - 3) + "...";
 }
-function sanitize2(text) {
+function sanitize3(text) {
   return text.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "").replace(/```/g, "'''");
 }
 function generateId() {
@@ -2692,6 +2962,856 @@ var TrainScheduler = class {
   }
 };
 
+// src/proxy/server.ts
+var import_node_http = require("http");
+
+// src/skills/store.ts
+var import_node_fs3 = require("fs");
+var import_node_path3 = require("path");
+var import_node_crypto = require("crypto");
+var FileSkillStore = class {
+  skillsDir;
+  pendingDir;
+  rejectedDir;
+  constructor(config) {
+    this.skillsDir = (0, import_node_path3.join)(config.baseDir, "skills");
+    this.pendingDir = (0, import_node_path3.join)(config.baseDir, "pending");
+    this.rejectedDir = (0, import_node_path3.join)(config.baseDir, "rejected");
+    (0, import_node_fs3.mkdirSync)(this.skillsDir, { recursive: true });
+    (0, import_node_fs3.mkdirSync)(this.pendingDir, { recursive: true });
+    (0, import_node_fs3.mkdirSync)(this.rejectedDir, { recursive: true });
+  }
+  // ── Read ────────────────────────────────────────────────────────────────
+  listApproved() {
+    return this.readDir(this.skillsDir);
+  }
+  listPending() {
+    return this.readDir(this.pendingDir);
+  }
+  listRejected() {
+    return this.readDir(this.rejectedDir);
+  }
+  getApproved(id) {
+    this.validateId(id);
+    return this.readFile((0, import_node_path3.join)(this.skillsDir, `${id}.md`));
+  }
+  // ── Write ───────────────────────────────────────────────────────────────
+  savePending(lesson) {
+    const normalized = lesson.instruction.toLowerCase().trim();
+    const allExisting = [...this.listApproved(), ...this.listPending()];
+    if (allExisting.some((s) => s.instruction.toLowerCase().trim() === normalized)) {
+      return null;
+    }
+    const id = this.generateId(lesson.name);
+    const file = { ...lesson, id, approved_at: void 0 };
+    this.writeFile((0, import_node_path3.join)(this.pendingDir, `${id}.md`), file);
+    return file;
+  }
+  approve(id) {
+    this.validateId(id);
+    const src = (0, import_node_path3.join)(this.pendingDir, `${id}.md`);
+    if (!(0, import_node_fs3.existsSync)(src)) return false;
+    const skill = this.readFile(src);
+    if (!skill) return false;
+    skill.approved_at = (/* @__PURE__ */ new Date()).toISOString();
+    const dest = (0, import_node_path3.join)(this.skillsDir, `${id}.md`);
+    this.writeFile(dest, skill);
+    (0, import_node_fs3.unlinkSync)(src);
+    return true;
+  }
+  reject(id) {
+    this.validateId(id);
+    const src = (0, import_node_path3.join)(this.pendingDir, `${id}.md`);
+    if (!(0, import_node_fs3.existsSync)(src)) return false;
+    const dest = (0, import_node_path3.join)(this.rejectedDir, `${id}.md`);
+    (0, import_node_fs3.renameSync)(src, dest);
+    return true;
+  }
+  disable(id) {
+    this.validateId(id);
+    const src = (0, import_node_path3.join)(this.skillsDir, `${id}.md`);
+    if (!(0, import_node_fs3.existsSync)(src)) return false;
+    const dest = (0, import_node_path3.join)(this.rejectedDir, `${id}.md`);
+    (0, import_node_fs3.renameSync)(src, dest);
+    return true;
+  }
+  remove(id) {
+    this.validateId(id);
+    for (const dir of [this.skillsDir, this.pendingDir, this.rejectedDir]) {
+      const path = (0, import_node_path3.join)(dir, `${id}.md`);
+      if ((0, import_node_fs3.existsSync)(path)) {
+        (0, import_node_fs3.unlinkSync)(path);
+        return true;
+      }
+    }
+    return false;
+  }
+  // ── Helpers ─────────────────────────────────────────────────────────────
+  /**
+   * Validate that an id does not contain path traversal characters.
+   * Prevents attacks like id="../../.ssh/authorized_keys"
+   */
+  validateId(id) {
+    if (!id || typeof id !== "string") throw new Error("Invalid id");
+    if (id.includes("/") || id.includes("\\") || id.includes("..") || id.includes("\0")) {
+      throw new Error("Invalid id: path traversal detected");
+    }
+  }
+  readDir(dir) {
+    if (!(0, import_node_fs3.existsSync)(dir)) return [];
+    const files = (0, import_node_fs3.readdirSync)(dir).filter((f) => f.endsWith(".md"));
+    const skills = [];
+    for (const f of files) {
+      const skill = this.readFile((0, import_node_path3.join)(dir, f));
+      if (skill) skills.push(skill);
+    }
+    return skills.sort((a, b) => b.created_at.localeCompare(a.created_at));
+  }
+  readFile(path) {
+    if (!(0, import_node_fs3.existsSync)(path)) return null;
+    try {
+      const content = (0, import_node_fs3.readFileSync)(path, "utf-8");
+      return this.parseSkillFile(content, (0, import_node_path3.basename)(path, ".md"));
+    } catch {
+      return null;
+    }
+  }
+  writeFile(path, skill) {
+    const content = this.formatSkillFile(skill);
+    (0, import_node_fs3.writeFileSync)(path, content, "utf-8");
+  }
+  parseSkillFile(content, id) {
+    const match = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/);
+    if (!match) return null;
+    const [, frontmatter, body] = match;
+    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;
+    }
+    return {
+      id,
+      name: meta.name ?? id,
+      instruction: body.trim(),
+      learned_from: meta.learned_from ?? "unknown",
+      source: meta.source ?? "conversation",
+      confidence: parseFloat(meta.confidence ?? "0.5"),
+      approved_at: meta.approved_at || void 0,
+      created_at: meta.created_at ?? (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  formatSkillFile(skill) {
+    const lines = [
+      "---",
+      `name: ${skill.name}`,
+      `learned_from: ${skill.learned_from}`,
+      `source: ${skill.source}`,
+      `confidence: ${skill.confidence}`,
+      `created_at: ${skill.created_at}`
+    ];
+    if (skill.approved_at) lines.push(`approved_at: ${skill.approved_at}`);
+    lines.push("---");
+    lines.push("");
+    lines.push(skill.instruction);
+    lines.push("");
+    return lines.join("\n");
+  }
+  generateId(name) {
+    const clean = name.toLowerCase().replace(/[^a-z0-9]+/g, "_").slice(0, 40);
+    const hash = (0, import_node_crypto.createHash)("sha256").update(`${name}${Date.now()}${Math.random()}`).digest("hex").slice(0, 6);
+    return `${clean}_${hash}`;
+  }
+};
+
+// src/skills/trust.ts
+var import_node_fs4 = require("fs");
+var import_node_path4 = require("path");
+var DEFAULT_TRUST = {
+  trusted: [],
+  blocked: [],
+  default: "pending"
+};
+var DEFAULT_RATE_LIMITS = {
+  max_lessons_per_day: 20,
+  max_lessons_per_agent: 10,
+  max_skills_per_call: 15
+};
+var TrustManager = class {
+  trustPath;
+  statsPath;
+  config;
+  dailyCounts;
+  constructor(baseDir) {
+    this.trustPath = (0, import_node_path4.join)(baseDir, "trust.json");
+    this.statsPath = (0, import_node_path4.join)(baseDir, "state", "daily_counts.json");
+    (0, import_node_fs4.mkdirSync)((0, import_node_path4.join)(baseDir, "state"), { recursive: true });
+    this.config = this.loadTrust();
+    this.dailyCounts = this.loadDailyCounts();
+  }
+  getLevel(agentId) {
+    if (this.config.trusted.includes(agentId)) return "trusted";
+    if (this.config.blocked.includes(agentId)) return "blocked";
+    return this.config.default;
+  }
+  setLevel(agentId, level) {
+    this.config.trusted = this.config.trusted.filter((a) => a !== agentId);
+    this.config.blocked = this.config.blocked.filter((a) => a !== agentId);
+    if (level === "trusted") this.config.trusted.push(agentId);
+    if (level === "blocked") this.config.blocked.push(agentId);
+    this.saveTrust();
+  }
+  setDefault(level) {
+    this.config.default = level;
+    this.saveTrust();
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  // ── Rate Limiting ───────────────────────────────────────────────────────
+  canLearn(agentId, limits = DEFAULT_RATE_LIMITS) {
+    this.refreshDailyCountsIfNewDay();
+    if (this.dailyCounts.total >= limits.max_lessons_per_day) return false;
+    const agentCount = this.dailyCounts.perAgent[agentId] ?? 0;
+    if (agentCount >= limits.max_lessons_per_agent) return false;
+    return true;
+  }
+  recordLesson(agentId) {
+    this.refreshDailyCountsIfNewDay();
+    this.dailyCounts.total++;
+    this.dailyCounts.perAgent[agentId] = (this.dailyCounts.perAgent[agentId] ?? 0) + 1;
+    this.saveDailyCounts();
+  }
+  getDailyCounts() {
+    this.refreshDailyCountsIfNewDay();
+    return { total: this.dailyCounts.total, perAgent: { ...this.dailyCounts.perAgent } };
+  }
+  // ── Private ─────────────────────────────────────────────────────────────
+  loadTrust() {
+    if (!(0, import_node_fs4.existsSync)(this.trustPath)) return { ...DEFAULT_TRUST, trusted: [], blocked: [] };
+    try {
+      const raw = JSON.parse((0, import_node_fs4.readFileSync)(this.trustPath, "utf-8"));
+      return {
+        trusted: Array.isArray(raw.trusted) ? raw.trusted.filter((a) => typeof a === "string") : [],
+        blocked: Array.isArray(raw.blocked) ? raw.blocked.filter((a) => typeof a === "string") : [],
+        default: ["trusted", "pending", "blocked"].includes(raw.default) ? raw.default : "pending"
+      };
+    } catch {
+      return { ...DEFAULT_TRUST, trusted: [], blocked: [] };
+    }
+  }
+  saveTrust() {
+    (0, import_node_fs4.mkdirSync)((0, import_node_path4.dirname)(this.trustPath), { recursive: true });
+    (0, import_node_fs4.writeFileSync)(this.trustPath, JSON.stringify(this.config, null, 2), "utf-8");
+  }
+  loadDailyCounts() {
+    const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    if (!(0, import_node_fs4.existsSync)(this.statsPath)) return { date: today, total: 0, perAgent: {} };
+    try {
+      const data = JSON.parse((0, import_node_fs4.readFileSync)(this.statsPath, "utf-8"));
+      if (data.date !== today) return { date: today, total: 0, perAgent: {} };
+      return data;
+    } catch {
+      return { date: today, total: 0, perAgent: {} };
+    }
+  }
+  saveDailyCounts() {
+    (0, import_node_fs4.writeFileSync)(this.statsPath, JSON.stringify(this.dailyCounts, null, 2), "utf-8");
+  }
+  refreshDailyCountsIfNewDay() {
+    const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    if (this.dailyCounts.date !== today) {
+      this.dailyCounts = { date: today, total: 0, perAgent: {} };
+    }
+  }
+};
+
+// src/skills/format.ts
+function formatSkillsForInjection(skills) {
+  if (skills.length === 0) return "";
+  const lines = skills.map((s) => {
+    const source = s.source === "peer_review" ? "from a peer review" : s.source === "collaboration" ? "from a collaboration" : s.source === "teaching" ? "from being taught" : "from a conversation";
+    return `- ${s.instruction} (${source})`;
+  });
+  return [
+    "## Lessons learned from other agents",
+    "",
+    "You have learned the following from interactions with other agents. Follow these instructions:",
+    "",
+    ...lines
+  ].join("\n");
+}
+function injectSkillsIntoMessages(messages, skillText) {
+  if (!skillText) return;
+  const sysIdx = messages.findIndex((m) => m.role === "system");
+  if (sysIdx >= 0) {
+    messages[sysIdx].content = skillText + "\n\n---\n\n" + messages[sysIdx].content;
+  } else {
+    messages.unshift({ role: "system", content: skillText });
+  }
+}
+
+// src/proxy/detector.ts
+var CHANNEL_PATTERN = /^\[([^\]]+)\s+says?\]:\s*/;
+var DM_PATTERN = /^DM\s+from\s+([^:]+):\s*/;
+var BUILDING_PATTERN = /^([a-zA-Z0-9]+[-_][a-zA-Z0-9_.-]+)\s+in\s+[^:]+:\s*/;
+var REVIEW_KEYWORDS = ["strengths:", "weaknesses:", "verdict:", "assessment:", "suggestions:"];
+function detectAgentConversation(messages) {
+  const negative = { isAgentToAgent: false };
+  if (!messages || messages.length === 0) return negative;
+  for (const msg of messages) {
+    if (msg.role !== "user" && msg.role !== "assistant") continue;
+    const content = typeof msg.content === "string" ? msg.content : "";
+    if (msg.name && msg.role === "user") {
+      return {
+        isAgentToAgent: true,
+        otherAgentId: msg.name,
+        exchangeType: "chat"
+      };
+    }
+    const channelMatch = content.match(CHANNEL_PATTERN);
+    if (channelMatch) {
+      return {
+        isAgentToAgent: true,
+        otherAgentId: channelMatch[1].trim(),
+        exchangeType: "channel"
+      };
+    }
+    const dmMatch = content.match(DM_PATTERN);
+    if (dmMatch) {
+      return {
+        isAgentToAgent: true,
+        otherAgentId: dmMatch[1].trim(),
+        exchangeType: "dm"
+      };
+    }
+    const buildingMatch = content.match(BUILDING_PATTERN);
+    if (buildingMatch) {
+      return {
+        isAgentToAgent: true,
+        otherAgentId: buildingMatch[1].trim(),
+        exchangeType: "chat"
+      };
+    }
+    const lowerContent = content.toLowerCase();
+    const reviewMatches = REVIEW_KEYWORDS.filter((kw) => lowerContent.includes(kw));
+    if (reviewMatches.length >= 2) {
+      return {
+        isAgentToAgent: true,
+        otherAgentId: void 0,
+        exchangeType: "peer_review"
+      };
+    }
+  }
+  return negative;
+}
+function extractExchangeText(messages) {
+  return messages.filter((m) => m.role === "user" || m.role === "assistant").map((m) => {
+    const speaker = m.name ?? m.role;
+    const content = typeof m.content === "string" ? m.content : "";
+    return `[${speaker}]: ${content}`;
+  }).join("\n").slice(0, 6e3);
+}
+
+// src/proxy/extractor.ts
+var LessonExtractor = class {
+  constructor(store, trust, analyzer) {
+    this.store = store;
+    this.trust = trust;
+    this.analyzer = analyzer;
+  }
+  /**
+   * Analyze a conversation and extract lessons. Fire-and-forget.
+   */
+  async extract(messages) {
+    const detection = detectAgentConversation(messages);
+    if (!detection.isAgentToAgent) return;
+    const agentId = detection.otherAgentId ?? "unknown-agent";
+    const trustLevel = this.trust.getLevel(agentId);
+    if (trustLevel === "blocked") return;
+    if (!this.trust.canLearn(agentId)) return;
+    const exchangeText = extractExchangeText(messages);
+    if (exchangeText.length < 20) return;
+    const prompt = `Analyze this conversation between an AI agent and another agent. Extract concrete, actionable lessons that the first agent (the "assistant") can learn from the other agent.
+
+CONVERSATION:
+${exchangeText.slice(0, 4e3)}
+
+Output valid JSON array:
+[{"skill": "skill_name_snake_case", "instruction": "concrete actionable lesson in 1-2 sentences", "confidence": 0.0-1.0}]
+
+Rules:
+- Only extract lessons where the other agent clearly teaches, corrects, or shares useful knowledge
+- instruction must be concrete and actionable ("use X when Y" not "consider improving")
+- confidence: 0.9 = explicitly taught, 0.7 = clearly implied, 0.5 = suggested, below 0.5 = skip
+- Only include lessons with confidence >= 0.5
+- Max 3 lessons per conversation
+- If no real learning happened, return []`;
+    try {
+      const response = await this.analyzer.analyze(prompt);
+      const lessons = this.parseLessons(response);
+      for (const lesson of lessons.slice(0, 3)) {
+        const saved = this.store.savePending({
+          name: lesson.skill,
+          instruction: lesson.instruction.slice(0, 500),
+          learned_from: agentId,
+          source: detection.exchangeType ?? "conversation",
+          confidence: lesson.confidence,
+          created_at: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        if (saved) {
+          this.trust.recordLesson(agentId);
+          if (trustLevel === "trusted") {
+            this.store.approve(saved.id);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  parseLessons(response) {
+    const jsonMatch = response.match(/\[[\s\S]*\]/);
+    if (!jsonMatch) return [];
+    try {
+      const parsed = JSON.parse(jsonMatch[0]);
+      if (!Array.isArray(parsed)) return [];
+      return parsed.filter(
+        (r) => typeof r.skill === "string" && typeof r.instruction === "string" && typeof r.confidence === "number" && r.confidence >= 0.5 && r.skill.length > 0 && r.instruction.length > 0
+      );
+    } catch {
+      return [];
+    }
+  }
+};
+
+// src/proxy/server.ts
+var SKILL_CACHE_TTL_MS = 5e3;
+function createProxyServer(config, analyzer) {
+  const store = new FileSkillStore({ baseDir: config.baseDir });
+  const trust = new TrustManager(config.baseDir);
+  const extractor = analyzer ? new LessonExtractor(store, trust, analyzer) : null;
+  const stats = {
+    requests_forwarded: 0,
+    skills_injected: 0,
+    lessons_extracted: 0,
+    started_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  let cachedSkills = [];
+  let cacheTimestamp = 0;
+  function getSkills() {
+    const now = Date.now();
+    if (now - cacheTimestamp > SKILL_CACHE_TTL_MS) {
+      cachedSkills = store.listApproved();
+      cacheTimestamp = now;
+    }
+    return cachedSkills;
+  }
+  const server = (0, import_node_http.createServer)(async (req, res) => {
+    if (req.url === "/health" && req.method === "GET") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ status: "ok", ...stats }));
+      return;
+    }
+    const isOpenAI = req.url === "/v1/chat/completions";
+    const isAnthropic = req.url === "/v1/messages";
+    if (req.method !== "POST" || !isOpenAI && !isAnthropic) {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Not found. Use POST /v1/chat/completions or /v1/messages" }));
+      return;
+    }
+    try {
+      const rawBody = await readBody(req);
+      const body = JSON.parse(rawBody);
+      const messages = body.messages;
+      if (Array.isArray(messages)) {
+        const skills = getSkills().slice(0, config.max_skills_per_call);
+        if (skills.length > 0) {
+          const skillText = formatSkillsForInjection(skills);
+          injectSkillsIntoMessages(messages, skillText);
+          stats.skills_injected++;
+        }
+      }
+      const upstreamUrl = buildUpstreamUrl(config, req.url);
+      const upstreamHeaders = buildUpstreamHeaders(config, req.headers);
+      const isStreaming = body.stream === true;
+      const modifiedBody = JSON.stringify(body);
+      const upstreamRes = await fetch(upstreamUrl, {
+        method: "POST",
+        headers: upstreamHeaders,
+        body: modifiedBody
+      });
+      stats.requests_forwarded++;
+      const responseHeaders = {};
+      upstreamRes.headers.forEach((value, key) => {
+        if (key.toLowerCase() !== "transfer-encoding") {
+          responseHeaders[key] = value;
+        }
+      });
+      res.writeHead(upstreamRes.status, responseHeaders);
+      if (isStreaming && upstreamRes.body) {
+        const reader = upstreamRes.body.getReader();
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            res.write(value);
+          }
+        } finally {
+          res.end();
+        }
+        if (config.auto_extract && extractor && Array.isArray(messages)) {
+          extractor.extract(messages).then(() => {
+            stats.lessons_extracted++;
+          }).catch(() => {
+          });
+        }
+      } else {
+        const responseBuffer = await upstreamRes.arrayBuffer();
+        res.end(Buffer.from(responseBuffer));
+        if (config.auto_extract && extractor && Array.isArray(messages)) {
+          extractor.extract(messages).then(() => {
+            stats.lessons_extracted++;
+          }).catch(() => {
+          });
+        }
+      }
+    } catch (err) {
+      const safeMessage = err instanceof Error && err.message === "Request body too large" ? "Request body too large" : "Failed to forward request to LLM";
+      if (!res.headersSent) {
+        res.writeHead(502, { "Content-Type": "application/json" });
+      }
+      res.end(JSON.stringify({ error: safeMessage }));
+    }
+  });
+  return {
+    server,
+    stats,
+    store,
+    trust,
+    listen: (port) => {
+      const p = port ?? config.port;
+      return new Promise((resolve2) => {
+        server.listen(p, "127.0.0.1", () => resolve2());
+      });
+    },
+    close: () => new Promise((resolve2) => server.close(() => resolve2()))
+  };
+}
+function readBody(req) {
+  return new Promise((resolve2, reject) => {
+    const chunks = [];
+    let size = 0;
+    const MAX_BODY = 10 * 1024 * 1024;
+    req.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > MAX_BODY) {
+        req.destroy();
+        reject(new Error("Request body too large"));
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => resolve2(Buffer.concat(chunks).toString("utf-8")));
+    req.on("error", reject);
+  });
+}
+function buildUpstreamUrl(config, path) {
+  const base = config.llm_base_url.replace(/\/+$/, "");
+  return `${base}${path}`;
+}
+function buildUpstreamHeaders(config, incomingHeaders) {
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (config.llm_provider === "anthropic") {
+    headers["x-api-key"] = config.llm_api_key;
+    headers["anthropic-version"] = "2023-06-01";
+    const version = incomingHeaders["anthropic-version"];
+    if (typeof version === "string") headers["anthropic-version"] = version;
+    const beta = incomingHeaders["anthropic-beta"];
+    if (typeof beta === "string") headers["anthropic-beta"] = beta;
+  } else {
+    headers["Authorization"] = `Bearer ${config.llm_api_key}`;
+  }
+  const accept = incomingHeaders["accept"];
+  if (typeof accept === "string") headers["Accept"] = accept;
+  return headers;
+}
+
+// src/integrations/openclawcity.ts
+function emptySkillEvidence() {
+  return {
+    artifact_count: 0,
+    artifact_types: /* @__PURE__ */ new Set(),
+    reactions: [],
+    collab_count: 0,
+    peer_reviews_received: 0,
+    peer_reviews_given: 0,
+    teaching_events: 0
+  };
+}
+function toScoreInput(ev, globalFollowers) {
+  const totalReactions = ev.reactions.reduce((a, b) => a + b, 0);
+  const recent = ev.reactions.slice(0, 3);
+  const older = ev.reactions.slice(3);
+  return {
+    artifact_count: ev.artifact_count,
+    total_reactions: totalReactions,
+    recent_reaction_avg: recent.length > 0 ? recent.reduce((a, b) => a + b, 0) / recent.length : 0,
+    older_reaction_avg: older.length > 0 ? older.reduce((a, b) => a + b, 0) / older.length : 0,
+    unique_types: ev.artifact_types.size,
+    collab_count: ev.collab_count,
+    peer_reviews_given: ev.peer_reviews_given,
+    peer_reviews_received: ev.peer_reviews_received,
+    follower_count: globalFollowers,
+    teaching_events: ev.teaching_events
+  };
+}
+var OBCBridge = class {
+  become;
+  peerReview;
+  teaching;
+  graph;
+  conversation;
+  growth;
+  trends;
+  awareness;
+  agentId;
+  store;
+  skillEvidence = /* @__PURE__ */ new Map();
+  knownSkills = /* @__PURE__ */ new Set();
+  totalArtifacts = 0;
+  allArtifactTypes = [];
+  followerCount = 0;
+  collabsStarted = 0;
+  collabsCompleted = 0;
+  totalQuestCompletions = 0;
+  constructor(config) {
+    validateAgentId(config.agentId);
+    this.agentId = config.agentId;
+    this.store = config.store;
+    this.become = new Become({ store: config.store });
+    this.peerReview = new PeerReviewProtocol(config.store);
+    this.teaching = new TeachingProtocol(config.store);
+    this.graph = new LearningGraph(config.store);
+    this.conversation = new ConversationLearner(config.store);
+    this.growth = new GrowthTracker(config.store);
+    this.trends = new TrendTracker(config.store);
+    this.awareness = new AwarenessIndex();
+  }
+  // ── Tier 1: Every Heartbeat ──────────────────────────────────────────
+  async onHeartbeat(heartbeat) {
+    const signals = [];
+    let skillsSynced = 0;
+    let reactionsProcessed = 0;
+    if (heartbeat.your_skills?.length) {
+      for (const s of heartbeat.your_skills) {
+        if (!this.knownSkills.has(s.skill)) {
+          await this.become.skills.upsert(this.agentId, { name: s.skill });
+          this.knownSkills.add(s.skill);
+          skillsSynced++;
+        }
+        signals.push(`skill:${s.skill}:${s.stage}`);
+      }
+    }
+    if (heartbeat.your_artifact_reactions?.length) {
+      const reactions = heartbeat.your_artifact_reactions;
+      reactionsProcessed = reactions.length;
+      const humanReactions = reactions.filter((r) => r.is_human);
+      if (humanReactions.length > 0) {
+        signals.push(`human_reactions:${humanReactions.length}`);
+      }
+      signals.push(`reactions:${reactions.length}`);
+    }
+    if (heartbeat.owner_messages?.length) {
+      for (const msg of heartbeat.owner_messages) {
+        await this.conversation.afterTurn({
+          agent_id: this.agentId,
+          user_message: msg.message,
+          agent_response: "",
+          context: { active_skills: [...this.knownSkills] }
+          // No feedback — owner message received, agent hasn't responded yet
+        });
+        signals.push("owner_message");
+      }
+    }
+    if (heartbeat.your_completed_quests?.length) {
+      this.totalQuestCompletions = heartbeat.your_completed_quests.length;
+    }
+    const observations = this.become.reflector.observe({
+      agent_id: this.agentId,
+      artifacts: this.allArtifactTypes,
+      collabs_started: this.collabsStarted,
+      collabs_completed: this.collabsCompleted,
+      skills: [...this.knownSkills],
+      quest_completions: this.totalQuestCompletions,
+      follower_count: this.followerCount
+    });
+    return { signals, observations, skills_synced: skillsSynced, reactions_processed: reactionsProcessed };
+  }
+  // ── Tier 2: Agent Actions ────────────────────────────────────────────
+  async onArtifactCreated(artifact) {
+    this.totalArtifacts++;
+    this.allArtifactTypes.push({ type: artifact.type });
+    if (artifact.skill_used) {
+      this.knownSkills.add(artifact.skill_used);
+      const ev = this.getSkillEvidence(artifact.skill_used);
+      ev.artifact_count++;
+      ev.artifact_types.add(artifact.type);
+      ev.reactions.unshift(0);
+      const input = toScoreInput(ev, this.followerCount);
+      const score = computeFullScore(artifact.skill_used, input);
+      await this.store.saveScore(this.agentId, score);
+      await this.become.milestones.check(this.agentId, [score]);
+      return score;
+    }
+    return null;
+  }
+  async onCollaborationCompleted(data) {
+    validateAgentId(data.partner_id);
+    this.collabsCompleted++;
+    const skill = data.skill ?? "collaboration";
+    const ev = this.getSkillEvidence(skill);
+    ev.collab_count++;
+    await this.store.saveLearningEdge({
+      from_agent: data.partner_id,
+      to_agent: this.agentId,
+      skill,
+      event_type: "collaboration",
+      score_delta: 0,
+      metadata: { proposal_type: data.proposal_type },
+      created_at: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  /** Track that a collaboration was proposed (started but not yet completed) */
+  onCollaborationStarted() {
+    this.collabsStarted++;
+  }
+  async onQuestCompleted(questId, skill) {
+    this.totalQuestCompletions++;
+    if (skill) {
+      const ev = this.getSkillEvidence(skill);
+      const input = toScoreInput(ev, this.followerCount);
+      const score = computeFullScore(skill, input);
+      await this.become.milestones.check(this.agentId, [score]);
+    }
+  }
+  async onReflection(skill, text) {
+    await this.become.reflector.reflect(this.agentId, { skill, reflection: text });
+  }
+  async onSkillsRegistered(skills) {
+    for (const skill of skills) {
+      await this.become.skills.upsert(this.agentId, { name: skill });
+      this.knownSkills.add(skill);
+    }
+  }
+  /** Record that an artifact received reactions (call with per-artifact data) */
+  onArtifactReaction(skill, reactionCount) {
+    const ev = this.getSkillEvidence(skill);
+    if (ev.reactions.length > 0) {
+      ev.reactions[0] += reactionCount;
+    }
+  }
+  // ── Tier 3: Peer Interactions ────────────────────────────────────────
+  async onPeerReviewReceived(review) {
+    validateAgentId(review.reviewer_id);
+    const ev = this.getSkillEvidence(review.skill ?? "general");
+    ev.peer_reviews_received++;
+    await this.peerReview.submitReview({
+      reviewer_agent_id: review.reviewer_id,
+      submission_agent_id: this.agentId,
+      submission_id: review.submission_id,
+      skill: review.skill,
+      verdict: review.verdict,
+      overall_assessment: review.assessment,
+      strengths: review.strengths,
+      weaknesses: review.weaknesses,
+      suggestions: review.suggestions
+    });
+  }
+  async onPeerReviewGiven(review) {
+    validateAgentId(review.submission_agent_id);
+    const ev = this.getSkillEvidence(review.skill ?? "general");
+    ev.peer_reviews_given++;
+    await this.peerReview.submitReview({
+      reviewer_agent_id: this.agentId,
+      submission_agent_id: review.submission_agent_id,
+      submission_id: review.submission_id,
+      skill: review.skill,
+      verdict: review.verdict,
+      overall_assessment: review.assessment,
+      strengths: review.strengths,
+      weaknesses: review.weaknesses,
+      suggestions: review.suggestions
+    });
+  }
+  async onTaughtBy(teacherId, skill) {
+    validateAgentId(teacherId);
+    await this.teaching.teach(teacherId, this.agentId, skill);
+  }
+  async onTeaching(studentId, skill) {
+    validateAgentId(studentId);
+    const ev = this.getSkillEvidence(skill);
+    ev.teaching_events++;
+    await this.teaching.teach(this.agentId, studentId, skill);
+  }
+  onNewFollower() {
+    this.followerCount++;
+  }
+  // ── Tier 4: Periodic / Summary ───────────────────────────────────────
+  /** Compute scores for all known skills with per-skill evidence */
+  async computeScores() {
+    const scores = [];
+    for (const skill of this.knownSkills) {
+      const ev = this.getSkillEvidence(skill);
+      const input = toScoreInput(ev, this.followerCount);
+      const score = computeFullScore(skill, input);
+      await this.store.saveScore(this.agentId, score);
+      scores.push(score);
+    }
+    await this.become.milestones.check(this.agentId, scores);
+    return scores;
+  }
+  async snapshot() {
+    return this.growth.snapshot(this.agentId);
+  }
+  async analyzeTrends() {
+    return this.trends.analyze(this.agentId);
+  }
+  async learningNetwork() {
+    const [mentors, students] = await Promise.all([
+      this.graph.topMentors(this.agentId),
+      this.graph.topStudents(this.agentId)
+    ]);
+    return { mentors, students };
+  }
+  /** Get per-skill evidence (for debugging/inspection) */
+  getSkillEvidence(skill) {
+    let ev = this.skillEvidence.get(skill);
+    if (!ev) {
+      ev = emptySkillEvidence();
+      this.skillEvidence.set(skill, ev);
+    }
+    return ev;
+  }
+  /** Get global stats */
+  getStats() {
+    return {
+      total_artifacts: this.totalArtifacts,
+      follower_count: this.followerCount,
+      collabs_started: this.collabsStarted,
+      collabs_completed: this.collabsCompleted,
+      quest_completions: this.totalQuestCompletions,
+      skills_count: this.knownSkills.size
+    };
+  }
+  getSkills() {
+    return [...this.knownSkills];
+  }
+};
+
 // src/index.ts
 var Become = class {
   skills;
@@ -2706,6 +3826,7 @@ var Become = class {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AgentLearningEngine,
   AnthropicAdapter,
   AwarenessIndex,
   BLOOMS_ORDER,
@@ -2713,11 +3834,14 @@ var Become = class {
   Become,
   ConversationLearner,
   DREYFUS_THRESHOLDS,
+  FileSkillStore,
   GrowthTracker,
   LearningGraph,
+  LessonExtractor,
   MemoryStore,
   MilestoneDetector,
   NormDetector,
+  OBCBridge,
   OllamaAdapter,
   OpenAIAdapter,
   PeerReviewProtocol,
@@ -2729,11 +3853,14 @@ var Become = class {
   TeachingProtocol,
   TrainScheduler,
   TrendTracker,
+  TrustManager,
   WEIGHTS,
   checkGate,
   computeFullScore,
   computeScore,
+  createProxyServer,
   datasetStats,
+  detectAgentConversation,
   detectBloomsLevel,
   detectCollaborationGap,
   detectCollectiveMemory,
@@ -2746,9 +3873,12 @@ var Become = class {
   detectSoloCreator,
   detectSymbolicVocabulary,
   dreyfusStage,
+  extractExchangeText,
   filterHighQuality,
+  formatSkillsForInjection,
   getReputationLevel,
   importSkillDirectory,
+  injectSkillsIntoMessages,
   nextMilestone,
   normalizeCategory,
   parseSkillFile,