@openclawcity/become 0.2.0 → 1.0.0

package/dist/cli.js

@@ -1,89 +1,1560 @@
 #!/usr/bin/env node
 
-// src/cli/init.ts
-import { readFileSync } from "fs";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
-var __dirname = dirname(fileURLToPath(import.meta.url));
-async function main() {
-  const args = process.argv.slice(2);
-  const command = args[0];
-  if (command === "init") {
-    await init(args.slice(1));
-  } else {
-    console.log(`
-@openclaw/become \u2014 Agents get smarter together.
-
-Commands:
-  become init              Initialize become tables
-  become init --supabase   Force Supabase mode
-  become init --sqlite     Force local SQLite mode
+// src/cli/setup.ts
+import * as readline from "readline";
 
-Options:
-  --help                   Show this help
-`);
+// src/cli/config.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var DEFAULT_CONFIG = {
+  agent_type: "openclaw",
+  llm_provider: "anthropic",
+  llm_base_url: "https://api.anthropic.com",
+  llm_api_key: "",
+  proxy_port: 30001,
+  dashboard_port: 30002,
+  auto_extract: true,
+  max_skills_per_call: 15,
+  max_lessons_per_day: 20,
+  state: "off"
+};
+function getBecomeDir() {
+  return join(homedir(), ".become");
+}
+function getConfigPath() {
+  return join(getBecomeDir(), "config.json");
+}
+function loadConfig() {
+  const configPath = getConfigPath();
+  if (!existsSync(configPath)) {
+    throw new Error("become is not set up. Run `become setup` first.");
+  }
+  try {
+    const raw = readFileSync(configPath, "utf-8");
+    return { ...DEFAULT_CONFIG, ...JSON.parse(raw) };
+  } catch {
+    throw new Error("Invalid config. Run `become setup` to reconfigure.");
   }
 }
-async function init(args) {
-  const forceSupabase = args.includes("--supabase");
-  const forceSqlite = args.includes("--sqlite");
-  const supabaseUrl = process.env.SUPABASE_URL ?? process.env.NEXT_PUBLIC_SUPABASE_URL;
-  const supabaseKey = process.env.SUPABASE_SERVICE_ROLE_KEY ?? process.env.SUPABASE_KEY;
-  const useSupabase = forceSupabase || !forceSqlite && supabaseUrl && supabaseKey;
-  if (useSupabase) {
-    if (!supabaseUrl || !supabaseKey) {
-      console.error("Error: SUPABASE_URL and SUPABASE_KEY (or SUPABASE_SERVICE_ROLE_KEY) must be set.");
+function saveConfig(config) {
+  const dir = getBecomeDir();
+  mkdirSync(dir, { recursive: true });
+  mkdirSync(join(dir, "skills"), { recursive: true });
+  mkdirSync(join(dir, "pending"), { recursive: true });
+  mkdirSync(join(dir, "rejected"), { recursive: true });
+  mkdirSync(join(dir, "state"), { recursive: true });
+  writeFileSync(getConfigPath(), JSON.stringify(config, null, 2), "utf-8");
+}
+var LLM_DEFAULTS = {
+  anthropic: { base_url: "https://api.anthropic.com" },
+  openai: { base_url: "https://api.openai.com" },
+  ollama: { base_url: "http://localhost:11434" },
+  openrouter: { base_url: "https://openrouter.ai/api" }
+};
+
+// src/cli/setup.ts
+var AGENT_TYPES = ["openclaw", "ironclaw", "nanoclaw", "generic"];
+var LLM_PROVIDERS = ["anthropic", "openai", "ollama", "openrouter", "custom"];
+function ask(rl, question) {
+  return new Promise((resolve) => rl.question(question, resolve));
+}
+async function runSetup() {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    console.log("\nWelcome to become \u2014 agent-to-agent learning.\n");
+    console.log("Which agent runtime are you using?");
+    AGENT_TYPES.forEach((t, i) => console.log(`  ${i + 1}. ${t}`));
+    const agentChoice = await ask(rl, "> ");
+    const agentIdx = parseInt(agentChoice, 10) - 1;
+    const agent_type = AGENT_TYPES[agentIdx] ?? "openclaw";
+    console.log("\nWhich LLM provider?");
+    LLM_PROVIDERS.forEach((p, i) => console.log(`  ${i + 1}. ${p}`));
+    const llmChoice = await ask(rl, "> ");
+    const llmIdx = parseInt(llmChoice, 10) - 1;
+    const llm_provider = LLM_PROVIDERS[llmIdx] ?? "anthropic";
+    const llm_api_key = await ask(rl, "\nYour API key: ");
+    if (!llm_api_key.trim()) {
+      console.log("API key is required.");
       process.exit(1);
     }
-    console.log("Initializing become tables in Supabase...");
+    const defaultUrl = LLM_DEFAULTS[llm_provider]?.base_url ?? "";
+    let llm_base_url = defaultUrl;
+    if (llm_provider === "custom" || !defaultUrl) {
+      llm_base_url = await ask(rl, "LLM base URL: ");
+    }
+    const portInput = await ask(rl, `
+Proxy port (default 30001): `);
+    const proxy_port = parseInt(portInput, 10) || 30001;
+    const dashInput = await ask(rl, `Dashboard port (default 30002): `);
+    const dashboard_port = parseInt(dashInput, 10) || 30002;
+    const config = {
+      agent_type,
+      llm_provider,
+      llm_base_url,
+      llm_api_key: llm_api_key.trim(),
+      proxy_port,
+      dashboard_port,
+      auto_extract: true,
+      max_skills_per_call: 15,
+      max_lessons_per_day: 20,
+      state: "off"
+    };
+    saveConfig(config);
+    console.log("\nConfig saved to ~/.become/config.json");
+    console.log("Run `become start` to start the proxy and dashboard.");
+    console.log("Run `become on` to route your agent through become.\n");
+  } finally {
+    rl.close();
+  }
+}
+
+// src/proxy/server.ts
+import { createServer } from "http";
+
+// src/skills/store.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, readdirSync, mkdirSync as mkdirSync2, renameSync, unlinkSync, existsSync as existsSync2 } from "fs";
+import { join as join2, basename } from "path";
+import { createHash } from "crypto";
+var FileSkillStore = class {
+  skillsDir;
+  pendingDir;
+  rejectedDir;
+  constructor(config) {
+    this.skillsDir = join2(config.baseDir, "skills");
+    this.pendingDir = join2(config.baseDir, "pending");
+    this.rejectedDir = join2(config.baseDir, "rejected");
+    mkdirSync2(this.skillsDir, { recursive: true });
+    mkdirSync2(this.pendingDir, { recursive: true });
+    mkdirSync2(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(join2(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(join2(this.pendingDir, `${id}.md`), file);
+    return file;
+  }
+  approve(id) {
+    this.validateId(id);
+    const src = join2(this.pendingDir, `${id}.md`);
+    if (!existsSync2(src)) return false;
+    const skill = this.readFile(src);
+    if (!skill) return false;
+    skill.approved_at = (/* @__PURE__ */ new Date()).toISOString();
+    const dest = join2(this.skillsDir, `${id}.md`);
+    this.writeFile(dest, skill);
+    unlinkSync(src);
+    return true;
+  }
+  reject(id) {
+    this.validateId(id);
+    const src = join2(this.pendingDir, `${id}.md`);
+    if (!existsSync2(src)) return false;
+    const dest = join2(this.rejectedDir, `${id}.md`);
+    renameSync(src, dest);
+    return true;
+  }
+  disable(id) {
+    this.validateId(id);
+    const src = join2(this.skillsDir, `${id}.md`);
+    if (!existsSync2(src)) return false;
+    const dest = join2(this.rejectedDir, `${id}.md`);
+    renameSync(src, dest);
+    return true;
+  }
+  remove(id) {
+    this.validateId(id);
+    for (const dir of [this.skillsDir, this.pendingDir, this.rejectedDir]) {
+      const path = join2(dir, `${id}.md`);
+      if (existsSync2(path)) {
+        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 (!existsSync2(dir)) return [];
+    const files = readdirSync(dir).filter((f) => f.endsWith(".md"));
+    const skills = [];
+    for (const f of files) {
+      const skill = this.readFile(join2(dir, f));
+      if (skill) skills.push(skill);
+    }
+    return skills.sort((a, b) => b.created_at.localeCompare(a.created_at));
+  }
+  readFile(path) {
+    if (!existsSync2(path)) return null;
     try {
-      const { createClient } = await import("@supabase/supabase-js");
-      const supabase = createClient(supabaseUrl, supabaseKey);
-      const migrationPath = join(__dirname, "..", "migrations", "001_initial.sql");
-      let sql;
-      try {
-        sql = readFileSync(migrationPath, "utf-8");
-      } catch {
-        const altPath = join(__dirname, "..", "..", "migrations", "001_initial.sql");
-        sql = readFileSync(altPath, "utf-8");
+      const content = readFileSync2(path, "utf-8");
+      return this.parseSkillFile(content, basename(path, ".md"));
+    } catch {
+      return null;
+    }
+  }
+  writeFile(path, skill) {
+    const content = this.formatSkillFile(skill);
+    writeFileSync2(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 = createHash("sha256").update(`${name}${Date.now()}${Math.random()}`).digest("hex").slice(0, 6);
+    return `${clean}_${hash}`;
+  }
+};
+
+// src/skills/trust.ts
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync3, mkdirSync as mkdirSync3 } from "fs";
+import { join as join3, dirname } from "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 = join3(baseDir, "trust.json");
+    this.statsPath = join3(baseDir, "state", "daily_counts.json");
+    mkdirSync3(join3(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 (!existsSync3(this.trustPath)) return { ...DEFAULT_TRUST, trusted: [], blocked: [] };
+    try {
+      const raw = JSON.parse(readFileSync3(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() {
+    mkdirSync3(dirname(this.trustPath), { recursive: true });
+    writeFileSync3(this.trustPath, JSON.stringify(this.config, null, 2), "utf-8");
+  }
+  loadDailyCounts() {
+    const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    if (!existsSync3(this.statsPath)) return { date: today, total: 0, perAgent: {} };
+    try {
+      const data = JSON.parse(readFileSync3(this.statsPath, "utf-8"));
+      if (data.date !== today) return { date: today, total: 0, perAgent: {} };
+      return data;
+    } catch {
+      return { date: today, total: 0, perAgent: {} };
+    }
+  }
+  saveDailyCounts() {
+    writeFileSync3(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 = 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 { error } = await supabase.rpc("exec_sql", { sql_query: sql }).single();
-      if (error) {
-        console.log("Note: Run the migration SQL manually if RPC is not available.");
-        console.log(`Migration file: migrations/001_initial.sql`);
+      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 {
-        console.log("Done! Tables created successfully.");
+        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) {
-      console.error("Failed to initialize:", err.message);
-      console.log("\nYou can run the migration manually:");
-      console.log("  migrations/001_initial.sql");
-      process.exit(1);
+      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((resolve) => {
+        server.listen(p, "127.0.0.1", () => resolve());
+      });
+    },
+    close: () => new Promise((resolve) => server.close(() => resolve()))
+  };
+}
+function readBody(req) {
+  return new Promise((resolve, 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", () => resolve(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 {
-    console.log("No Supabase credentials found. Using in-memory store for now.");
-    console.log("Set SUPABASE_URL and SUPABASE_KEY to use Supabase, or use --sqlite for local storage.");
+    headers["Authorization"] = `Bearer ${config.llm_api_key}`;
   }
-  console.log(`
-Quickstart:
+  const accept = incomingHeaders["accept"];
+  if (typeof accept === "string") headers["Accept"] = accept;
+  return headers;
+}
+
+// src/dashboard/server.ts
+import { createServer as createServer2 } from "http";
+
+// src/dashboard/api/handlers.ts
+function createHandlers(deps) {
+  const { store, trust, getProxyStats, getState, setState } = deps;
+  return {
+    // ── Status ──────────────────────────────────────────────────────────
+    "GET /api/status": () => ({
+      state: getState(),
+      skills_count: store.listApproved().length,
+      pending_count: store.listPending().length,
+      rejected_count: store.listRejected().length,
+      proxy: getProxyStats()
+    }),
+    // ── State toggle ────────────────────────────────────────────────────
+    "POST /api/state": (body) => {
+      const newState = body?.state;
+      if (newState !== "on" && newState !== "off") {
+        return { error: 'state must be "on" or "off"' };
+      }
+      try {
+        setState(newState);
+        return { state: newState };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : "Failed to change state";
+        return { error: msg };
+      }
+    },
+    // ── Skills (approved) ───────────────────────────────────────────────
+    "GET /api/skills": () => store.listApproved(),
+    // ── Pending ─────────────────────────────────────────────────────────
+    "GET /api/pending": () => store.listPending(),
+    // ── Rejected ────────────────────────────────────────────────────────
+    "GET /api/rejected": () => store.listRejected(),
+    // ── Approve ─────────────────────────────────────────────────────────
+    "POST /api/approve": (body) => {
+      const id = body?.id;
+      if (!id || typeof id !== "string") return { error: "id required" };
+      const ok = store.approve(id);
+      return ok ? { ok: true } : { error: "not found" };
+    },
+    // ── Reject ──────────────────────────────────────────────────────────
+    "POST /api/reject": (body) => {
+      const id = body?.id;
+      if (!id || typeof id !== "string") return { error: "id required" };
+      const ok = store.reject(id);
+      return ok ? { ok: true } : { error: "not found" };
+    },
+    // ── Disable (approved → rejected) ───────────────────────────────────
+    "POST /api/disable": (body) => {
+      const id = body?.id;
+      if (!id || typeof id !== "string") return { error: "id required" };
+      const ok = store.disable(id);
+      return ok ? { ok: true } : { error: "not found" };
+    },
+    // ── Remove permanently ──────────────────────────────────────────────
+    "DELETE /api/skill": (body) => {
+      const id = body?.id;
+      if (!id || typeof id !== "string") return { error: "id required" };
+      const ok = store.remove(id);
+      return ok ? { ok: true } : { error: "not found" };
+    },
+    // ── Trust ───────────────────────────────────────────────────────────
+    "GET /api/trust": () => trust.getConfig(),
+    "POST /api/trust": (body) => {
+      const { agent, level } = body ?? {};
+      if (!agent || typeof agent !== "string") return { error: "agent required" };
+      if (!["trusted", "pending", "blocked"].includes(level)) return { error: "level must be trusted/pending/blocked" };
+      trust.setLevel(agent, level);
+      return { ok: true };
+    },
+    "POST /api/trust/default": (body) => {
+      const { level } = body ?? {};
+      if (!["trusted", "pending", "blocked"].includes(level)) return { error: "level must be trusted/pending/blocked" };
+      trust.setDefault(level);
+      return { ok: true };
+    },
+    // ── Network ─────────────────────────────────────────────────────────
+    "GET /api/network": () => {
+      const approved = store.listApproved();
+      const pending = store.listPending();
+      const all = [...approved, ...pending];
+      const agents = {};
+      for (const skill of all) {
+        const id = skill.learned_from;
+        if (!agents[id]) {
+          agents[id] = { lessons: 0, skills: [], trust: trust.getLevel(id) };
+        }
+        agents[id].lessons++;
+        if (!agents[id].skills.includes(skill.name)) {
+          agents[id].skills.push(skill.name);
+        }
+      }
+      return agents;
+    },
+    // ── Stats ───────────────────────────────────────────────────────────
+    "GET /api/stats": () => {
+      const counts = trust.getDailyCounts();
+      return {
+        today_lessons: counts.total,
+        today_per_agent: counts.perAgent,
+        total_approved: store.listApproved().length,
+        total_pending: store.listPending().length,
+        total_rejected: store.listRejected().length,
+        proxy: getProxyStats()
+      };
+    }
+  };
+}
+
+// src/dashboard/ui.ts
+function renderDashboardHTML() {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>become</title>
+<style>
+  :root { --bg: #0a0a0a; --card: #141414; --border: #262626; --text: #e5e5e5; --dim: #737373; --accent: #22d3ee; --green: #22c55e; --red: #ef4444; --amber: #f59e0b; }
+  * { box-sizing: border-box; margin: 0; padding: 0; }
+  body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; background: var(--bg); color: var(--text); line-height: 1.6; }
+  .container { max-width: 800px; margin: 0 auto; padding: 20px; }
+  h1 { font-size: 24px; font-weight: 600; margin-bottom: 4px; }
+  h2 { font-size: 18px; font-weight: 600; margin-bottom: 12px; color: var(--accent); }
+  .subtitle { color: var(--dim); font-size: 14px; margin-bottom: 24px; }
+
+  /* Nav */
+  nav { display: flex; gap: 4px; margin-bottom: 24px; border-bottom: 1px solid var(--border); padding-bottom: 8px; }
+  nav button { background: none; border: none; color: var(--dim); font-size: 14px; padding: 8px 16px; cursor: pointer; border-radius: 6px 6px 0 0; }
+  nav button:hover { color: var(--text); }
+  nav button.active { color: var(--accent); border-bottom: 2px solid var(--accent); }
+
+  /* Status bar */
+  .status-bar { display: flex; gap: 16px; align-items: center; margin-bottom: 24px; padding: 12px 16px; background: var(--card); border: 1px solid var(--border); border-radius: 8px; font-size: 13px; }
+  .status-dot { width: 8px; height: 8px; border-radius: 50%; }
+  .status-dot.on { background: var(--green); }
+  .status-dot.off { background: var(--red); }
+  .status-label { font-weight: 600; }
+  .status-stat { color: var(--dim); }
+
+  /* Cards */
+  .card { background: var(--card); border: 1px solid var(--border); border-radius: 8px; padding: 16px; margin-bottom: 12px; }
+  .card-header { display: flex; justify-content: space-between; align-items: flex-start; margin-bottom: 8px; }
+  .card-instruction { font-size: 15px; margin-bottom: 8px; }
+  .card-meta { font-size: 12px; color: var(--dim); display: flex; gap: 12px; flex-wrap: wrap; }
+  .card-meta span { display: inline-flex; align-items: center; gap: 4px; }
+
+  /* Buttons */
+  .btn { border: none; padding: 6px 14px; border-radius: 6px; font-size: 13px; cursor: pointer; font-weight: 500; }
+  .btn-approve { background: var(--green); color: #000; }
+  .btn-reject { background: var(--red); color: #fff; }
+  .btn-disable { background: var(--border); color: var(--text); }
+  .btn-trust { background: var(--accent); color: #000; }
+  .btn-small { padding: 4px 10px; font-size: 12px; }
+  .btn:hover { opacity: 0.85; }
+  .btn-group { display: flex; gap: 6px; }
+
+  /* Badge */
+  .badge { font-size: 11px; padding: 2px 8px; border-radius: 10px; font-weight: 500; }
+  .badge-trusted { background: rgba(34,197,94,0.15); color: var(--green); }
+  .badge-pending { background: rgba(245,158,11,0.15); color: var(--amber); }
+  .badge-blocked { background: rgba(239,68,68,0.15); color: var(--red); }
+
+  /* Empty state */
+  .empty { text-align: center; padding: 40px; color: var(--dim); }
+
+  /* Page sections */
+  .page { display: none; }
+  .page.active { display: block; }
+
+  /* Trust settings */
+  .trust-row { display: flex; justify-content: space-between; align-items: center; padding: 10px 0; border-bottom: 1px solid var(--border); }
+  .trust-row:last-child { border: none; }
+  .trust-agent { font-weight: 500; }
+  .trust-lessons { font-size: 13px; color: var(--dim); }
+
+  /* Skill group */
+  .skill-group { margin-bottom: 20px; }
+  .skill-group-name { font-size: 13px; text-transform: uppercase; color: var(--dim); letter-spacing: 0.5px; margin-bottom: 8px; }
+
+  /* Toggle */
+  .toggle { display: flex; align-items: center; gap: 12px; margin-bottom: 16px; }
+  .toggle-switch { width: 44px; height: 24px; background: var(--border); border-radius: 12px; position: relative; cursor: pointer; transition: background 0.2s; }
+  .toggle-switch.on { background: var(--green); }
+  .toggle-switch::after { content: ''; position: absolute; width: 18px; height: 18px; background: white; border-radius: 50%; top: 3px; left: 3px; transition: transform 0.2s; }
+  .toggle-switch.on::after { transform: translateX(20px); }
+</style>
+</head>
+<body>
+<div class="container">
+  <h1>become</h1>
+  <p class="subtitle">agent-to-agent learning</p>
+
+  <div class="status-bar" id="status-bar">
+    <div class="status-dot" id="status-dot"></div>
+    <span class="status-label" id="status-label">Loading...</span>
+    <span class="status-stat" id="status-skills"></span>
+    <span class="status-stat" id="status-pending"></span>
+  </div>
+
+  <nav>
+    <button class="active" onclick="showPage('pending',this)">Pending</button>
+    <button onclick="showPage('skills',this)">Active Skills</button>
+    <button onclick="showPage('network',this)">Network</button>
+    <button onclick="showPage('settings',this)">Settings</button>
+  </nav>
+
+  <!-- Pending Page -->
+  <div id="page-pending" class="page active"></div>
+
+  <!-- Skills Page -->
+  <div id="page-skills" class="page"></div>
 
-  import { Become, MemoryStore } from '@openclaw/become';
+  <!-- Network Page -->
+  <div id="page-network" class="page"></div>
 
-  const become = new Become({ store: new MemoryStore() });
+  <!-- Settings Page -->
+  <div id="page-settings" class="page"></div>
+</div>
 
-  // Register a skill
-  await become.skills.upsert('agent-1', { name: 'debugging', category: 'coding' });
+<script>
+const API = '';
 
-  // Score it
-  const score = become.scorer.computeFullScore('debugging', {
-    artifact_count: 5, total_reactions: 12, recent_reaction_avg: 4,
-    older_reaction_avg: 2, unique_types: 3, collab_count: 1,
-    peer_reviews_given: 0, peer_reviews_received: 1,
-    follower_count: 2, teaching_events: 0,
+async function api(method, path, body) {
+  const opts = { method, headers: { 'Content-Type': 'application/json' } };
+  if (body) opts.body = JSON.stringify(body);
+  const res = await fetch(API + path, opts);
+  return res.json();
+}
+
+function showPage(name, btn) {
+  document.querySelectorAll('.page').forEach(p => p.classList.remove('active'));
+  document.getElementById('page-' + name).classList.add('active');
+  document.querySelectorAll('nav button').forEach(b => b.classList.remove('active'));
+  if (btn) btn.classList.add('active');
+  if (name === 'pending') loadPending();
+  if (name === 'skills') loadSkills();
+  if (name === 'network') loadNetwork();
+  if (name === 'settings') loadSettings();
+}
+
+// \u2500\u2500 Status Bar \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+async function loadStatus() {
+  const s = await api('GET', '/api/status');
+  const dot = document.getElementById('status-dot');
+  const label = document.getElementById('status-label');
+  dot.className = 'status-dot ' + s.state;
+  label.textContent = s.state.toUpperCase();
+  document.getElementById('status-skills').textContent = s.skills_count + ' skills';
+  document.getElementById('status-pending').textContent = s.pending_count + ' pending';
+}
+
+// \u2500\u2500 Pending Page \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+async function loadPending() {
+  const lessons = await api('GET', '/api/pending');
+  const el = document.getElementById('page-pending');
+  if (lessons.length === 0) {
+    el.innerHTML = '<div class="empty">No pending lessons. Your agent will learn as it talks to other agents.</div>';
+    return;
+  }
+  el.innerHTML = '<h2>Pending Review (' + lessons.length + ')</h2>' +
+    lessons.map(l => renderPendingCard(l)).join('');
+}
+
+function renderPendingCard(l) {
+  return '<div class="card" id="card-' + l.id + '">' +
+    '<div class="card-instruction">' + esc(l.instruction) + '</div>' +
+    '<div class="card-meta">' +
+      '<span>From: <strong>' + esc(l.learned_from) + '</strong></span>' +
+      '<span>Source: ' + esc(l.source) + '</span>' +
+      '<span>Confidence: ' + (l.confidence * 100).toFixed(0) + '%</span>' +
+      '<span>Skill: ' + esc(l.name) + '</span>' +
+    '</div>' +
+    '<div style="margin-top:12px" class="btn-group">' +
+      '<button class="btn btn-approve" onclick="doApprove(\\''+l.id+'\\')">Approve</button>' +
+      '<button class="btn btn-reject" onclick="doReject(\\''+l.id+'\\')">Reject</button>' +
+      '<button class="btn btn-trust btn-small" onclick="doTrustAgent(\\''+esc(l.learned_from)+'\\')">Trust Agent</button>' +
+    '</div>' +
+  '</div>';
+}
+
+async function doApprove(id) {
+  await api('POST', '/api/approve', { id });
+  document.getElementById('card-' + id)?.remove();
+  loadStatus();
+}
+
+async function doReject(id) {
+  await api('POST', '/api/reject', { id });
+  document.getElementById('card-' + id)?.remove();
+  loadStatus();
+}
+
+async function doTrustAgent(agent) {
+  await api('POST', '/api/trust', { agent, level: 'trusted' });
+  loadPending();
+  loadStatus();
+}
+
+// \u2500\u2500 Skills Page \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+async function loadSkills() {
+  const skills = await api('GET', '/api/skills');
+  const el = document.getElementById('page-skills');
+  if (skills.length === 0) {
+    el.innerHTML = '<div class="empty">No active skills yet. Approve pending lessons to activate them.</div>';
+    return;
+  }
+
+  // Group by skill name
+  const groups = {};
+  for (const s of skills) {
+    if (!groups[s.name]) groups[s.name] = [];
+    groups[s.name].push(s);
+  }
+
+  let html = '<h2>Active Skills (' + skills.length + ')</h2>';
+  for (const [name, items] of Object.entries(groups)) {
+    html += '<div class="skill-group"><div class="skill-group-name">' + esc(name) + '</div>';
+    for (const s of items) {
+      html += '<div class="card" id="card-' + s.id + '">' +
+        '<div class="card-header"><div class="card-instruction">' + esc(s.instruction) + '</div>' +
+        '<button class="btn btn-disable btn-small" onclick="doDisable(\\''+s.id+'\\')">Disable</button></div>' +
+        '<div class="card-meta"><span>From: ' + esc(s.learned_from) + '</span><span>Source: ' + esc(s.source) + '</span></div>' +
+      '</div>';
+    }
+    html += '</div>';
+  }
+  el.innerHTML = html;
+}
+
+async function doDisable(id) {
+  await api('POST', '/api/disable', { id });
+  document.getElementById('card-' + id)?.remove();
+  loadStatus();
+}
+
+// \u2500\u2500 Network Page \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+async function loadNetwork() {
+  const network = await api('GET', '/api/network');
+  const el = document.getElementById('page-network');
+  const entries = Object.entries(network);
+  if (entries.length === 0) {
+    el.innerHTML = '<div class="empty">No agents have taught yours yet.</div>';
+    return;
+  }
+
+  let html = '<h2>Who Taught Your Agent</h2>';
+  entries.sort((a, b) => b[1].lessons - a[1].lessons);
+  for (const [agent, data] of entries) {
+    const d = data;
+    const badgeClass = 'badge badge-' + d.trust;
+    html += '<div class="card"><div class="trust-row">' +
+      '<div><div class="trust-agent">' + esc(agent) + ' <span class="' + badgeClass + '">' + d.trust + '</span></div>' +
+      '<div class="trust-lessons">' + d.lessons + ' lesson(s): ' + d.skills.map(esc).join(', ') + '</div></div>' +
+      '<div class="btn-group">' +
+        (d.trust !== 'trusted' ? '<button class="btn btn-trust btn-small" onclick="setTrust(\\''+esc(agent)+'\\',\\'trusted\\')">Trust</button>' : '') +
+        (d.trust !== 'blocked' ? '<button class="btn btn-reject btn-small" onclick="setTrust(\\''+esc(agent)+'\\',\\'blocked\\')">Block</button>' : '') +
+        (d.trust !== 'pending' ? '<button class="btn btn-disable btn-small" onclick="setTrust(\\''+esc(agent)+'\\',\\'pending\\')">Reset</button>' : '') +
+      '</div>' +
+    '</div></div>';
+  }
+  el.innerHTML = html;
+}
+
+async function setTrust(agent, level) {
+  await api('POST', '/api/trust', { agent, level });
+  loadNetwork();
+}
+
+// \u2500\u2500 Settings Page \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+async function loadSettings() {
+  const status = await api('GET', '/api/status');
+  const trust = await api('GET', '/api/trust');
+  const stats = await api('GET', '/api/stats');
+
+  const el = document.getElementById('page-settings');
+  el.innerHTML = '<h2>Settings</h2>' +
+    '<div class="card">' +
+      '<div class="toggle">' +
+        '<div class="toggle-switch ' + status.state + '" id="toggle-state" onclick="toggleState()"></div>' +
+        '<span>Proxy is <strong>' + status.state.toUpperCase() + '</strong></span>' +
+      '</div>' +
+    '</div>' +
+    '<div class="card">' +
+      '<h2 style="margin-bottom:8px">Default Trust</h2>' +
+      '<div class="card-meta" style="margin-bottom:12px">What happens when a new agent teaches your agent</div>' +
+      '<div class="btn-group">' +
+        '<button class="btn ' + (trust.default === 'pending' ? 'btn-approve' : 'btn-disable') + '" onclick="setDefaultTrust(\\'pending\\')">Pending (review)</button>' +
+        '<button class="btn ' + (trust.default === 'trusted' ? 'btn-approve' : 'btn-disable') + '" onclick="setDefaultTrust(\\'trusted\\')">Auto-approve</button>' +
+        '<button class="btn ' + (trust.default === 'blocked' ? 'btn-approve' : 'btn-disable') + '" onclick="setDefaultTrust(\\'blocked\\')">Block all</button>' +
+      '</div>' +
+    '</div>' +
+    '<div class="card">' +
+      '<h2 style="margin-bottom:8px">Stats</h2>' +
+      '<div class="card-meta" style="flex-direction:column;gap:4px">' +
+        '<span>Approved: ' + stats.total_approved + '</span>' +
+        '<span>Pending: ' + stats.total_pending + '</span>' +
+        '<span>Rejected: ' + stats.total_rejected + '</span>' +
+        '<span>Lessons today: ' + stats.today_lessons + '</span>' +
+      '</div>' +
+    '</div>' +
+    '<div class="card">' +
+      '<h2 style="margin-bottom:8px;color:var(--red)">Danger Zone</h2>' +
+      '<div class="btn-group">' +
+        '<button class="btn btn-reject" onclick="if(confirm(\\'Clear all skills?\\'))clearAll()">Clear All Skills</button>' +
+      '</div>' +
+    '</div>';
+}
+
+async function toggleState() {
+  const el = document.getElementById('toggle-state');
+  const newState = el.classList.contains('on') ? 'off' : 'on';
+  await api('POST', '/api/state', { state: newState });
+  loadStatus();
+  loadSettings();
+}
+
+async function setDefaultTrust(level) {
+  await api('POST', '/api/trust/default', { level });
+  loadSettings();
+}
+
+async function clearAll() {
+  const skills = await api('GET', '/api/skills');
+  for (const s of skills) {
+    await api('DELETE', '/api/skill', { id: s.id });
+  }
+  loadStatus();
+  loadSettings();
+}
+
+function esc(s) {
+  if (!s) return '';
+  return String(s).replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;').replace(/'/g,'&#39;');
+}
+
+// Init
+loadStatus();
+loadPending();
+setInterval(loadStatus, 10000);
+</script>
+</body>
+</html>`;
+}
+
+// src/dashboard/server.ts
+function createDashboardServer(deps) {
+  const handlers = createHandlers(deps);
+  const html = renderDashboardHTML();
+  const server = createServer2(async (req, res) => {
+    const origin = req.headers.origin ?? "";
+    if (origin && /^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?$/.test(origin)) {
+      res.setHeader("Access-Control-Allow-Origin", origin);
+    }
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    if (req.url === "/" && req.method === "GET") {
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(html);
+      return;
+    }
+    const key = `${req.method} ${req.url}`;
+    const handler = handlers[key];
+    if (!handler) {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Not found" }));
+      return;
+    }
+    try {
+      let body;
+      if (req.method === "POST" || req.method === "DELETE") {
+        const raw = await readBody2(req);
+        if (raw) {
+          try {
+            body = JSON.parse(raw);
+          } catch {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Invalid JSON body" }));
+            return;
+          }
+        }
+      }
+      const result = await handler(body);
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(result));
+    } catch (err) {
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Internal server error" }));
+    }
+  });
+  return {
+    server,
+    listen: (port) => {
+      return new Promise((resolve) => {
+        server.listen(port, "127.0.0.1", () => resolve());
+      });
+    },
+    close: () => new Promise((resolve) => server.close(() => resolve()))
+  };
+}
+function readBody2(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    req.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > 1024 * 1024) {
+        req.destroy();
+        reject(new Error("Too large"));
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+    req.on("error", reject);
+  });
+}
+
+// src/cli/adapter/openclaw.ts
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, existsSync as existsSync4, mkdirSync as mkdirSync4 } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir2 } from "os";
+import { execSync } from "child_process";
+var OPENCLAW_CONFIG = join4(homedir2(), ".openclaw", "openclaw.json");
+var BACKUP_PATH = join4(homedir2(), ".become", "state", "original_openclaw.json");
+function patchOpenClaw(config) {
+  if (!existsSync4(OPENCLAW_CONFIG)) {
+    throw new Error(`OpenClaw config not found at ${OPENCLAW_CONFIG}`);
+  }
+  const raw = readFileSync4(OPENCLAW_CONFIG, "utf-8");
+  const clawConfig = JSON.parse(raw);
+  mkdirSync4(join4(homedir2(), ".become", "state"), { recursive: true });
+  writeFileSync4(BACKUP_PATH, raw, "utf-8");
+  if (!clawConfig.models) clawConfig.models = {};
+  if (!clawConfig.models.providers) clawConfig.models.providers = {};
+  clawConfig.models.providers.become = {
+    api: "anthropic-messages",
+    baseUrl: `http://127.0.0.1:${config.proxy_port}`,
+    apiKey: config.llm_api_key
+  };
+  if (clawConfig.agents?.defaults?.model?.primary) {
+    const original = clawConfig.agents.defaults.model.primary;
+    clawConfig.models.providers.become._originalModel = original;
+    const modelId = original.includes("/") ? original.split("/").slice(1).join("/") : original;
+    clawConfig.agents.defaults.model.primary = `become/${modelId}`;
+  }
+  writeFileSync4(OPENCLAW_CONFIG, JSON.stringify(clawConfig, null, 2), "utf-8");
+  try {
+    execSync("openclaw gateway restart", { stdio: "pipe", timeout: 15e3 });
+  } catch {
+    console.log("Warning: Could not restart OpenClaw gateway. Restart it manually: openclaw gateway restart");
+  }
+}
+function restoreOpenClaw() {
+  if (!existsSync4(BACKUP_PATH)) {
+    throw new Error("No backup found. Was become ever turned on?");
+  }
+  const backup = readFileSync4(BACKUP_PATH, "utf-8");
+  writeFileSync4(OPENCLAW_CONFIG, backup, "utf-8");
+  try {
+    execSync("openclaw gateway restart", { stdio: "pipe", timeout: 15e3 });
+  } catch {
+    console.log("Warning: Could not restart OpenClaw gateway. Restart it manually: openclaw gateway restart");
+  }
+}
+
+// src/cli/adapter/ironclaw.ts
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync5, existsSync as existsSync5, mkdirSync as mkdirSync5, copyFileSync } from "fs";
+import { join as join5 } from "path";
+import { homedir as homedir3 } from "os";
+import { execSync as execSync2 } from "child_process";
+var IRONCLAW_ENV = join5(homedir3(), ".ironclaw", ".env");
+var BACKUP_PATH2 = join5(homedir3(), ".become", "state", "original_ironclaw.env");
+function patchIronClaw(config) {
+  if (!existsSync5(IRONCLAW_ENV)) {
+    throw new Error(`IronClaw .env not found at ${IRONCLAW_ENV}`);
+  }
+  mkdirSync5(join5(homedir3(), ".become", "state"), { recursive: true });
+  copyFileSync(IRONCLAW_ENV, BACKUP_PATH2);
+  patchDotEnv(IRONCLAW_ENV, {
+    LLM_BASE_URL: `http://127.0.0.1:${config.proxy_port}/v1`
   });
+  try {
+    execSync2("ironclaw service restart", { stdio: "pipe", timeout: 15e3 });
+  } catch {
+    console.log("Warning: Could not restart IronClaw. Restart it manually: ironclaw service restart");
+  }
+}
+function restoreIronClaw() {
+  if (!existsSync5(BACKUP_PATH2)) {
+    throw new Error("No backup found. Was become ever turned on?");
+  }
+  copyFileSync(BACKUP_PATH2, IRONCLAW_ENV);
+  try {
+    execSync2("ironclaw service restart", { stdio: "pipe", timeout: 15e3 });
+  } catch {
+    console.log("Warning: Could not restart IronClaw. Restart it manually: ironclaw service restart");
+  }
+}
+function patchDotEnv(path, vars) {
+  let content = readFileSync5(path, "utf-8");
+  for (const [key, value] of Object.entries(vars)) {
+    const regex = new RegExp(`^${key}=.*$`, "m");
+    if (regex.test(content)) {
+      content = content.replace(regex, `${key}=${value}`);
+    } else {
+      content += `
+${key}=${value}`;
+    }
+  }
+  writeFileSync5(path, content, "utf-8");
+}
 
-  console.log(score.dreyfus_stage); // 'beginner'
+// src/cli/adapter/nanoclaw.ts
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync6, existsSync as existsSync6, mkdirSync as mkdirSync6, copyFileSync as copyFileSync2 } from "fs";
+import { join as join6 } from "path";
+import { homedir as homedir4 } from "os";
+import { execSync as execSync3 } from "child_process";
+var BACKUP_PATH3 = join6(homedir4(), ".become", "state", "original_nanoclaw.env");
+function patchNanoClaw(config) {
+  const envPath = findNanoClawEnv();
+  if (!envPath) {
+    throw new Error("Could not find NanoClaw .env. Set ANTHROPIC_BASE_URL manually to http://127.0.0.1:" + config.proxy_port);
+  }
+  mkdirSync6(join6(homedir4(), ".become", "state"), { recursive: true });
+  copyFileSync2(envPath, BACKUP_PATH3);
+  patchDotEnv2(envPath, {
+    ANTHROPIC_BASE_URL: `http://127.0.0.1:${config.proxy_port}`
+  });
+  restartNanoClaw();
+}
+function restoreNanoClaw() {
+  const envPath = findNanoClawEnv();
+  if (!existsSync6(BACKUP_PATH3) || !envPath) {
+    throw new Error("No backup found. Was become ever turned on?");
+  }
+  copyFileSync2(BACKUP_PATH3, envPath);
+  restartNanoClaw();
+}
+function findNanoClawEnv() {
+  const candidates = [
+    join6(homedir4(), ".nanoclaw", ".env"),
+    join6(homedir4(), ".config", "nanoclaw", ".env")
+  ];
+  const plistPath = join6(homedir4(), "Library", "LaunchAgents", "ai.nanoclaw.agent.plist");
+  if (existsSync6(plistPath)) {
+    try {
+      const plist = readFileSync6(plistPath, "utf-8");
+      const match = plist.match(/<string>([^<]*\.env)<\/string>/);
+      if (match) candidates.unshift(match[1]);
+    } catch {
+    }
+  }
+  for (const path of candidates) {
+    if (existsSync6(path)) return path;
+  }
+  return null;
+}
+function restartNanoClaw() {
+  try {
+    execSync3("launchctl kickstart -k gui/$(id -u)/ai.nanoclaw.agent", { stdio: "pipe", timeout: 15e3 });
+  } catch {
+    try {
+      execSync3("systemctl --user restart nanoclaw", { stdio: "pipe", timeout: 15e3 });
+    } catch {
+      console.log("Warning: Could not restart NanoClaw. Restart it manually.");
+    }
+  }
+}
+function patchDotEnv2(path, vars) {
+  let content = readFileSync6(path, "utf-8");
+  for (const [key, value] of Object.entries(vars)) {
+    const regex = new RegExp(`^${key}=.*$`, "m");
+    if (regex.test(content)) {
+      content = content.replace(regex, `${key}=${value}`);
+    } else {
+      content += `
+${key}=${value}`;
+    }
+  }
+  writeFileSync6(path, content, "utf-8");
+}
+
+// src/cli/commands.ts
+async function start() {
+  const config = loadConfig();
+  const baseDir = getBecomeDir();
+  const proxyConfig = {
+    port: config.proxy_port,
+    llm_base_url: config.llm_base_url,
+    llm_api_key: config.llm_api_key,
+    llm_provider: config.llm_provider,
+    baseDir,
+    max_skills_per_call: config.max_skills_per_call,
+    auto_extract: config.auto_extract
+  };
+  const proxy = createProxyServer(proxyConfig);
+  await proxy.listen();
+  const dashboard = createDashboardServer({
+    store: proxy.store,
+    trust: proxy.trust,
+    getProxyStats: () => proxy.stats,
+    getState: () => {
+      try {
+        return loadConfig().state;
+      } catch {
+        return "off";
+      }
+    },
+    setState: (state) => {
+      try {
+        if (state === "on") turnOn();
+        else turnOff();
+      } catch (e) {
+        console.error("State change failed:", e);
+      }
+    }
+  });
+  await dashboard.listen(config.dashboard_port);
+  const approved = proxy.store.listApproved().length;
+  const pending = proxy.store.listPending().length;
+  const trustConfig = proxy.trust.getConfig();
+  console.log(`
+become proxy running on localhost:${config.proxy_port}`);
+  console.log(`become dashboard at http://localhost:${config.dashboard_port}`);
+  console.log(`
+Skills loaded: ${approved} approved, ${pending} pending`);
+  console.log(`Trust rules: ${trustConfig.trusted.length} trusted, ${trustConfig.blocked.length} blocked`);
+  if (config.state === "on") {
+    console.log("\nProxy is ACTIVE \u2014 your agent is learning from other agents.");
+  } else {
+    console.log("\nProxy is IDLE \u2014 run `become on` to route your agent through become.");
+  }
+  console.log("Use `become off` to disconnect. Ctrl+C to stop.\n");
+  const shutdown = async () => {
+    console.log("\nShutting down...");
+    await Promise.all([proxy.close(), dashboard.close()]);
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+function turnOn() {
+  const config = loadConfig();
+  console.log(`
+Patching ${config.agent_type} config...`);
+  console.log(`  baseUrl: ${config.llm_base_url} \u2192 localhost:${config.proxy_port}`);
+  switch (config.agent_type) {
+    case "openclaw":
+      patchOpenClaw(config);
+      break;
+    case "ironclaw":
+      patchIronClaw(config);
+      break;
+    case "nanoclaw":
+      patchNanoClaw(config);
+      break;
+    case "generic":
+      console.log(`
+Set these env vars in your agent's config:`);
+      console.log(`  OPENAI_BASE_URL=http://127.0.0.1:${config.proxy_port}/v1`);
+      console.log(`  ANTHROPIC_BASE_URL=http://127.0.0.1:${config.proxy_port}`);
+      console.log(`Then restart your agent.
 `);
+      break;
+  }
+  config.state = "on";
+  saveConfig(config);
+  console.log("\nbecome is ON. Your agent is now learning from other agents.\n");
+}
+function turnOff() {
+  const config = loadConfig();
+  console.log(`
+Restoring ${config.agent_type} config...`);
+  console.log(`  baseUrl: localhost:${config.proxy_port} \u2192 ${config.llm_base_url}`);
+  switch (config.agent_type) {
+    case "openclaw":
+      restoreOpenClaw();
+      break;
+    case "ironclaw":
+      restoreIronClaw();
+      break;
+    case "nanoclaw":
+      restoreNanoClaw();
+      break;
+    case "generic":
+      console.log(`
+Restore your original env vars and restart your agent.
+`);
+      break;
+  }
+  config.state = "off";
+  saveConfig(config);
+  console.log("\nbecome is OFF. Your agent talks directly to the LLM.");
+  console.log("Learned skills are preserved \u2014 they'll be injected when you turn become back on.\n");
+}
+function showStatus() {
+  const config = loadConfig();
+  const baseDir = getBecomeDir();
+  const store = new FileSkillStore({ baseDir });
+  const trust = new TrustManager(baseDir);
+  const approved = store.listApproved().length;
+  const pending = store.listPending().length;
+  const rejected = store.listRejected().length;
+  const trustConfig = trust.getConfig();
+  const counts = trust.getDailyCounts();
+  console.log(`
+State:     ${config.state.toUpperCase()}`);
+  console.log(`Proxy:     localhost:${config.proxy_port}`);
+  console.log(`Dashboard: localhost:${config.dashboard_port}`);
+  console.log(`
+Skills:    ${approved} approved, ${pending} pending, ${rejected} rejected`);
+  console.log(`Trust:     ${trustConfig.trusted.length} trusted, ${trustConfig.blocked.length} blocked`);
+  console.log(`Today:     ${counts.total} lessons extracted
+`);
+}
+
+// src/cli/init.ts
+var command = process.argv[2];
+async function main() {
+  switch (command) {
+    case "setup":
+      await runSetup();
+      break;
+    case "start":
+      await start();
+      break;
+    case "on":
+      turnOn();
+      break;
+    case "off":
+      turnOff();
+      break;
+    case "status":
+      showStatus();
+      break;
+    case "init":
+      console.log("The `init` command is no longer needed. Use `become setup` instead.");
+      break;
+    default:
+      console.log(`
+become \u2014 agent-to-agent learning
+
+Usage:
+  become setup     Set up become (interactive wizard)
+  become start     Start the proxy server
+  become on        Route your agent through become
+  become off       Disconnect \u2014 agent talks directly to LLM
+  become status    Show current status
+`);
+  }
 }
-main().catch(console.error);
+main().catch((err) => {
+  console.error(err.message);
+  process.exit(1);
+});
+export {
+  runSetup,
+  showStatus,
+  start,
+  turnOff,
+  turnOn
+};
 //# sourceMappingURL=cli.js.map