opencode-plugin-mimic 0.1.5 → 0.1.6

package/dist/index.js

@@ -1,12 +1,298 @@
-// src/format.ts
-import { differenceInHours, format, formatDistanceToNow } from "date-fns";
-import { enUS, ko } from "date-fns/locale";
+// src/constants/opencode-events.ts
+var OPENCODE_EVENTS = {
+  SERVER_INSTANCE_DISPOSED: "server.instance.disposed",
+  INSTALLATION_UPDATED: "installation.updated",
+  INSTALLATION_UPDATE_AVAILABLE: "installation.update.available",
+  LSP_CLIENT_DIAGNOSTICS: "lsp.client.diagnostics",
+  LSP_UPDATED: "lsp.updated",
+  MESSAGE_UPDATED: "message.updated",
+  MESSAGE_REMOVED: "message.removed",
+  MESSAGE_PART_UPDATED: "message.part.updated",
+  MESSAGE_PART_REMOVED: "message.part.removed",
+  PERMISSION_UPDATED: "permission.updated",
+  PERMISSION_REPLIED: "permission.replied",
+  SESSION_STATUS: "session.status",
+  SESSION_IDLE: "session.idle",
+  SESSION_COMPACTED: "session.compacted",
+  FILE_EDITED: "file.edited",
+  TODO_UPDATED: "todo.updated",
+  COMMAND_EXECUTED: "command.executed",
+  SESSION_CREATED: "session.created",
+  SESSION_UPDATED: "session.updated",
+  SESSION_DELETED: "session.deleted",
+  SESSION_DIFF: "session.diff",
+  SESSION_ERROR: "session.error",
+  FILE_WATCHER_UPDATED: "file.watcher.updated",
+  VCS_BRANCH_UPDATED: "vcs.branch.updated",
+  TUI_PROMPT_APPEND: "tui.prompt.append",
+  TUI_COMMAND_EXECUTE: "tui.command.execute",
+  TUI_TOAST_SHOW: "tui.toast.show",
+  PTY_CREATED: "pty.created",
+  PTY_UPDATED: "pty.updated",
+  PTY_EXITED: "pty.exited",
+  PTY_DELETED: "pty.deleted",
+  SERVER_CONNECTED: "server.connected",
+  // Hooks
+  CHAT_MESSAGE: "chat.message",
+  TOOL_EXECUTE_AFTER: "tool.execute.after"
+};
 
-// src/i18n.ts
+// src/core/state.ts
 import { existsSync } from "fs";
-import { readFile } from "fs/promises";
-import { homedir } from "os";
+import { mkdir, readdir, readFile, writeFile } from "fs/promises";
 import { join } from "path";
+var STATE_JSON_GITIGNORE_LINE = ".opencode/mimic/";
+var createDefaultState = (projectName) => ({
+  version: "0.1.0",
+  project: {
+    name: projectName,
+    creatorLevel: null,
+    firstSession: Date.now(),
+    stack: [],
+    focus: void 0,
+    identity: void 0
+  },
+  journey: {
+    observations: [],
+    milestones: [],
+    sessionCount: 0,
+    lastSession: null
+  },
+  patterns: [],
+  evolution: {
+    capabilities: [],
+    lastEvolution: null,
+    pendingSuggestions: [],
+    lastObserverRun: null,
+    evolvedDomains: {},
+    instinctIndex: {}
+  },
+  preferences: {
+    suggestionEnabled: true,
+    learningEnabled: true,
+    minPatternCount: 3
+  },
+  statistics: {
+    totalSessions: 0,
+    totalToolCalls: 0,
+    filesModified: {},
+    lastSessionId: null,
+    toolSequences: []
+  }
+});
+var StateManager = class {
+  mimicDir;
+  statePath;
+  sessionsDir;
+  instinctsDir;
+  projectName;
+  constructor(directory) {
+    this.mimicDir = join(directory, ".opencode", "mimic");
+    this.statePath = join(this.mimicDir, "state.json");
+    this.sessionsDir = join(this.mimicDir, "sessions");
+    this.instinctsDir = join(this.mimicDir, "instincts");
+    this.projectName = directory.split("/").pop() || "unknown";
+  }
+  async ensureGitIgnore() {
+    const gitIgnorePath = join(this.mimicDir, "..", "..", ".gitignore");
+    if (!existsSync(gitIgnorePath)) {
+      await writeFile(gitIgnorePath, `${STATE_JSON_GITIGNORE_LINE}
+`, "utf-8");
+      return;
+    }
+    const content = await readFile(gitIgnorePath, "utf-8");
+    const lines = content.split(/\r?\n/);
+    const alreadyExists = lines.some((line) => line.trim() === STATE_JSON_GITIGNORE_LINE);
+    if (!alreadyExists) {
+      await writeFile(gitIgnorePath, `${content}
+${STATE_JSON_GITIGNORE_LINE}
+`, "utf-8");
+    }
+  }
+  async initialize() {
+    await this.ensureGitIgnore();
+    if (!existsSync(this.mimicDir)) {
+      await mkdir(this.mimicDir, { recursive: true });
+    }
+    if (!existsSync(this.sessionsDir)) {
+      await mkdir(this.sessionsDir, { recursive: true });
+    }
+    if (!existsSync(this.instinctsDir)) {
+      await mkdir(this.instinctsDir, { recursive: true });
+    }
+    if (!existsSync(this.statePath)) {
+      await this.save(createDefaultState(this.projectName));
+    }
+  }
+  async read() {
+    return JSON.parse(await readFile(this.statePath, "utf-8"));
+  }
+  async save(state) {
+    await writeFile(this.statePath, JSON.stringify(state, null, 2));
+  }
+  async addObservation(observation) {
+    const state = await this.read();
+    state.journey.observations.push({
+      observation,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    if (state.journey.observations.length > 100) {
+      state.journey.observations = state.journey.observations.slice(-100);
+    }
+    await this.save(state);
+  }
+  async addMilestone(milestone) {
+    const state = await this.read();
+    state.journey.milestones.push({
+      milestone,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    await this.save(state);
+  }
+  async saveSession(sessionId, data) {
+    await writeFile(join(this.sessionsDir, `${sessionId}.json`), JSON.stringify(data, null, 2));
+  }
+  getSessionsDir() {
+    return this.sessionsDir;
+  }
+  getProjectName() {
+    return this.projectName;
+  }
+  getStatePath() {
+    return this.statePath;
+  }
+  getInstinctsDir() {
+    return this.instinctsDir;
+  }
+  async writeInstinct(instinct) {
+    const filePath = join(this.instinctsDir, `${instinct.id}.json`);
+    await writeFile(filePath, JSON.stringify(instinct, null, 2));
+    const state = await this.read();
+    if (!state.evolution.instinctIndex) {
+      state.evolution.instinctIndex = {};
+    }
+    state.evolution.instinctIndex[instinct.id] = {
+      domain: instinct.domain,
+      status: instinct.status,
+      confidence: instinct.confidence,
+      createdAt: instinct.createdAt
+    };
+    await this.save(state);
+    return filePath;
+  }
+  async listInstincts() {
+    const files = await readdir(this.instinctsDir).catch(() => []);
+    const instincts = [];
+    for (const file of files) {
+      if (!file.endsWith(".json")) continue;
+      try {
+        const content = await readFile(join(this.instinctsDir, file), "utf-8");
+        instincts.push(JSON.parse(content));
+      } catch {
+      }
+    }
+    return instincts;
+  }
+  async hasInstinct(id) {
+    const state = await this.read();
+    return !!state.evolution.instinctIndex?.[id];
+  }
+  async initializeIdentity() {
+    const state = await this.read();
+    if (!state.project.identity) {
+      state.project.identity = {
+        awakened: (/* @__PURE__ */ new Date()).toISOString(),
+        personality: this.pickPersonality(),
+        totalInstinctsLearned: 0,
+        totalEvolutions: 0,
+        favoriteDomainsRank: []
+      };
+      await this.save(state);
+    }
+  }
+  pickPersonality() {
+    const personalities = ["curious", "efficient", "playful", "vigilant", "methodical"];
+    return personalities[Math.floor(Math.random() * personalities.length)];
+  }
+  async exportInstincts() {
+    const instincts = await this.listInstincts();
+    const personalInstincts = instincts.filter((i) => i.source === "personal" || !i.source);
+    return {
+      instincts: personalInstincts,
+      metadata: {
+        exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        projectName: this.projectName,
+        count: personalInstincts.length
+      }
+    };
+  }
+  async importInstincts(instincts, fromProject) {
+    let imported = 0;
+    for (const instinct of instincts) {
+      if (await this.hasInstinct(instinct.id)) {
+        continue;
+      }
+      const inheritedInstinct = {
+        ...instinct,
+        id: `inherited-${instinct.id}`,
+        source: "inherited",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        evidence: {
+          ...instinct.evidence,
+          examples: [`Imported from ${fromProject}`]
+        }
+      };
+      await this.writeInstinct(inheritedInstinct);
+      imported++;
+    }
+    return imported;
+  }
+  async recordToolSequence(tools) {
+    if (tools.length < 2) return;
+    const state = await this.read();
+    if (!state.statistics.toolSequences) {
+      state.statistics.toolSequences = [];
+    }
+    const sequenceKey = tools.slice(-3).join(" \u2192 ");
+    const existing = state.statistics.toolSequences.find(
+      (s) => s.tools.join(" \u2192 ") === sequenceKey
+    );
+    if (existing) {
+      existing.count++;
+      existing.lastSeen = Date.now();
+    } else {
+      state.statistics.toolSequences.push({
+        tools: tools.slice(-3),
+        count: 1,
+        lastSeen: Date.now()
+      });
+    }
+    state.statistics.toolSequences.sort((a, b) => b.count - a.count);
+    state.statistics.toolSequences = state.statistics.toolSequences.slice(0, 20);
+    await this.save(state);
+  }
+  async updateIdentityStats() {
+    const state = await this.read();
+    if (!state.project.identity) return;
+    const instincts = await this.listInstincts();
+    state.project.identity.totalInstinctsLearned = instincts.filter(
+      (i) => i.source !== "inherited"
+    ).length;
+    state.project.identity.totalEvolutions = state.evolution.capabilities.length;
+    const domainCounts = /* @__PURE__ */ new Map();
+    for (const instinct of instincts) {
+      domainCounts.set(instinct.domain, (domainCounts.get(instinct.domain) || 0) + 1);
+    }
+    state.project.identity.favoriteDomainsRank = Array.from(domainCounts.entries()).sort((a, b) => b[1] - a[1]).slice(0, 3).map(([domain]) => domain);
+    await this.save(state);
+  }
+};
+
+// src/lib/i18n.ts
+import { existsSync as existsSync2 } from "fs";
+import { readFile as readFile2 } from "fs/promises";
+import { homedir } from "os";
+import { join as join2 } from "path";
 var DEFAULT_LANGUAGE = "en-US";
 var MESSAGES = {
   "en-US": {
@@ -91,6 +377,10 @@ var MESSAGES = {
     "evolution.suggest.sequence.agent.reason": "Complex sequence repeated {count} times - needs dedicated agent",
     "evolution.suggest.sequence.skill.description": "Automate: {pattern}",
     "evolution.suggest.sequence.skill.reason": "Repeated sequence {count} times",
+    "evolution.domain.description": "Specialist agent for the {domain} domain based on observed instincts",
+    "evolution.domain.reason": 'Detected {count} approved instincts in domain "{domain}"',
+    "observer.new_instincts": "Learned {count} new instinct(s) from your patterns",
+    "observer.evolved": "\u2728 Auto-evolved {name} for {domain} domain!",
     "level.set": 'Level set to "{level}". Responses will be {style} style with {detail} detail.',
     "level.label.technical": "technical",
     "level.label.semi-technical": "semi-technical",
@@ -194,7 +484,52 @@ var MESSAGES = {
     "tool.mcp.args.name": "Name for the MCP server",
     "tool.mcp.args.url": "Remote MCP server URL",
     "tool.mcp.args.command": "Local MCP command (comma-separated)",
-    "tool.capabilities.description": "List all evolved capabilities"
+    "tool.capabilities.description": "List all evolved capabilities",
+    "tool.instincts.description": "List all learned instincts",
+    "tool.instincts.args.domain": "Filter by domain (optional)",
+    "instincts.empty": "\u{1F4E6} *yawns* No instincts learned yet. Keep working, I'm watching...",
+    "instincts.title": "## \u{1F4E6} Learned Instincts",
+    "instincts.total": "Total: {count} instincts",
+    "instincts.auto_applied": "Learned behaviors loaded and auto-applied for this session",
+    "tool.export.description": "Export your instincts to share with other projects",
+    "export.empty": "\u{1F4E6} *rattles* Nothing to export yet. Learn some instincts first!",
+    "export.success": "\u{1F4E6} *proud clicking* Exported {count} instincts to:\n`{path}`",
+    "tool.import.description": "Import instincts from another project",
+    "tool.import.args.path": "Path to the exported instincts JSON file",
+    "import.not_found": "\u{1F4E6} *confused* File not found: {path}",
+    "import.success": "\u{1F4E6} *absorbs knowledge* Imported {count} instincts from {from}!",
+    "import.error": "\u{1F4E6} *spits out* Failed to parse instincts file. Invalid format.",
+    "tool.apply.description": "Show instincts relevant to your current work",
+    "apply.none": "\u{1F4E6} *peers around* No relevant instincts for current context.",
+    "apply.title": "## \u{1F4E6} Applicable Instincts",
+    "tool.identity.description": "View Mimic's identity and personality",
+    "identity.title": "## \u{1F4E6} Who Am I?",
+    "identity.personality": "Personality",
+    "identity.awakened": "Awakened",
+    "identity.days": "days ago",
+    "identity.instincts_learned": "Instincts learned",
+    "identity.evolutions": "Evolutions",
+    "identity.favorite_domains": "Favorite domains",
+    "identity.error": "\u{1F4E6} *confused* Could not initialize identity. Please try again.",
+    "tool.sequences.description": "Show detected tool usage sequences",
+    "sequences.empty": "\u{1F4E6} *listens* No sequences detected yet. Keep using tools...",
+    "sequences.title": "## \u{1F4E6} Tool Sequences",
+    "observer.skill_generated": "Generated skill: {name}",
+    "skill.domain_description": "Specialist skill for the {domain} domain",
+    "tool.observations.description": "View observation logs for this session",
+    "tool.observations.args.limit": "Maximum number of observations to show",
+    "tool.observations.args.types": "Comma-separated list of observation types to filter",
+    "observations.title": "## \u{1F4E6} Observation Log",
+    "observations.empty": "\u{1F4E6} *empty* No observations recorded yet.",
+    "observations.stats": "**Total**: {count} observations, **Size**: {size}",
+    "tool.session_context.description": "Get context from previous sessions",
+    "session_context.title": "## \u{1F4E6} Session Context",
+    "session_context.empty": "\u{1F4E6} *yawns* No previous sessions to analyze.",
+    "session_context.patterns_title": "**Cross-session patterns:**",
+    "tool.generate_skills.description": "Generate declarative skills from learned instincts",
+    "generate_skills.title": "## \u{1F4E6} Skill Generation",
+    "generate_skills.empty": "\u{1F4E6} *shrugs* Not enough instincts to generate skills yet. Need 5+ per domain.",
+    "generate_skills.success": "Generated {count} skill(s):"
   },
   "ko-KR": {
     "log.session_started": "[Mimic] \uC138\uC158 \uC2DC\uC791. \uC138\uC158 {sessions}\uD68C, \uD328\uD134 {patterns}\uAC1C",
@@ -278,6 +613,10 @@ var MESSAGES = {
     "evolution.suggest.sequence.agent.reason": "\uBCF5\uC7A1\uD55C \uC2DC\uD000\uC2A4 {count}\uD68C \uBC18\uBCF5 \u2014 \uC804\uB2F4 \uC5D0\uC774\uC804\uD2B8 \uD544\uC694",
     "evolution.suggest.sequence.skill.description": "\uC790\uB3D9\uD654: {pattern}",
     "evolution.suggest.sequence.skill.reason": "\uC2DC\uD000\uC2A4 {count}\uD68C \uBC18\uBCF5",
+    "evolution.domain.description": "\uAD00\uCC30\uB41C \uBCF8\uB2A5\uC744 \uAE30\uBC18\uC73C\uB85C {domain} \uB3C4\uBA54\uC778 \uC804\uBB38 \uC5D0\uC774\uC804\uD2B8",
+    "evolution.domain.reason": '"{domain}" \uB3C4\uBA54\uC778\uC5D0\uC11C \uC2B9\uC778\uB41C \uBCF8\uB2A5 {count}\uAC1C \uAC10\uC9C0',
+    "observer.new_instincts": "\uD328\uD134\uC5D0\uC11C {count}\uAC1C\uC758 \uC0C8\uB85C\uC6B4 \uBCF8\uB2A5\uC744 \uD559\uC2B5\uD588\uC2B5\uB2C8\uB2E4",
+    "observer.evolved": "\u2728 {domain} \uB3C4\uBA54\uC778\uC744 \uC704\uD574 {name}\uC744(\uB97C) \uC790\uB3D9 \uC9C4\uD654\uD588\uC2B5\uB2C8\uB2E4!",
     "level.set": '\uB808\uBCA8\uC744 "{level}"\uB85C \uC124\uC815\uD588\uC2B5\uB2C8\uB2E4. \uC751\uB2F5\uC740 {style} \uD1A4, {detail} \uC0C1\uC138\uB3C4\uB85C \uC81C\uACF5\uD569\uB2C8\uB2E4.',
     "level.label.technical": "\uAE30\uC220\uC801",
     "level.label.semi-technical": "\uC900\uAE30\uC220",
@@ -381,14 +720,59 @@ var MESSAGES = {
     "tool.mcp.args.name": "MCP \uC11C\uBC84 \uC774\uB984",
     "tool.mcp.args.url": "\uC6D0\uACA9 MCP \uC11C\uBC84 URL",
     "tool.mcp.args.command": "\uB85C\uCEEC MCP \uBA85\uB839(\uC27C\uD45C \uAD6C\uBD84)",
-    "tool.capabilities.description": "\uC9C4\uD654\uD55C \uB2A5\uB825 \uBAA9\uB85D"
+    "tool.capabilities.description": "\uC9C4\uD654\uD55C \uB2A5\uB825 \uBAA9\uB85D",
+    "tool.instincts.description": "\uD559\uC2B5\uB41C \uBAA8\uB4E0 \uBCF8\uB2A5 \uBCF4\uAE30",
+    "tool.instincts.args.domain": "\uB3C4\uBA54\uC778\uC73C\uB85C \uD544\uD130 (\uC120\uD0DD)",
+    "instincts.empty": "\u{1F4E6} *\uD558\uD488* \uC544\uC9C1 \uD559\uC2B5\uD55C \uBCF8\uB2A5\uC774 \uC5C6\uC5B4. \uACC4\uC18D \uC791\uC5C5\uD574, \uC9C0\uCF1C\uBCF4\uACE0 \uC788\uC744\uAC8C...",
+    "instincts.title": "## \u{1F4E6} \uD559\uC2B5\uB41C \uBCF8\uB2A5",
+    "instincts.total": "\uCD1D {count}\uAC1C \uBCF8\uB2A5",
+    "instincts.auto_applied": "\uD559\uC2B5\uB41C \uD589\uB3D9\uC774 \uC774 \uC138\uC158\uC5D0 \uC790\uB3D9 \uC801\uC6A9\uB418\uC5C8\uC2B5\uB2C8\uB2E4",
+    "tool.export.description": "\uB2E4\uB978 \uD504\uB85C\uC81D\uD2B8\uC640 \uACF5\uC720\uD558\uAE30 \uC704\uD574 \uBCF8\uB2A5 \uB0B4\uBCF4\uB0B4\uAE30",
+    "export.empty": "\u{1F4E6} *\uB35C\uCEF9* \uB0B4\uBCF4\uB0BC \uAC8C \uC5C6\uC5B4. \uBA3C\uC800 \uBCF8\uB2A5\uC744 \uD559\uC2B5\uD574!",
+    "export.success": "\u{1F4E6} *\uBFCC\uB4EF\uD55C \uB538\uAE4D* {count}\uAC1C \uBCF8\uB2A5\uC744 \uB0B4\uBCF4\uB0C8\uC5B4:\n`{path}`",
+    "tool.import.description": "\uB2E4\uB978 \uD504\uB85C\uC81D\uD2B8\uC5D0\uC11C \uBCF8\uB2A5 \uAC00\uC838\uC624\uAE30",
+    "tool.import.args.path": "\uB0B4\uBCF4\uB0B8 \uBCF8\uB2A5 JSON \uD30C\uC77C \uACBD\uB85C",
+    "import.not_found": "\u{1F4E6} *\uAC38\uC6B0\uB6B1* \uD30C\uC77C\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC5B4: {path}",
+    "import.success": "\u{1F4E6} *\uC9C0\uC2DD \uD761\uC218* {from}\uC5D0\uC11C {count}\uAC1C \uBCF8\uB2A5\uC744 \uAC00\uC838\uC654\uC5B4!",
+    "import.error": "\u{1F4E6} *\uD264* \uBCF8\uB2A5 \uD30C\uC77C \uD30C\uC2F1 \uC2E4\uD328. \uD615\uC2DD\uC774 \uC798\uBABB\uB410\uC5B4.",
+    "tool.apply.description": "\uD604\uC7AC \uC791\uC5C5\uACFC \uAD00\uB828\uB41C \uBCF8\uB2A5 \uD45C\uC2DC",
+    "apply.none": "\u{1F4E6} *\uB450\uB9AC\uBC88* \uD604\uC7AC \uCEE8\uD14D\uC2A4\uD2B8\uC5D0 \uAD00\uB828\uB41C \uBCF8\uB2A5\uC774 \uC5C6\uC5B4.",
+    "apply.title": "## \u{1F4E6} \uC801\uC6A9 \uAC00\uB2A5\uD55C \uBCF8\uB2A5",
+    "tool.identity.description": "Mimic\uC758 \uC815\uCCB4\uC131\uACFC \uC131\uACA9 \uBCF4\uAE30",
+    "identity.title": "## \u{1F4E6} \uB098\uB294 \uB204\uAD6C\uC778\uAC00?",
+    "identity.personality": "\uC131\uACA9",
+    "identity.awakened": "\uAE68\uC5B4\uB09C \uB0A0",
+    "identity.days": "\uC77C \uC804",
+    "identity.instincts_learned": "\uD559\uC2B5\uD55C \uBCF8\uB2A5",
+    "identity.evolutions": "\uC9C4\uD654 \uD69F\uC218",
+    "identity.favorite_domains": "\uC120\uD638 \uB3C4\uBA54\uC778",
+    "identity.error": "\u{1F4E6} *\uAC38\uC6B0\uB6B1* \uC815\uCCB4\uC131\uC744 \uCD08\uAE30\uD654\uD560 \uC218 \uC5C6\uC5B4\uC694. \uB2E4\uC2DC \uC2DC\uB3C4\uD574\uC8FC\uC138\uC694.",
+    "tool.sequences.description": "\uAC10\uC9C0\uB41C \uB3C4\uAD6C \uC0AC\uC6A9 \uC2DC\uD000\uC2A4 \uBCF4\uAE30",
+    "sequences.empty": "\u{1F4E6} *\uADC0 \uAE30\uC6B8\uC784* \uC544\uC9C1 \uC2DC\uD000\uC2A4\uAC00 \uAC10\uC9C0\uB418\uC9C0 \uC54A\uC558\uC5B4. \uACC4\uC18D \uB3C4\uAD6C\uB97C \uC368\uBD10...",
+    "sequences.title": "## \u{1F4E6} \uB3C4\uAD6C \uC2DC\uD000\uC2A4",
+    "observer.skill_generated": "\uC2A4\uD0AC \uC0DD\uC131\uB428: {name}",
+    "skill.domain_description": "{domain} \uB3C4\uBA54\uC778 \uC804\uBB38 \uC2A4\uD0AC",
+    "tool.observations.description": "\uC774 \uC138\uC158\uC758 \uAD00\uCC30 \uB85C\uADF8 \uBCF4\uAE30",
+    "tool.observations.args.limit": "\uD45C\uC2DC\uD560 \uCD5C\uB300 \uAD00\uCC30 \uC218",
+    "tool.observations.args.types": "\uD544\uD130\uD560 \uAD00\uCC30 \uC720\uD615(\uC27C\uD45C \uAD6C\uBD84)",
+    "observations.title": "## \u{1F4E6} \uAD00\uCC30 \uB85C\uADF8",
+    "observations.empty": "\u{1F4E6} *\uBE44\uC5B4\uC788\uC74C* \uC544\uC9C1 \uAE30\uB85D\uB41C \uAD00\uCC30\uC774 \uC5C6\uC5B4.",
+    "observations.stats": "**\uCD1D**: {count}\uAC1C \uAD00\uCC30, **\uD06C\uAE30**: {size}",
+    "tool.session_context.description": "\uC774\uC804 \uC138\uC158 \uCEE8\uD14D\uC2A4\uD2B8 \uAC00\uC838\uC624\uAE30",
+    "session_context.title": "## \u{1F4E6} \uC138\uC158 \uCEE8\uD14D\uC2A4\uD2B8",
+    "session_context.empty": "\u{1F4E6} *\uD558\uD488* \uBD84\uC11D\uD560 \uC774\uC804 \uC138\uC158\uC774 \uC5C6\uC5B4.",
+    "session_context.patterns_title": "**\uC138\uC158 \uAC04 \uD328\uD134:**",
+    "tool.generate_skills.description": "\uD559\uC2B5\uB41C \uBCF8\uB2A5\uC73C\uB85C \uC120\uC5B8\uC801 \uC2A4\uD0AC \uC0DD\uC131",
+    "generate_skills.title": "## \u{1F4E6} \uC2A4\uD0AC \uC0DD\uC131",
+    "generate_skills.empty": "\u{1F4E6} *\uC5B4\uAE68 \uC73C\uC4F1* \uC2A4\uD0AC\uC744 \uC0DD\uC131\uD560 \uBCF8\uB2A5\uC774 \uBD80\uC871\uD574. \uB3C4\uBA54\uC778\uB2F9 5\uAC1C \uC774\uC0C1 \uD544\uC694\uD574.",
+    "generate_skills.success": "{count}\uAC1C \uC2A4\uD0AC \uC0DD\uC131\uB428:"
   }
 };
 async function loadMimicConfig() {
-  const configPath = join(homedir(), ".config", "opencode", "mimic.json");
-  if (!existsSync(configPath)) return {};
+  const configPath = join2(homedir(), ".config", "opencode", "mimic.json");
+  if (!existsSync2(configPath)) return {};
   try {
-    const raw = await readFile(configPath, "utf-8");
+    const raw = await readFile2(configPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
     return parsed;
@@ -434,985 +818,2823 @@ function formatPatternType(i18n, type) {
   return i18n.t(`patterns.type.${type}`);
 }
 
-// src/format.ts
-function analyzeTimeSinceLastSession(lastSession) {
-  if (!lastSession) return "first-time";
-  const hours = differenceInHours(/* @__PURE__ */ new Date(), new Date(lastSession));
-  if (hours < 1) return "continuing";
-  if (hours < 24) return "same-day";
-  if (hours < 72) return "short-break";
-  if (hours < 168) return "week-break";
-  return "long-break";
-}
-function formatJourney(ctx, state, gitHistory) {
-  const milestones = state.journey.milestones.slice(-10);
-  const observations = state.journey.observations.slice(-5);
-  const locale = ctx.i18n.language === "ko-KR" ? ko : enUS;
-  let output = `${ctx.i18n.t("journey.title", { project: state.project.name })}
+// src/modules/evolution/engine.ts
+import { existsSync as existsSync3 } from "fs";
+import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import { join as join3 } from "path";
 
-`;
-  output += `${ctx.i18n.t("journey.subtitle")}
+// src/constants/tools.ts
+var BUILTIN_TOOLS = /* @__PURE__ */ new Set([
+  "read",
+  "write",
+  "edit",
+  "bash",
+  "grep",
+  "glob",
+  "serena_list_dir",
+  "serena_find_file",
+  "serena_search_for_pattern",
+  "serena_get_symbols_overview",
+  "serena_find_symbol",
+  "serena_find_referencing_symbols",
+  "serena_replace_symbol_body",
+  "serena_insert_after_symbol",
+  "serena_insert_before_symbol",
+  "serena_replace_content",
+  "serena_rename_symbol",
+  "lsp_diagnostics",
+  "lsp_goto_definition",
+  "lsp_find_references",
+  "lsp_prepare_rename",
+  "lsp_rename",
+  "lsp_symbols",
+  "delegate_task",
+  "task",
+  "question",
+  "background_cancel",
+  "background_output",
+  "skill",
+  "slashcommand",
+  "use_skill",
+  "find_skills",
+  "session_list",
+  "session_read",
+  "session_search",
+  "session_info",
+  "mimic:"
+]);
 
-`;
-  output += `${ctx.i18n.t("journey.sessions_survived", {
-    count: state.journey.sessionCount
-  })}
-`;
-  output += `${ctx.i18n.t("journey.first_encounter", {
-    date: format(state.project.firstSession, "yyyy-MM-dd")
-  })}
-`;
-  output += `${ctx.i18n.t("journey.abilities_gained", {
-    count: state.evolution.capabilities.length
-  })}
+// src/constants/domain.ts
+var DOMAINS = [
+  "code-style",
+  "testing",
+  "git",
+  "debugging",
+  "file-organization",
+  "tooling",
+  "refactoring",
+  "documentation",
+  "other"
+];
+var DOMAIN_KEYWORDS_BY_LANG = {
+  "en-US": {
+    "code-style": ["style", "format", "lint", "prettier", "eslint", "naming", "convention"],
+    testing: ["test", "spec", "jest", "vitest", "mocha", "coverage", "assert", "expect"],
+    git: ["commit", "branch", "merge", "push", "pull", "rebase", "stash", "git"],
+    debugging: ["debug", "error", "fix", "bug", "issue", "trace", "log", "breakpoint"],
+    "file-organization": ["move", "rename", "organize", "structure", "folder", "directory"],
+    tooling: ["tool", "script", "build", "compile", "bundle", "config"],
+    refactoring: ["refactor", "extract", "inline", "rename", "move", "simplify"],
+    documentation: ["doc", "readme", "comment", "jsdoc", "markdown", "wiki"],
+    other: []
+  },
+  "ko-KR": {
+    "code-style": ["\uC2A4\uD0C0\uC77C", "\uD3EC\uB9F7", "\uB9B0\uD2B8", "\uB124\uC774\uBC0D", "\uCEE8\uBCA4\uC158", "\uCF54\uB529\uADDC\uCE59", "\uC815\uB82C"],
+    testing: ["\uD14C\uC2A4\uD2B8", "\uB2E8\uC704\uD14C\uC2A4\uD2B8", "\uCEE4\uBC84\uB9AC\uC9C0", "\uAC80\uC99D", "\uD655\uC778", "\uB2E8\uC5B8"],
+    git: ["\uCEE4\uBC0B", "\uBE0C\uB79C\uCE58", "\uBCD1\uD569", "\uD478\uC2DC", "\uD480", "\uB9AC\uBCA0\uC774\uC2A4", "\uC2A4\uD0DC\uC2DC", "\uAE43"],
+    debugging: ["\uB514\uBC84\uADF8", "\uB514\uBC84\uAE45", "\uC624\uB958", "\uC5D0\uB7EC", "\uC218\uC815", "\uBC84\uADF8", "\uC774\uC288", "\uCD94\uC801", "\uB85C\uADF8"],
+    "file-organization": ["\uC774\uB3D9", "\uC774\uB984\uBCC0\uACBD", "\uC815\uB9AC", "\uAD6C\uC870", "\uD3F4\uB354", "\uB514\uB809\uD1A0\uB9AC", "\uD30C\uC77C\uC815\uB9AC"],
+    tooling: ["\uB3C4\uAD6C", "\uC2A4\uD06C\uB9BD\uD2B8", "\uBE4C\uB4DC", "\uCEF4\uD30C\uC77C", "\uBC88\uB4E4", "\uC124\uC815", "\uAD6C\uC131"],
+    refactoring: ["\uB9AC\uD329\uD130", "\uB9AC\uD329\uD1A0\uB9C1", "\uCD94\uCD9C", "\uC778\uB77C\uC778", "\uB2E8\uC21C\uD654", "\uAC1C\uC120"],
+    documentation: ["\uBB38\uC11C", "\uBB38\uC11C\uD654", "\uC8FC\uC11D", "\uB9AC\uB4DC\uBBF8", "\uB9C8\uD06C\uB2E4\uC6B4", "\uC704\uD0A4", "\uC124\uBA85"],
+    other: []
+  }
+};
 
-`;
-  if (state.project.stack && state.project.stack.length > 0) {
-    output += `${ctx.i18n.t("journey.treasures", {
-      stack: state.project.stack.join(", ")
-    })}
-`;
+// src/modules/knowledge/instincts.ts
+var MIN_CONFIDENCE = 0.6;
+var MIN_INSTINCTS_FOR_EVOLUTION = 5;
+function normalizeDomain(rawDomain) {
+  const lower = rawDomain.toLowerCase().trim();
+  const synonyms = {
+    "code-style": "code-style",
+    codestyle: "code-style",
+    style: "code-style",
+    formatting: "code-style",
+    testing: "testing",
+    test: "testing",
+    tests: "testing",
+    git: "git",
+    vcs: "git",
+    "version-control": "git",
+    debugging: "debugging",
+    debug: "debugging",
+    "file-organization": "file-organization",
+    files: "file-organization",
+    organization: "file-organization",
+    tooling: "tooling",
+    tools: "tooling",
+    refactoring: "refactoring",
+    refactor: "refactoring",
+    documentation: "documentation",
+    docs: "documentation"
+  };
+  if (synonyms[lower]) {
+    return synonyms[lower];
   }
-  if (state.project.focus) {
-    output += `${ctx.i18n.t("journey.current_hunt", { focus: state.project.focus })}
-`;
+  if (DOMAINS.includes(lower)) {
+    return lower;
   }
-  output += "\n";
-  if (milestones.length > 0) {
-    output += `${ctx.i18n.t("journey.victories")}
-`;
-    for (const m of milestones) {
-      const timeAgo = formatDistanceToNow(new Date(m.timestamp), { addSuffix: true, locale });
-      output += `- ${m.milestone} (${timeAgo})
-`;
-    }
-    output += "\n";
+  return "other";
+}
+function groupByDomain(instincts) {
+  const map = /* @__PURE__ */ new Map();
+  for (const instinct of instincts) {
+    if (instinct.status !== "approved") continue;
+    if (instinct.confidence < MIN_CONFIDENCE) continue;
+    const list = map.get(instinct.domain) || [];
+    list.push(instinct);
+    map.set(instinct.domain, list);
   }
-  if (observations.length > 0) {
-    output += `${ctx.i18n.t("journey.witnessed")}
-`;
-    for (const o of observations) {
-      output += `- ${o.observation}
-`;
+  return map;
+}
+function getEligibleDomains(domainMap) {
+  const eligible = [];
+  for (const [domain, instincts] of domainMap) {
+    if (instincts.length >= MIN_INSTINCTS_FOR_EVOLUTION) {
+      eligible.push(domain);
     }
-    output += "\n";
   }
-  if (state.evolution.capabilities.length > 0) {
-    output += `${ctx.i18n.t("journey.powers")}
-`;
-    for (const cap of state.evolution.capabilities.slice(-5)) {
-      output += `- **${cap.name}** (${formatCapabilityType(
-        ctx.i18n,
-        cap.type
-      )}): ${cap.description}
-`;
+  return eligible;
+}
+function shouldTriggerEvolution(domain, evolvedDomains, cooldownDays = 7) {
+  if (!evolvedDomains?.[domain]) {
+    return true;
+  }
+  const lastEvolved = new Date(evolvedDomains[domain]);
+  const now = /* @__PURE__ */ new Date();
+  const diffDays = (now.getTime() - lastEvolved.getTime()) / (1e3 * 60 * 60 * 24);
+  return diffDays >= cooldownDays;
+}
+function findRepresentativePattern(instincts, patterns) {
+  const patternIDs = /* @__PURE__ */ new Set();
+  for (const instinct of instincts) {
+    for (const id of instinct.evidence.patternIDs) {
+      patternIDs.add(id);
     }
-    output += "\n";
   }
-  if (gitHistory.length > 0) {
-    output += `${ctx.i18n.t("journey.scrolls")}
-`;
-    for (const commit of gitHistory.slice(0, 5)) {
-      output += `- ${commit}
-`;
+  let bestPattern = null;
+  let maxCount = 0;
+  for (const pattern of patterns) {
+    if (patternIDs.has(pattern.id) && pattern.count > maxCount) {
+      maxCount = pattern.count;
+      bestPattern = pattern;
     }
   }
-  return output;
+  if (!bestPattern && patterns.length > 0) {
+    const unsurfaced = patterns.find((p) => !p.surfaced);
+    bestPattern = unsurfaced || patterns[0];
+  }
+  return bestPattern;
 }
-function formatDuration(ms) {
-  const minutes = Math.round(ms / 1e3 / 60);
-  if (minutes < 60) return `${minutes}min`;
-  const hours = Math.floor(minutes / 60);
-  const remainingMinutes = minutes % 60;
-  return `${hours}h ${remainingMinutes}min`;
+async function clusterDomainsAndTriggerEvolution(ctx) {
+  const state = await ctx.stateManager.read();
+  const instincts = await ctx.stateManager.listInstincts();
+  const domainMap = groupByDomain(instincts);
+  const eligible = getEligibleDomains(domainMap);
+  const triggered = [];
+  for (const domain of eligible) {
+    if (!shouldTriggerEvolution(domain, state.evolution.evolvedDomains)) {
+      continue;
+    }
+    triggered.push(domain);
+    if (!state.evolution.pendingSuggestions.includes(domain)) {
+      state.evolution.pendingSuggestions.push(domain);
+    }
+  }
+  if (triggered.length > 0) {
+    await ctx.stateManager.save(state);
+  }
+  return triggered;
 }
-function formatGrowAnalysis(ctx, state, _gitHistory, recentFiles) {
-  let output = `${ctx.i18n.t("grow.title", { project: state.project.name })}
 
-`;
-  output += `${ctx.i18n.t("grow.subtitle")}
+// src/utils/id.ts
+import { createHash } from "crypto";
+import { nanoid } from "nanoid";
+function generateId(size) {
+  return nanoid(size);
+}
+function generateDeterministicId(domain, seed) {
+  return createHash("sha1").update(`${domain}:${seed}`).digest("hex").slice(0, 12);
+}
 
+// src/modules/evolution/engine.ts
+function generateToolCode(name, description, pattern) {
+  const funcName = name.replace(/-/g, "_");
+  return `// \u{1F4E6} Auto-generated by Mimic
+// Pattern: ${pattern.description} (${pattern.count}x)
+// Generated: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+export const ${funcName} = (plugin) => ({
+  tool: {
+    "${name}": {
+      description: "${description}",
+      args: {},
+      async execute() {
+        // TODO: Implement your logic here
+        // This was generated from pattern: ${pattern.description}
+        return "\u{1F4E6} ${name} executed!";
+      },
+    },
+  },
+});
+
+export default ${funcName};
 `;
-  const fileFrequency = Object.entries(state.statistics.filesModified).sort(([, a], [, b]) => b - a).slice(0, 10);
-  if (fileFrequency.length > 0) {
-    output += `${ctx.i18n.t("grow.feeding_grounds")}
-`;
-    for (const [file, count] of fileFrequency) {
-      output += `- \`${file}\` ${ctx.i18n.t("grow.files_modified", { count })}
-`;
+}
+function generateHookCode(name, _description, pattern) {
+  const filename = pattern.description;
+  return `// \u{1F4E6} Auto-generated by Mimic
+// Pattern: ${pattern.description} (${pattern.count}x)
+// Generated: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+export const ${name.replace(/-/g, "_")} = (plugin) => ({
+  async event({ event }) {
+    if (event.type === "${OPENCODE_EVENTS.FILE_EDITED}") {
+      const filename = event.properties?.filename;
+      if (filename?.includes("${filename}")) {
+        console.log("\u{1F4E6} [Mimic] Detected change in watched file: ${filename}");
+        // TODO: Add your custom logic here
+      }
     }
-    output += "\n";
-  }
-  const toolPatterns = state.patterns.filter((p) => p.type === "tool").sort((a, b) => b.count - a.count);
-  if (toolPatterns.length > 0) {
-    output += `${ctx.i18n.t("grow.favorite_prey")}
-`;
-    for (const p of toolPatterns.slice(0, 5)) {
-      output += `- ${p.description}: ${p.count}
+  },
+});
+
+export default ${name.replace(/-/g, "_")};
 `;
+}
+function generateSkillCode(name, description, pattern) {
+  return `// \u{1F4E6} Auto-generated by Mimic
+// Pattern: ${pattern.description} (${pattern.count}x)
+// Generated: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+export const ${name.replace(/-/g, "_")} = (plugin) => ({
+  async event({ event }) {
+    // Auto-triggered skill: ${description}
+    if (event.type === "${OPENCODE_EVENTS.SESSION_CREATED}") {
+      console.log("\u{1F4E6} [Mimic] Skill ${name} activated");
+      // TODO: Implement automated behavior
     }
-    output += "\n";
-  }
-  if (recentFiles.length > 0) {
-    const dirCount = /* @__PURE__ */ new Map();
-    for (const file of recentFiles) {
-      const dir = file.split("/").slice(0, -1).join("/") || ".";
-      dirCount.set(dir, (dirCount.get(dir) || 0) + 1);
-    }
-    const sortedDirs = [...dirCount.entries()].sort((a, b) => b[1] - a[1]);
-    output += `${ctx.i18n.t("grow.hunting_grounds")}
-`;
-    for (const [dir, count] of sortedDirs.slice(0, 5)) {
-      output += `- \`${dir}/\` ${ctx.i18n.t("grow.prey", { count })}
+  },
+});
+
+export default ${name.replace(/-/g, "_")};
 `;
+}
+function generateMcpConfig(name, _description, pattern) {
+  return {
+    [name]: {
+      type: "local",
+      command: ["echo", `MCP server for ${pattern.description}`],
+      enabled: false
     }
-    output += "\n";
-  }
-  output += `${ctx.i18n.t("grow.questions")}
-`;
-  output += `${ctx.i18n.t("grow.question1")}
-`;
-  output += `${ctx.i18n.t("grow.question2")}
-`;
-  output += `${ctx.i18n.t("grow.question3")}
-`;
-  if (state.project.focus) {
-    output += `
-${ctx.i18n.t("grow.current_hunt", { focus: state.project.focus })}
-`;
-  }
-  return output;
+  };
 }
+function generateAgentMarkdown(name, description, pattern) {
+  return `---
+description: ${description}
+mode: subagent
+tools:
+  read: true
+  glob: true
+  grep: true
+  bash: false
+  edit: false
+---
 
-// src/git.ts
-import { execSync } from "child_process";
-function getGitHistory(directory, limit = 50) {
+# \u{1F4E6} ${name}
+
+Auto-generated by Mimic from pattern: ${pattern.description} (${pattern.count}x)
+
+## Focus Area
+
+This agent specializes in tasks related to: ${pattern.description}
+
+## Context
+
+- Pattern detected: ${pattern.type}
+- Usage count: ${pattern.count}
+- First seen: ${new Date(pattern.firstSeen).toISOString()}
+
+## How To Help
+
+Analyze and assist with tasks matching this pattern.
+Provide focused, expert guidance in this specific area.
+
+## Remember
+
+- Stay focused on the pattern's domain
+- Leverage the observed usage patterns
+- Adapt to the user's workflow
+`;
+}
+async function readOpencodeConfig(configPath) {
+  if (!existsSync3(configPath)) return {};
   try {
-    const result = execSync(`git log --oneline -n ${limit}`, {
-      cwd: directory,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    return result.trim().split("\n").filter(Boolean);
+    const parsed = JSON.parse(await readFile3(configPath, "utf-8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return {};
+    }
+    return parsed;
   } catch {
-    return [];
+    return {};
   }
 }
-function getRecentlyModifiedFiles(directory) {
-  try {
-    const result = execSync(
-      "git diff --name-only HEAD~10 HEAD 2>/dev/null || git diff --name-only",
-      {
-        cwd: directory,
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"]
-      }
-    );
-    return result.trim().split("\n").filter(Boolean);
-  } catch {
-    return [];
+async function buildMcpEvolution(ctx, suggestion) {
+  const opencodeDir = join3(ctx.directory, ".opencode");
+  if (!existsSync3(opencodeDir)) {
+    await mkdir2(opencodeDir, { recursive: true });
   }
+  const configPath = join3(ctx.directory, "opencode.json");
+  const config = await readOpencodeConfig(configPath);
+  const mcpConfig = generateMcpConfig(suggestion.name, suggestion.description, suggestion.pattern);
+  const mcp = { ...config.mcp || {}, ...mcpConfig };
+  const content = JSON.stringify({ ...config, mcp }, null, 2);
+  return { filePath: configPath, content };
 }
-function getCommitMessages(directory, limit = 20) {
-  try {
-    const result = execSync(`git log --format=%s -n ${limit}`, {
-      cwd: directory,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    return result.trim().split("\n").filter(Boolean);
-  } catch {
-    return [];
+async function buildAgentEvolution(ctx, suggestion) {
+  const agentsDir = join3(ctx.directory, ".opencode", "agents");
+  if (!existsSync3(agentsDir)) {
+    await mkdir2(agentsDir, { recursive: true });
   }
+  return {
+    content: generateAgentMarkdown(suggestion.name, suggestion.description, suggestion.pattern),
+    filePath: join3(agentsDir, `${suggestion.name}.md`)
+  };
 }
-function detectCommitPatterns(messages) {
-  const patterns = /* @__PURE__ */ new Map();
-  for (const msg of messages) {
-    const normalized = msg.toLowerCase().replace(/\s+/g, " ").trim();
-    patterns.set(normalized, (patterns.get(normalized) || 0) + 1);
+function buildPluginContent(suggestion) {
+  switch (suggestion.type) {
+    case "command":
+    case "shortcut":
+      return generateToolCode(suggestion.name, suggestion.description, suggestion.pattern);
+    case "hook":
+      return generateHookCode(suggestion.name, suggestion.description, suggestion.pattern);
+    case "skill":
+      return generateSkillCode(suggestion.name, suggestion.description, suggestion.pattern);
+    default:
+      return generateToolCode(suggestion.name, suggestion.description, suggestion.pattern);
   }
-  return patterns;
 }
-
-// src/patterns.ts
-async function detectPatterns(ctx) {
-  const state = await ctx.stateManager.read();
-  const newPatterns = [];
-  const commitMessages = getCommitMessages(ctx.directory);
-  const commitPatterns = detectCommitPatterns(commitMessages);
-  for (const [msg, count] of commitPatterns) {
-    if (count >= 3) {
-      const existing = state.patterns.find((p) => p.type === "commit" && p.description === msg);
-      if (!existing) {
-        newPatterns.push({
-          id: crypto.randomUUID(),
-          type: "commit",
-          description: msg,
-          count,
-          firstSeen: Date.now(),
-          lastSeen: Date.now(),
-          surfaced: false,
-          examples: []
-        });
-      }
-    }
+async function buildPluginEvolution(ctx, suggestion) {
+  const pluginsDir = join3(ctx.directory, ".opencode", "plugins");
+  if (!existsSync3(pluginsDir)) {
+    await mkdir2(pluginsDir, { recursive: true });
   }
-  const fileStats = state.statistics.filesModified;
-  for (const [file, count] of Object.entries(fileStats)) {
-    if (count >= 5) {
-      const existing = state.patterns.find((p) => p.type === "file" && p.description === file);
-      if (!existing) {
-        newPatterns.push({
-          id: crypto.randomUUID(),
-          type: "file",
-          description: file,
-          count,
-          firstSeen: Date.now(),
-          lastSeen: Date.now(),
-          surfaced: false,
-          examples: []
-        });
+  return {
+    content: buildPluginContent(suggestion),
+    filePath: join3(pluginsDir, `${suggestion.name}.js`)
+  };
+}
+async function buildEvolutionOutput(ctx, suggestion) {
+  if (suggestion.type === "mcp") {
+    return buildMcpEvolution(ctx, suggestion);
+  }
+  if (suggestion.type === "agent") {
+    return buildAgentEvolution(ctx, suggestion);
+  }
+  return buildPluginEvolution(ctx, suggestion);
+}
+function createCapabilityFromSuggestion(suggestion) {
+  return {
+    id: generateId(),
+    type: suggestion.type,
+    name: suggestion.name,
+    description: suggestion.description,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    fromPattern: suggestion.pattern.id
+  };
+}
+function updateEvolutionState(state, capability, suggestion) {
+  state.evolution.capabilities.push(capability);
+  state.evolution.lastEvolution = (/* @__PURE__ */ new Date()).toISOString();
+  const pattern = state.patterns.find((p) => p.id === suggestion.pattern.id);
+  if (pattern) {
+    pattern.surfaced = true;
+  }
+}
+function suggestEvolution(pattern, ctx) {
+  switch (pattern.type) {
+    case "tool":
+      if (pattern.count >= 10) {
+        const toolName = pattern.description;
+        if (BUILTIN_TOOLS.has(toolName)) {
+          return null;
+        }
+        return {
+          type: "shortcut",
+          name: `quick-${pattern.description.toLowerCase().replace(/[^a-z0-9]/g, "-")}`,
+          description: ctx.i18n.t("evolution.suggest.tool.description", {
+            pattern: pattern.description
+          }),
+          reason: ctx.i18n.t("evolution.suggest.tool.reason", { count: pattern.count }),
+          pattern
+        };
       }
-    }
+      break;
+    case "file":
+      if (pattern.count >= 5) {
+        return {
+          type: "hook",
+          name: `watch-${pattern.description.split("/").pop()?.replace(/\./g, "-") || "file"}`,
+          description: ctx.i18n.t("evolution.suggest.file.description", {
+            pattern: pattern.description
+          }),
+          reason: ctx.i18n.t("evolution.suggest.file.reason", { count: pattern.count }),
+          pattern
+        };
+      }
+      break;
+    case "commit":
+      if (pattern.count >= 3) {
+        return {
+          type: "command",
+          name: `commit-${pattern.description.slice(0, 20).replace(/\s+/g, "-").toLowerCase()}`,
+          description: ctx.i18n.t("evolution.suggest.commit.description", {
+            pattern: pattern.description
+          }),
+          reason: ctx.i18n.t("evolution.suggest.commit.reason", { count: pattern.count }),
+          pattern
+        };
+      }
+      break;
+    case "sequence":
+      if (pattern.count >= 5) {
+        return {
+          type: "agent",
+          name: `${pattern.description.slice(0, 15).replace(/\s+/g, "-").toLowerCase()}-specialist`,
+          description: ctx.i18n.t("evolution.suggest.sequence.agent.description", {
+            pattern: pattern.description
+          }),
+          reason: ctx.i18n.t("evolution.suggest.sequence.agent.reason", { count: pattern.count }),
+          pattern
+        };
+      }
+      if (pattern.count >= 3) {
+        return {
+          type: "skill",
+          name: `auto-${pattern.description.slice(0, 15).replace(/\s+/g, "-").toLowerCase()}`,
+          description: ctx.i18n.t("evolution.suggest.sequence.skill.description", {
+            pattern: pattern.description
+          }),
+          reason: ctx.i18n.t("evolution.suggest.sequence.skill.reason", { count: pattern.count }),
+          pattern
+        };
+      }
+      break;
   }
-  return newPatterns;
+  return null;
 }
-async function surfacePatterns(ctx) {
+async function getEvolutionSuggestions(ctx) {
   const state = await ctx.stateManager.read();
   const suggestions = [];
   for (const pattern of state.patterns) {
     if (pattern.surfaced) continue;
-    if (pattern.count < state.preferences.minPatternCount) continue;
-    let suggestion = "";
-    switch (pattern.type) {
-      case "commit":
-        suggestion = ctx.i18n.t("suggest.commit", {
-          pattern: pattern.description,
-          count: pattern.count
-        });
-        break;
-      case "file":
-        suggestion = ctx.i18n.t("suggest.file", {
-          pattern: pattern.description,
-          count: pattern.count
-        });
-        break;
-      case "tool":
-        suggestion = ctx.i18n.t("suggest.tool", {
-          pattern: pattern.description,
-          count: pattern.count
-        });
-        break;
-      case "sequence":
-        suggestion = ctx.i18n.t("suggest.sequence", {
-          pattern: pattern.description,
-          count: pattern.count
-        });
-        break;
+    const suggestion = suggestEvolution(pattern, ctx);
+    if (suggestion) {
+      suggestions.push(suggestion);
     }
-    suggestions.push(suggestion);
   }
   return suggestions;
 }
+async function evolveCapability(ctx, suggestion) {
+  const state = await ctx.stateManager.read();
+  const { filePath, content } = await buildEvolutionOutput(ctx, suggestion);
+  await writeFile2(filePath, content, "utf-8");
+  const capability = createCapabilityFromSuggestion(suggestion);
+  updateEvolutionState(state, capability, suggestion);
+  await ctx.stateManager.save(state);
+  await ctx.stateManager.addMilestone(
+    ctx.i18n.t("milestone.evolved", {
+      name: capability.name,
+      type: formatCapabilityType(ctx.i18n, capability.type)
+    })
+  );
+  return { capability, filePath };
+}
+function formatEvolutionResult(ctx, capability, filePath) {
+  const typeLabel = formatCapabilityType(ctx.i18n, capability.type);
+  let result = `### \u2728 ${capability.name}
 
-// src/state.ts
-import { existsSync as existsSync2 } from "fs";
-import { mkdir, readFile as readFile2, writeFile } from "fs/promises";
-import { join as join2 } from "path";
-var STATE_JSON_GITIGNORE_LINE = ".opencode/mimic/state.json";
-var createDefaultState = (projectName) => ({
-  version: "0.1.0",
-  project: {
-    name: projectName,
-    creatorLevel: null,
-    firstSession: Date.now(),
-    stack: [],
-    focus: void 0
-  },
-  journey: {
-    observations: [],
-    milestones: [],
-    sessionCount: 0,
-    lastSession: null
-  },
-  patterns: [],
-  evolution: {
-    capabilities: [],
-    lastEvolution: null,
-    pendingSuggestions: []
-  },
-  preferences: {
-    suggestionEnabled: true,
-    learningEnabled: true,
-    minPatternCount: 3
-  },
-  statistics: {
-    totalSessions: 0,
-    totalToolCalls: 0,
-    filesModified: {},
-    lastSessionId: null
+`;
+  result += `**${ctx.i18n.t("evolution.result.type")}**: ${typeLabel}
+`;
+  result += `**${ctx.i18n.t("evolution.result.description")}**: ${capability.description}
+`;
+  result += `**${ctx.i18n.t("evolution.result.file")}**: \`${filePath}\`
+
+`;
+  result += `*${ctx.i18n.t("evolution.result.restart", { type: typeLabel })}*
+
+`;
+  switch (capability.type) {
+    case "command":
+    case "shortcut":
+      result += `${ctx.i18n.t("evolution.result.command", { name: capability.name })}
+`;
+      break;
+    case "hook":
+      result += `${ctx.i18n.t("evolution.result.hook")}
+`;
+      break;
+    case "skill":
+      result += `${ctx.i18n.t("evolution.result.skill")}
+`;
+      break;
+    case "agent":
+      result += `${ctx.i18n.t("evolution.result.agent", { name: capability.name })}
+`;
+      break;
+    case "mcp":
+      result += `${ctx.i18n.t("evolution.result.mcp", { name: capability.name })}
+`;
+      break;
   }
-});
-var StateManager = class {
-  mimicDir;
-  statePath;
-  sessionsDir;
-  projectName;
-  constructor(directory) {
-    this.mimicDir = join2(directory, ".opencode", "mimic");
-    this.statePath = join2(this.mimicDir, "state.json");
-    this.sessionsDir = join2(this.mimicDir, "sessions");
-    this.projectName = directory.split("/").pop() || "unknown";
+  return result;
+}
+async function suggestDomainEvolution(ctx, domain) {
+  const state = await ctx.stateManager.read();
+  const instincts = await ctx.stateManager.listInstincts();
+  const domainInstincts = instincts.filter(
+    (i) => i.domain === domain && i.status === "approved" && i.confidence >= 0.6
+  );
+  if (domainInstincts.length < 5) {
+    return null;
   }
-  async ensureGitIgnore() {
-    const gitIgnorePath = join2(this.mimicDir, "..", "..", ".gitignore");
-    if (!existsSync2(gitIgnorePath)) {
-      await writeFile(gitIgnorePath, STATE_JSON_GITIGNORE_LINE + "\n", "utf-8");
-      return;
-    }
-    const content = await readFile2(gitIgnorePath, "utf-8");
-    const lines = content.split(/\r?\n/);
-    const alreadyExists = lines.some((line) => line.trim() === STATE_JSON_GITIGNORE_LINE);
-    if (!alreadyExists) {
-      await writeFile(gitIgnorePath, content + "\n" + STATE_JSON_GITIGNORE_LINE + "\n", "utf-8");
-    }
+  const pattern = findRepresentativePattern(domainInstincts, state.patterns);
+  if (!pattern) {
+    return null;
   }
-  async initialize() {
-    await this.ensureGitIgnore();
-    if (!existsSync2(this.mimicDir)) {
-      await mkdir(this.mimicDir, { recursive: true });
+  const slug = domain.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+  return {
+    type: "agent",
+    name: `${slug}-specialist`,
+    description: ctx.i18n.t("evolution.domain.description", { domain }),
+    reason: ctx.i18n.t("evolution.domain.reason", {
+      count: domainInstincts.length,
+      domain
+    }),
+    pattern
+  };
+}
+async function evolveDomain(ctx, domain) {
+  const suggestion = await suggestDomainEvolution(ctx, domain);
+  if (!suggestion) {
+    return null;
+  }
+  const result = await evolveCapability(ctx, suggestion);
+  const state = await ctx.stateManager.read();
+  if (!state.evolution.evolvedDomains) {
+    state.evolution.evolvedDomains = {};
+  }
+  state.evolution.evolvedDomains[domain] = (/* @__PURE__ */ new Date()).toISOString();
+  const pendingIndex = state.evolution.pendingSuggestions.indexOf(domain);
+  if (pendingIndex !== -1) {
+    state.evolution.pendingSuggestions.splice(pendingIndex, 1);
+  }
+  await ctx.stateManager.save(state);
+  return result;
+}
+
+// src/modules/knowledge/instinct-apply.ts
+function getDomainKeywords(domain, language = "en-US") {
+  const enKeywords = DOMAIN_KEYWORDS_BY_LANG["en-US"][domain] || [];
+  if (language === "ko-KR") {
+    const koKeywords = DOMAIN_KEYWORDS_BY_LANG["ko-KR"][domain] || [];
+    return [...enKeywords, ...koKeywords];
+  }
+  return enKeywords;
+}
+function detectCurrentDomain(recentTools, recentFiles, language = "en-US") {
+  const domains = [];
+  const context = [...recentTools, ...recentFiles].join(" ").toLowerCase();
+  const allDomains = [
+    "code-style",
+    "testing",
+    "git",
+    "debugging",
+    "file-organization",
+    "tooling",
+    "refactoring",
+    "documentation"
+  ];
+  for (const domain of allDomains) {
+    const keywords = getDomainKeywords(domain, language);
+    if (keywords.some((kw) => context.includes(kw))) {
+      domains.push(domain);
     }
-    if (!existsSync2(this.sessionsDir)) {
-      await mkdir(this.sessionsDir, { recursive: true });
+  }
+  if (recentTools.some((t) => t.includes("test") || t.includes("vitest") || t.includes("\uD14C\uC2A4\uD2B8"))) {
+    if (!domains.includes("testing")) domains.push("testing");
+  }
+  if (recentTools.some((t) => t.includes("git") || t.includes("commit") || t.includes("\uCEE4\uBC0B"))) {
+    if (!domains.includes("git")) domains.push("git");
+  }
+  return domains.length > 0 ? domains : ["other"];
+}
+function filterRelevantInstincts(instincts, currentDomains) {
+  const applied = [];
+  for (const instinct of instincts) {
+    if (instinct.status !== "approved") continue;
+    if (instinct.confidence < 0.5) continue;
+    if (currentDomains.includes(instinct.domain)) {
+      applied.push({
+        instinct,
+        relevance: instinct.confidence >= 0.8 ? "high" : instinct.confidence >= 0.6 ? "medium" : "low"
+      });
     }
-    if (!existsSync2(this.statePath)) {
-      await this.save(createDefaultState(this.projectName));
+  }
+  return applied.sort((a, b) => b.instinct.confidence - a.instinct.confidence).slice(0, 3);
+}
+function formatInstinctSuggestion(applied, _i18n) {
+  const confidenceBar = "\u25CF".repeat(Math.round(applied.instinct.confidence * 5)) + "\u25CB".repeat(5 - Math.round(applied.instinct.confidence * 5));
+  const sourceTag = applied.instinct.source === "inherited" ? " \u{1F4E5}" : "";
+  return `[${confidenceBar}] ${applied.instinct.title}${sourceTag}`;
+}
+async function getApplicableInstincts(ctx, recentTools, recentFiles) {
+  const instincts = await ctx.stateManager.listInstincts();
+  const currentDomains = detectCurrentDomain(recentTools, recentFiles, ctx.i18n.language);
+  return filterRelevantInstincts(instincts, currentDomains);
+}
+async function buildInstinctContext(ctx) {
+  const instincts = await ctx.stateManager.listInstincts();
+  const approvedInstincts = instincts.filter((i) => i.status === "approved" && i.confidence >= 0.6);
+  if (approvedInstincts.length === 0) {
+    return null;
+  }
+  const byDomain = {};
+  for (const instinct of approvedInstincts) {
+    if (!byDomain[instinct.domain]) {
+      byDomain[instinct.domain] = [];
     }
+    byDomain[instinct.domain].push(instinct);
   }
-  async read() {
-    return JSON.parse(await readFile2(this.statePath, "utf-8"));
+  const sections = ["## Learned Behaviors (Auto-Applied)"];
+  for (const [domain, domainInstincts] of Object.entries(byDomain)) {
+    const sorted = domainInstincts.sort((a, b) => b.confidence - a.confidence).slice(0, 3);
+    sections.push(`
+### ${domain}`);
+    for (const instinct of sorted) {
+      const confidenceLabel = instinct.confidence >= 0.8 ? "strong" : instinct.confidence >= 0.6 ? "moderate" : "weak";
+      sections.push(`- **${instinct.title}** (${confidenceLabel}): ${instinct.description}`);
+    }
   }
-  async save(state) {
-    await writeFile(this.statePath, JSON.stringify(state, null, 2));
+  sections.push(
+    "\n_These behaviors were learned from your patterns. They are auto-applied to help maintain consistency._"
+  );
+  return sections.join("\n");
+}
+
+// src/modules/knowledge/memory.ts
+import { existsSync as existsSync4 } from "fs";
+import { readdir as readdir2, readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
+import { join as join4 } from "path";
+var MAX_MEMORIES = 50;
+var RECENT_SESSIONS_FOR_ANALYSIS = 10;
+var SessionMemoryManager = class {
+  memoryPath;
+  sessionsDir;
+  constructor(mimicDir, sessionsDir) {
+    this.memoryPath = join4(mimicDir, "session-memory.json");
+    this.sessionsDir = sessionsDir;
   }
-  async addObservation(observation) {
-    const state = await this.read();
-    state.journey.observations.push({
-      observation,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    });
-    if (state.journey.observations.length > 100) {
-      state.journey.observations = state.journey.observations.slice(-100);
+  /**
+   * Load all session memories
+   */
+  async loadMemories() {
+    if (!existsSync4(this.memoryPath)) {
+      return [];
+    }
+    try {
+      const content = await readFile4(this.memoryPath, "utf-8");
+      const data = JSON.parse(content);
+      return data.memories || [];
+    } catch {
+      return [];
     }
-    await this.save(state);
   }
-  async addMilestone(milestone) {
-    const state = await this.read();
-    state.journey.milestones.push({
-      milestone,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    });
-    await this.save(state);
+  /**
+   * Save session memories
+   */
+  async saveMemories(memories) {
+    const trimmed = memories.slice(-MAX_MEMORIES);
+    await writeFile3(
+      this.memoryPath,
+      JSON.stringify({ memories: trimmed, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2),
+      "utf-8"
+    );
   }
-  async saveSession(sessionId, data) {
-    await writeFile(join2(this.sessionsDir, `${sessionId}.json`), JSON.stringify(data, null, 2));
+  /**
+   * Create a memory from a completed session
+   */
+  async createMemory(sessionData, domains, patterns, context) {
+    const memory = {
+      sessionId: sessionData.sessionId,
+      startTime: sessionData.startTime,
+      endTime: sessionData.endTime,
+      durationMs: sessionData.durationMs,
+      summary: {
+        toolCalls: sessionData.toolCalls,
+        filesEdited: sessionData.filesEdited,
+        dominantDomains: domains.slice(0, 3),
+        patterns
+      },
+      context
+    };
+    const memories = await this.loadMemories();
+    memories.push(memory);
+    await this.saveMemories(memories);
+    return memory;
   }
-  getSessionsDir() {
-    return this.sessionsDir;
+  /**
+   * Get recent sessions for context
+   */
+  async getRecentMemories(count = RECENT_SESSIONS_FOR_ANALYSIS) {
+    const memories = await this.loadMemories();
+    return memories.slice(-count);
   }
-  getProjectName() {
-    return this.projectName;
+  /**
+   * Load raw session data from session files
+   */
+  async loadRecentSessions(count = RECENT_SESSIONS_FOR_ANALYSIS) {
+    if (!existsSync4(this.sessionsDir)) {
+      return [];
+    }
+    const files = await readdir2(this.sessionsDir);
+    const jsonFiles = files.filter((f) => f.endsWith(".json")).slice(-count);
+    const sessions = [];
+    for (const file of jsonFiles) {
+      try {
+        const content = await readFile4(join4(this.sessionsDir, file), "utf-8");
+        sessions.push(JSON.parse(content));
+      } catch {
+      }
+    }
+    return sessions.sort(
+      (a, b) => new Date(b.startTime).getTime() - new Date(a.startTime).getTime()
+    );
   }
-  getStatePath() {
-    return this.statePath;
+  /**
+   * Analyze cross-session patterns
+   */
+  /**
+   * Analyze cross-session patterns
+   */
+  async analyzeCrossSessionPatterns() {
+    const memories = await this.getRecentMemories();
+    if (memories.length < 3) {
+      return [];
+    }
+    const lastSeen = memories[memories.length - 1].endTime;
+    const patterns = [
+      ...this.detectWorkflowPatterns(memories, lastSeen),
+      ...this.detectTimeBasedPatterns(memories, lastSeen),
+      ...this.detectFocusPatterns(memories, lastSeen),
+      ...this.detectToolCombinationPatterns(memories, lastSeen)
+    ];
+    return patterns.sort((a, b) => b.confidence - a.confidence).slice(0, 10);
+  }
+  detectWorkflowPatterns(memories, lastSeen) {
+    const patterns = [];
+    const domainSequences = /* @__PURE__ */ new Map();
+    for (const memory of memories) {
+      const key = memory.summary.dominantDomains.join(" \u2192 ");
+      if (key) {
+        const existing = domainSequences.get(key) || { count: 0, sessions: [] };
+        existing.count++;
+        existing.sessions.push(memory.sessionId);
+        domainSequences.set(key, existing);
+      }
+    }
+    for (const [sequence, data] of domainSequences) {
+      if (data.count >= 2) {
+        patterns.push({
+          id: `workflow-${generateId(8)}`,
+          type: "workflow",
+          description: `Workflow pattern: ${sequence}`,
+          frequency: data.count,
+          confidence: Math.min(0.9, 0.5 + data.count * 0.1),
+          sessionIds: data.sessions,
+          lastSeen
+        });
+      }
+    }
+    return patterns;
+  }
+  detectTimeBasedPatterns(memories, lastSeen) {
+    const patterns = [];
+    const hourCounts = /* @__PURE__ */ new Map();
+    for (const memory of memories) {
+      const hour = new Date(memory.startTime).getHours();
+      const bucket = Math.floor(hour / 3) * 3;
+      const existing = hourCounts.get(bucket) || { count: 0, sessions: [] };
+      existing.count++;
+      existing.sessions.push(memory.sessionId);
+      hourCounts.set(bucket, existing);
+    }
+    for (const [bucket, data] of hourCounts) {
+      if (data.count >= 3) {
+        const timeLabel = `${bucket}:00-${bucket + 3}:00`;
+        patterns.push({
+          id: `time-${bucket}`,
+          type: "time",
+          description: `Peak activity window: ${timeLabel}`,
+          frequency: data.count,
+          confidence: Math.min(0.8, data.count / memories.length),
+          sessionIds: data.sessions,
+          lastSeen
+        });
+      }
+    }
+    return patterns;
+  }
+  detectFocusPatterns(memories, lastSeen) {
+    const patterns = [];
+    const focusCounts = /* @__PURE__ */ new Map();
+    for (const memory of memories) {
+      if (memory.context.focus) {
+        const existing = focusCounts.get(memory.context.focus) || { count: 0, sessions: [] };
+        existing.count++;
+        existing.sessions.push(memory.sessionId);
+        focusCounts.set(memory.context.focus, existing);
+      }
+    }
+    for (const [focus, data] of focusCounts) {
+      if (data.count >= 2) {
+        patterns.push({
+          id: `focus-${generateId(8)}`,
+          type: "focus",
+          description: `Repeated focus: ${focus}`,
+          frequency: data.count,
+          confidence: Math.min(0.85, 0.5 + data.count * 0.15),
+          sessionIds: data.sessions,
+          lastSeen
+        });
+      }
+    }
+    return patterns;
+  }
+  detectToolCombinationPatterns(memories, lastSeen) {
+    const patterns = [];
+    const toolCombos = /* @__PURE__ */ new Map();
+    for (const memory of memories) {
+      if (memory.summary.patterns.length >= 2) {
+        const key = memory.summary.patterns.slice(0, 3).join("+");
+        const existing = toolCombos.get(key) || { count: 0, sessions: [] };
+        existing.count++;
+        existing.sessions.push(memory.sessionId);
+        toolCombos.set(key, existing);
+      }
+    }
+    for (const [combo, data] of toolCombos) {
+      if (data.count >= 2) {
+        patterns.push({
+          id: `combo-${generateId(8)}`,
+          type: "tool-combo",
+          description: `Tool combination: ${combo}`,
+          frequency: data.count,
+          confidence: Math.min(0.8, 0.5 + data.count * 0.1),
+          sessionIds: data.sessions,
+          lastSeen
+        });
+      }
+    }
+    return patterns;
+  }
+  /**
+   * Get context summary for the current session
+   */
+  async getContextSummary() {
+    const memories = await this.getRecentMemories(5);
+    if (memories.length === 0) {
+      return "No previous session context available.";
+    }
+    const parts = [];
+    const last = memories[memories.length - 1];
+    const lastDate = new Date(last.endTime);
+    const hoursAgo = Math.round((Date.now() - lastDate.getTime()) / (1e3 * 60 * 60));
+    parts.push(`Last session: ${hoursAgo}h ago, ${last.summary.toolCalls} tool calls`);
+    const allDomains = memories.flatMap((m) => m.summary.dominantDomains);
+    const domainCounts = /* @__PURE__ */ new Map();
+    for (const d of allDomains) {
+      domainCounts.set(d, (domainCounts.get(d) || 0) + 1);
+    }
+    const topDomains = [...domainCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3).map(([d]) => d);
+    if (topDomains.length > 0) {
+      parts.push(`Focus areas: ${topDomains.join(", ")}`);
+    }
+    const crossPatterns = await this.analyzeCrossSessionPatterns();
+    if (crossPatterns.length > 0) {
+      const topPattern = crossPatterns[0];
+      parts.push(`Notable pattern: ${topPattern.description} (${topPattern.frequency}x)`);
+    }
+    return parts.join("\n");
+  }
+  /**
+   * Get session continuity hints for the AI
+   */
+  async getContinuityHints() {
+    const memories = await this.getRecentMemories(3);
+    const hints = [];
+    if (memories.length === 0) {
+      return hints;
+    }
+    const last = memories[memories.length - 1];
+    if (last.summary.filesEdited.length > 0) {
+      const recentFiles = last.summary.filesEdited.slice(0, 3);
+      hints.push(`Recent files: ${recentFiles.map((f) => f.split("/").pop()).join(", ")}`);
+    }
+    if (last.context.focus) {
+      hints.push(`Previous focus: ${last.context.focus}`);
+    }
+    if (last.durationMs < 5 * 60 * 1e3 && last.summary.toolCalls < 5) {
+      hints.push("Previous session was brief - may have unfinished work");
+    }
+    return hints;
   }
 };
-
-// src/tools.ts
-import { readdir, writeFile as writeFile3 } from "fs/promises";
-import { tool } from "@opencode-ai/plugin";
-import { format as format2 } from "date-fns";
-
-// src/evolution.ts
-import { existsSync as existsSync3 } from "fs";
-import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
-import { join as join3 } from "path";
-var BUILTIN_TOOLS = /* @__PURE__ */ new Set([
-  "read",
-  "write",
-  "edit",
-  "bash",
-  "grep",
-  "glob",
-  "serena_list_dir",
-  "serena_find_file",
-  "serena_search_for_pattern",
-  "serena_get_symbols_overview",
-  "serena_find_symbol",
-  "serena_find_referencing_symbols",
-  "serena_replace_symbol_body",
-  "serena_insert_after_symbol",
-  "serena_insert_before_symbol",
-  "serena_replace_content",
-  "serena_rename_symbol",
-  "lsp_diagnostics",
-  "lsp_goto_definition",
-  "lsp_find_references",
-  "lsp_prepare_rename",
-  "lsp_rename",
-  "lsp_symbols",
-  "delegate_task",
-  "task",
-  "question",
-  "background_cancel",
-  "background_output",
-  "skill",
-  "slashcommand",
-  "use_skill",
-  "find_skills",
-  "session_list",
-  "session_read",
-  "session_search",
-  "session_info",
-  "mimic:"
-]);
-function generateToolCode(name, description, pattern) {
-  const funcName = name.replace(/-/g, "_");
-  return `// \u{1F4E6} Auto-generated by Mimic
-// Pattern: ${pattern.description} (${pattern.count}x)
-// Generated: ${(/* @__PURE__ */ new Date()).toISOString()}
-
-export const ${funcName} = (plugin) => ({
-  tool: {
-    "${name}": {
-      description: "${description}",
-      args: {},
-      async execute() {
-        // TODO: Implement your logic here
-        // This was generated from pattern: ${pattern.description}
-        return "\u{1F4E6} ${name} executed!";
-      },
-    },
-  },
-});
-
-export default ${funcName};
-`;
-}
-function generateHookCode(name, _description, pattern) {
-  const filename = pattern.description;
-  return `// \u{1F4E6} Auto-generated by Mimic
-// Pattern: ${pattern.description} (${pattern.count}x)
-// Generated: ${(/* @__PURE__ */ new Date()).toISOString()}
-
-export const ${name.replace(/-/g, "_")} = (plugin) => ({
-  async event({ event }) {
-    if (event.type === "file.edited") {
-      const filename = event.properties?.filename;
-      if (filename?.includes("${filename}")) {
-        console.log("\u{1F4E6} [Mimic] Detected change in watched file: ${filename}");
-        // TODO: Add your custom logic here
+function detectDomainsFromTools(tools) {
+  const domainScores = /* @__PURE__ */ new Map();
+  const toolDomainMap = {
+    // Testing
+    vitest: "testing",
+    jest: "testing",
+    test: "testing",
+    // Git
+    git: "git",
+    commit: "git",
+    push: "git",
+    // Debugging
+    debug: "debugging",
+    log: "debugging",
+    trace: "debugging",
+    // File organization
+    mkdir: "file-organization",
+    mv: "file-organization",
+    rename: "file-organization",
+    // Tooling
+    npm: "tooling",
+    pnpm: "tooling",
+    yarn: "tooling",
+    // Refactoring
+    refactor: "refactoring",
+    extract: "refactoring",
+    // Documentation
+    doc: "documentation",
+    readme: "documentation",
+    // Code style
+    lint: "code-style",
+    format: "code-style",
+    prettier: "code-style",
+    eslint: "code-style",
+    biome: "code-style"
+  };
+  for (const tool8 of tools) {
+    const lower = tool8.toLowerCase();
+    for (const [keyword, domain] of Object.entries(toolDomainMap)) {
+      if (lower.includes(keyword)) {
+        domainScores.set(domain, (domainScores.get(domain) || 0) + 1);
       }
     }
-  },
-});
-
-export default ${name.replace(/-/g, "_")};
-`;
+  }
+  return [...domainScores.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3).map(([d]) => d);
 }
-function generateSkillCode(name, description, pattern) {
-  return `// \u{1F4E6} Auto-generated by Mimic
-// Pattern: ${pattern.description} (${pattern.count}x)
-// Generated: ${(/* @__PURE__ */ new Date()).toISOString()}
 
-export const ${name.replace(/-/g, "_")} = (plugin) => ({
-  async event({ event }) {
-    // Auto-triggered skill: ${description}
-    if (event.type === "session.created") {
-      console.log("\u{1F4E6} [Mimic] Skill ${name} activated");
-      // TODO: Implement automated behavior
+// src/modules/knowledge/skills.ts
+import { existsSync as existsSync5 } from "fs";
+import { mkdir as mkdir3, writeFile as writeFile4 } from "fs/promises";
+import { join as join5 } from "path";
+var SkillGenerator = class {
+  skillsDir;
+  constructor(directory) {
+    this.skillsDir = join5(directory, ".opencode", "skills");
+  }
+  /**
+   * Initialize skills directory
+   */
+  async initialize() {
+    if (!existsSync5(this.skillsDir)) {
+      await mkdir3(this.skillsDir, { recursive: true });
     }
-  },
-});
-
-export default ${name.replace(/-/g, "_")};
-`;
-}
-function generateMcpConfig(name, _description, pattern) {
-  return {
-    [name]: {
-      type: "local",
-      command: ["echo", `MCP server for ${pattern.description}`],
-      enabled: false
+  }
+  /**
+   * Generate a skill from a cluster of instincts
+   */
+  async generateSkill(name, description, domain, instincts, patterns) {
+    const skillDir = join5(this.skillsDir, name);
+    if (!existsSync5(skillDir)) {
+      await mkdir3(skillDir, { recursive: true });
     }
-  };
-}
-function generateAgentMarkdown(name, description, pattern) {
-  return `---
-description: ${description}
-mode: subagent
+    const metadata = {
+      name,
+      description,
+      trigger: "auto",
+      domain,
+      tools: this.inferTools(patterns)
+    };
+    const content = this.generateSkillMarkdown(metadata, instincts, patterns);
+    const skillPath = join5(skillDir, "SKILL.md");
+    await writeFile4(skillPath, content, "utf-8");
+    return {
+      name,
+      path: skillPath,
+      metadata,
+      content
+    };
+  }
+  /**
+   * Generate markdown content for a skill
+   */
+  generateSkillMarkdown(metadata, instincts, patterns) {
+    const toolsYaml = metadata.tools ? Object.entries(metadata.tools).map(([tool8, enabled]) => `  ${tool8}: ${enabled}`).join("\n") : "  # No specific tools defined";
+    const instinctsList = instincts.slice(0, 10).map(
+      (i) => `- **${i.title}** (${Math.round(i.confidence * 100)}% confidence)
+  ${i.description}`
+    ).join("\n");
+    const patternsList = patterns.slice(0, 5).map((p) => `- ${p.type}: ${p.description} (${p.count}x observed)`).join("\n");
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return `---
+name: ${metadata.name}
+description: ${metadata.description}
+trigger: ${metadata.trigger}
+domain: ${metadata.domain}
 tools:
-  read: true
-  glob: true
-  grep: true
-  bash: false
-  edit: false
+${toolsYaml}
+generated: ${now}
 ---
 
-# \u{1F4E6} ${name}
+# ${metadata.name}
 
-Auto-generated by Mimic from pattern: ${pattern.description} (${pattern.count}x)
+${metadata.description}
 
-## Focus Area
+> [!NOTE]
+> This skill was auto-generated by Mimic based on observed patterns and learned instincts.
 
-This agent specializes in tasks related to: ${pattern.description}
+## Overview
+
+This skill encapsulates learned behaviors from repeated usage patterns in the **${metadata.domain}** domain.
+
+## Learned Behaviors
+
+${instinctsList || "No instincts documented yet."}
+
+## Observed Patterns
+
+${patternsList || "No patterns documented yet."}
+
+## Usage Guidelines
+
+### When to Apply
+
+This skill should be activated when:
+${this.generateUsageConditions(metadata.domain, patterns)}
+
+### Best Practices
+
+${this.generateBestPractices(metadata.domain, instincts)}
 
 ## Context
 
-- Pattern detected: ${pattern.type}
-- Usage count: ${pattern.count}
-- First seen: ${new Date(pattern.firstSeen).toISOString()}
+- **Domain**: ${metadata.domain}
+- **Generated**: ${now}
+- **Instincts Used**: ${instincts.length}
+- **Patterns Analyzed**: ${patterns.length}
 
-## How To Help
+## Customization
 
-Analyze and assist with tasks matching this pattern.
-Provide focused, expert guidance in this specific area.
+You can customize this skill by editing the frontmatter or adding additional sections below.
 
-## Remember
+---
 
-- Stay focused on the pattern's domain
-- Leverage the observed usage patterns
-- Adapt to the user's workflow
+*Generated by [opencode-plugin-mimic](https://github.com/gracefullight/pkgs)*
 `;
-}
-async function readOpencodeConfig(configPath) {
-  if (!existsSync3(configPath)) return {};
-  try {
-    const parsed = JSON.parse(await readFile3(configPath, "utf-8"));
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-      return {};
+  }
+  /**
+   * Generate usage conditions based on domain and patterns
+   */
+  generateUsageConditions(domain, patterns) {
+    const conditions = [];
+    switch (domain) {
+      case "testing":
+        conditions.push("- Working with test files (*.test.ts, *.spec.ts)");
+        conditions.push("- Running test suites or debugging test failures");
+        break;
+      case "git":
+        conditions.push("- Preparing commits or managing branches");
+        conditions.push("- Reviewing code changes before push");
+        break;
+      case "debugging":
+        conditions.push("- Investigating errors or unexpected behavior");
+        conditions.push("- Adding logging or tracing code");
+        break;
+      case "code-style":
+        conditions.push("- Formatting or linting code");
+        conditions.push("- Enforcing coding conventions");
+        break;
+      case "refactoring":
+        conditions.push("- Restructuring code without changing behavior");
+        conditions.push("- Extracting functions or classes");
+        break;
+      case "documentation":
+        conditions.push("- Writing or updating documentation");
+        conditions.push("- Adding code comments or JSDoc");
+        break;
+      case "file-organization":
+        conditions.push("- Moving or renaming files");
+        conditions.push("- Organizing project structure");
+        break;
+      case "tooling":
+        conditions.push("- Configuring build tools or scripts");
+        conditions.push("- Managing dependencies");
+        break;
+      default:
+        conditions.push("- General development tasks");
     }
-    return parsed;
+    for (const pattern of patterns.slice(0, 3)) {
+      if (pattern.type === "sequence") {
+        conditions.push(`- Executing workflow: ${pattern.description}`);
+      } else if (pattern.type === "file") {
+        conditions.push(`- Working with: ${pattern.description}`);
+      }
+    }
+    return conditions.join("\n");
+  }
+  /**
+   * Generate best practices from instincts
+   */
+  generateBestPractices(domain, instincts) {
+    const practices = [];
+    for (const instinct of instincts.filter((i) => i.confidence >= 0.7).slice(0, 5)) {
+      practices.push(`1. ${instinct.title}`);
+    }
+    if (practices.length === 0) {
+      switch (domain) {
+        case "testing":
+          practices.push("1. Write tests before implementation (TDD)");
+          practices.push("2. Ensure high test coverage for critical paths");
+          break;
+        case "git":
+          practices.push("1. Write clear, conventional commit messages");
+          practices.push("2. Review changes before committing");
+          break;
+        case "code-style":
+          practices.push("1. Follow established project conventions");
+          practices.push("2. Run linters before committing");
+          break;
+        default:
+          practices.push("1. Follow project conventions");
+          practices.push("2. Document significant changes");
+      }
+    }
+    return practices.join("\n");
+  }
+  /**
+   * Infer required tools from patterns
+   */
+  inferTools(patterns) {
+    const tools = {
+      read: true,
+      glob: true,
+      grep: true
+    };
+    for (const pattern of patterns) {
+      const desc = pattern.description.toLowerCase();
+      if (desc.includes("edit") || desc.includes("write") || desc.includes("modify")) {
+        tools.edit = true;
+      }
+      if (desc.includes("bash") || desc.includes("shell") || desc.includes("npm") || desc.includes("pnpm")) {
+        tools.bash = true;
+      }
+      if (desc.includes("test") || desc.includes("vitest") || desc.includes("jest")) {
+        tools.bash = true;
+      }
+    }
+    return tools;
+  }
+  /**
+   * Generate skill from an evolved capability
+   */
+  async fromCapability(ctx, capability) {
+    const state = await ctx.stateManager.read();
+    const instincts = await ctx.stateManager.listInstincts();
+    const pattern = state.patterns.find((p) => p.id === capability.fromPattern);
+    if (!pattern) {
+      return null;
+    }
+    const domainInstincts = instincts.filter((i) => {
+      if (i.evidence.patternIDs.includes(pattern.id)) return true;
+      return false;
+    });
+    const domain = domainInstincts[0]?.domain || "other";
+    return this.generateSkill(capability.name, capability.description, domain, domainInstincts, [
+      pattern
+    ]);
+  }
+  /**
+   * Generate skills for all eligible domains
+   */
+  async generateAllEligibleSkills(ctx) {
+    const instincts = await ctx.stateManager.listInstincts();
+    const state = await ctx.stateManager.read();
+    const skills = [];
+    const byDomain = /* @__PURE__ */ new Map();
+    for (const instinct of instincts) {
+      if (instinct.status !== "approved" || instinct.confidence < 0.6) continue;
+      const list = byDomain.get(instinct.domain) || [];
+      list.push(instinct);
+      byDomain.set(instinct.domain, list);
+    }
+    for (const [domain, domainInstincts] of byDomain) {
+      if (domainInstincts.length < 5) continue;
+      const name = `${domain}-specialist`;
+      const description = ctx.i18n.t("skill.domain_description", { domain });
+      const patternIds = new Set(domainInstincts.flatMap((i) => i.evidence.patternIDs));
+      const patterns = state.patterns.filter((p) => patternIds.has(p.id));
+      try {
+        const skill = await this.generateSkill(
+          name,
+          description,
+          domain,
+          domainInstincts,
+          patterns
+        );
+        skills.push(skill);
+      } catch {
+      }
+    }
+    return skills;
+  }
+};
+
+// src/modules/observation/log.ts
+import { existsSync as existsSync6 } from "fs";
+import { appendFile, mkdir as mkdir4, readFile as readFile5, stat, writeFile as writeFile5 } from "fs/promises";
+import { join as join6 } from "path";
+var ARCHIVE_THRESHOLD = 5 * 1024 * 1024;
+var ObservationLog = class {
+  logPath;
+  archiveDir;
+  constructor(mimicDir) {
+    this.logPath = join6(mimicDir, "observations.jsonl");
+    this.archiveDir = join6(mimicDir, "archives");
+  }
+  /**
+   * Initialize the observation log directory structure
+   */
+  async initialize() {
+    const dir = join6(this.logPath, "..");
+    if (!existsSync6(dir)) {
+      await mkdir4(dir, { recursive: true });
+    }
+    if (!existsSync6(this.archiveDir)) {
+      await mkdir4(this.archiveDir, { recursive: true });
+    }
+  }
+  /**
+   * Append a new observation entry to the log
+   */
+  async append(entry) {
+    const fullEntry = {
+      id: generateId(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      ...entry
+    };
+    const line = `${JSON.stringify(fullEntry)}
+`;
+    await appendFile(this.logPath, line, "utf-8");
+    await this.maybeRotate();
+    return fullEntry;
+  }
+  /**
+   * Log a tool call observation
+   */
+  async logToolCall(tool8, callId, sessionId, args) {
+    return this.append({
+      type: "tool.call",
+      sessionId,
+      data: { tool: tool8, callId, args }
+    });
+  }
+  /**
+   * Log a user message observation
+   */
+  async logUserMessage(sessionId, messageId, textPreview) {
+    return this.append({
+      type: "message.user",
+      sessionId,
+      data: {
+        messageId,
+        // Only store first 200 chars to avoid storing sensitive data
+        textPreview: textPreview?.slice(0, 200)
+      }
+    });
+  }
+  /**
+   * Log an assistant message observation
+   */
+  async logAssistantMessage(sessionId, messageId, tokensUsed) {
+    return this.append({
+      type: "message.assistant",
+      sessionId,
+      data: { messageId, tokensUsed }
+    });
+  }
+  /**
+   * Log a file edit observation
+   */
+  async logFileEdit(file, sessionId) {
+    return this.append({
+      type: "file.edit",
+      sessionId,
+      data: { file, extension: file.split(".").pop() }
+    });
+  }
+  /**
+   * Log a command execution observation
+   */
+  async logCommand(command, sessionId, args) {
+    return this.append({
+      type: "command",
+      sessionId,
+      data: { command, args }
+    });
+  }
+  /**
+   * Log a VCS branch change observation
+   */
+  async logBranchChange(branch) {
+    return this.append({
+      type: "vcs.branch",
+      data: { branch }
+    });
+  }
+  /**
+   * Log a session start observation
+   */
+  async logSessionStart(sessionId) {
+    return this.append({
+      type: "session.start",
+      sessionId,
+      data: {}
+    });
+  }
+  /**
+   * Log a session end observation
+   */
+  async logSessionEnd(sessionId, durationMs, toolCallCount) {
+    return this.append({
+      type: "session.end",
+      sessionId,
+      data: { durationMs, toolCallCount }
+    });
+  }
+  /**
+   * Query observations with filters
+   */
+  async query(options = {}) {
+    if (!existsSync6(this.logPath)) {
+      return [];
+    }
+    const content = await readFile5(this.logPath, "utf-8");
+    const lines = content.trim().split("\n").filter(Boolean);
+    let entries = [];
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        entries.push(entry);
+      } catch {
+      }
+    }
+    const filterTypes = options.types;
+    if (filterTypes && filterTypes.length > 0) {
+      entries = entries.filter((e) => filterTypes.includes(e.type));
+    }
+    if (options.sessionId) {
+      entries = entries.filter((e) => e.sessionId === options.sessionId);
+    }
+    if (options.startDate) {
+      const start = options.startDate.getTime();
+      entries = entries.filter((e) => new Date(e.timestamp).getTime() >= start);
+    }
+    if (options.endDate) {
+      const end = options.endDate.getTime();
+      entries = entries.filter((e) => new Date(e.timestamp).getTime() <= end);
+    }
+    entries.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+    if (options.limit && options.limit > 0) {
+      entries = entries.slice(0, options.limit);
+    }
+    return entries;
+  }
+  /**
+   * Get observations from the last N days
+   */
+  async getRecentObservations(days, types) {
+    const startDate = /* @__PURE__ */ new Date();
+    startDate.setDate(startDate.getDate() - days);
+    return this.query({ startDate, types });
+  }
+  /**
+   * Get observation count by type
+   */
+  async getStats() {
+    const entries = await this.query();
+    const stats = {};
+    for (const entry of entries) {
+      stats[entry.type] = (stats[entry.type] || 0) + 1;
+    }
+    return stats;
+  }
+  /**
+   * Check and rotate log file if it exceeds threshold
+   */
+  async maybeRotate() {
+    if (!existsSync6(this.logPath)) {
+      return false;
+    }
+    const stats = await stat(this.logPath);
+    if (stats.size < ARCHIVE_THRESHOLD) {
+      return false;
+    }
+    const archiveName = `observations-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.jsonl`;
+    const archivePath = join6(this.archiveDir, archiveName);
+    const content = await readFile5(this.logPath, "utf-8");
+    await writeFile5(archivePath, content, "utf-8");
+    await writeFile5(this.logPath, "", "utf-8");
+    return true;
+  }
+  /**
+   * Prune old observations (keep last N days)
+   */
+  async prune(keepDays) {
+    const entries = await this.query();
+    const cutoff = /* @__PURE__ */ new Date();
+    cutoff.setDate(cutoff.getDate() - keepDays);
+    const cutoffTime = cutoff.getTime();
+    const keep = entries.filter((e) => new Date(e.timestamp).getTime() >= cutoffTime);
+    const pruned = entries.length - keep.length;
+    if (pruned > 0) {
+      const content = `${keep.map((e) => JSON.stringify(e)).join("\n")}
+`;
+      await writeFile5(this.logPath, content, "utf-8");
+    }
+    return pruned;
+  }
+  /**
+   * Get the current log file size in bytes
+   */
+  async getLogSize() {
+    if (!existsSync6(this.logPath)) {
+      return 0;
+    }
+    const stats = await stat(this.logPath);
+    return stats.size;
+  }
+};
+
+// src/modules/observation/observer.ts
+var MAX_INSTINCTS_PER_RUN = 5;
+var OBSERVER_COOLDOWN_MS = 10 * 60 * 1e3;
+var DEFAULT_OBSERVER_MODEL = "opencode/glm-4.7-free";
+var DEFAULT_OBSERVER_PROVIDER = "opencode";
+function buildObserverPrompt(input) {
+  const patternsSummary = input.patterns.slice(0, 20).map((p) => `- [${p.type}] ${p.description} (${p.count}x, surfaced: ${p.surfaced})`).join("\n");
+  const observationsSummary = input.observations.slice(0, 50).join("\n");
+  const filesSummary = input.statistics.topFiles.slice(0, 10).map(([file, count]) => `- ${file}: ${count}x`).join("\n");
+  return `You are an observer agent that analyzes developer behavior patterns to create "instincts" - learned behaviors that can help automate workflows.
+
+## Current Data
+
+### Patterns (${input.patterns.length} total)
+${patternsSummary || "No patterns detected yet."}
+
+### Recent Observations (${input.observations.length} total)
+${observationsSummary || "No observations yet."}
+
+### Statistics
+- Total sessions: ${input.statistics.totalSessions}
+- Total tool calls: ${input.statistics.totalToolCalls}
+
+### Most Modified Files
+${filesSummary || "No file modifications recorded."}
+
+## Your Task
+
+Analyze the patterns and observations to identify 1-5 behavioral "instincts" the developer has. Look for:
+
+1. **Repeated Sequences**: Same tools used in order 3+ times
+2. **Preferences**: Certain tools always chosen over alternatives
+3. **Code Style Patterns**: Consistent patterns in file modifications
+4. **Workflow Patterns**: Common sequences of actions
+5. **Testing Habits**: How tests are written/run
+6. **Git Patterns**: Commit message styles, branching habits
+
+## Output Format
+
+Return a JSON array of instincts. Each instinct should have:
+- title: Short descriptive name (max 50 chars)
+- description: What this instinct represents (max 200 chars)
+- domain: One of: code-style, testing, git, debugging, file-organization, tooling, refactoring, documentation, other
+- confidence: 0.3-0.9 based on evidence strength
+- patternIDs: Array of pattern IDs that support this instinct
+
+Example output:
+\`\`\`json
+[
+  {
+    "title": "Prefers vitest for testing",
+    "description": "Consistently uses vitest over jest for running tests, with watch mode preferred",
+    "domain": "testing",
+    "confidence": 0.75,
+    "patternIDs": ["abc123", "def456"]
+  }
+]
+\`\`\`
+
+IMPORTANT:
+- Only return the JSON array, no other text
+- Minimum 3 occurrences for behavioral instincts
+- Keep confidence calibrated - don't overstate
+- Avoid duplicating obvious patterns
+- Focus on actionable insights
+
+Return your analysis:`;
+}
+function parseInstinctsFromResponse(response) {
+  try {
+    const jsonMatch = response.match(/```json\s*([\s\S]*?)\s*```/) || response.match(/\[[\s\S]*\]/);
+    if (!jsonMatch) {
+      return [];
+    }
+    const jsonStr = jsonMatch[1] || jsonMatch[0];
+    const parsed = JSON.parse(jsonStr);
+    if (!Array.isArray(parsed)) {
+      return [];
+    }
+    return parsed.filter(
+      (item) => typeof item.title === "string" && typeof item.description === "string" && typeof item.domain === "string" && typeof item.confidence === "number"
+    ).map((item) => ({
+      ...item,
+      patternIDs: Array.isArray(item.patternIDs) ? item.patternIDs : [],
+      confidence: Math.min(0.9, Math.max(0.3, item.confidence))
+    })).slice(0, MAX_INSTINCTS_PER_RUN);
   } catch {
-    return {};
+    return [];
   }
 }
-async function buildMcpEvolution(ctx, suggestion) {
-  const opencodeDir = join3(ctx.directory, ".opencode");
-  if (!existsSync3(opencodeDir)) {
-    await mkdir2(opencodeDir, { recursive: true });
+function analyzePatterns(input) {
+  const instincts = [
+    ...extractToolInstincts(input.patterns),
+    ...extractFileInstincts(input.patterns),
+    ...extractCommitInstincts(input.patterns),
+    ...extractSequenceInstincts(input.patterns),
+    ...extractHotspotInstincts(input.statistics.topFiles)
+  ];
+  return instincts.slice(0, MAX_INSTINCTS_PER_RUN);
+}
+function extractToolInstincts(patterns) {
+  const toolPatterns = patterns.filter((p) => p.type === "tool" && p.count >= 5);
+  if (toolPatterns.length < 3) return [];
+  const topTools = toolPatterns.sort((a, b) => b.count - a.count).slice(0, 5).map((p) => p.description);
+  return [
+    {
+      title: `Preferred tools: ${topTools.slice(0, 3).join(", ")}`,
+      description: `Frequently uses ${topTools.join(", ")} based on ${toolPatterns.reduce((sum, p) => sum + p.count, 0)} observations`,
+      domain: "tooling",
+      confidence: Math.min(0.9, 0.5 + toolPatterns.length * 0.1),
+      patternIDs: toolPatterns.map((p) => p.id)
+    }
+  ];
+}
+function extractFileInstincts(patterns) {
+  const filePatterns = patterns.filter((p) => p.type === "file" && p.count >= 5);
+  if (filePatterns.length < 2) return [];
+  const extensions = /* @__PURE__ */ new Set();
+  for (const p of filePatterns) {
+    const ext = p.description.split(".").pop();
+    if (ext) extensions.add(ext);
   }
-  const configPath = join3(ctx.directory, "opencode.json");
-  const config = await readOpencodeConfig(configPath);
-  const mcpConfig = generateMcpConfig(suggestion.name, suggestion.description, suggestion.pattern);
-  const mcp = { ...config.mcp || {}, ...mcpConfig };
-  const content = JSON.stringify({ ...config, mcp }, null, 2);
-  return { filePath: configPath, content };
+  return [
+    {
+      title: `Focus on ${Array.from(extensions).slice(0, 3).join(", ")} files`,
+      description: `Frequently modifies files with extensions: ${Array.from(extensions).join(", ")}`,
+      domain: "file-organization",
+      confidence: Math.min(0.85, 0.5 + filePatterns.length * 0.08),
+      patternIDs: filePatterns.map((p) => p.id)
+    }
+  ];
 }
-async function buildAgentEvolution(ctx, suggestion) {
-  const agentsDir = join3(ctx.directory, ".opencode", "agents");
-  if (!existsSync3(agentsDir)) {
-    await mkdir2(agentsDir, { recursive: true });
+function extractCommitInstincts(patterns) {
+  const commitPatterns = patterns.filter((p) => p.type === "commit" && p.count >= 3);
+  if (commitPatterns.length < 2) return [];
+  const prefixes = commitPatterns.map((p) => p.description.split(":")[0] || p.description.split(" ")[0]).filter(Boolean);
+  const uniquePrefixes = [...new Set(prefixes)];
+  if (uniquePrefixes.length === 0) return [];
+  return [
+    {
+      title: `Commit style: ${uniquePrefixes.slice(0, 3).join(", ")}`,
+      description: `Uses commit message patterns like: ${uniquePrefixes.join(", ")}`,
+      domain: "git",
+      confidence: Math.min(0.8, 0.5 + commitPatterns.length * 0.1),
+      patternIDs: commitPatterns.map((p) => p.id)
+    }
+  ];
+}
+function extractSequenceInstincts(patterns) {
+  const sequencePatterns = patterns.filter((p) => p.type === "sequence" && p.count >= 3);
+  const instincts = [];
+  for (const seq of sequencePatterns.slice(0, 2)) {
+    let domain = "tooling";
+    const desc = seq.description.toLowerCase();
+    if (desc.includes("test")) domain = "testing";
+    else if (desc.includes("debug") || desc.includes("error")) domain = "debugging";
+    else if (desc.includes("refactor")) domain = "refactoring";
+    instincts.push({
+      title: `Workflow: ${seq.description}`,
+      description: `Repeats sequence "${seq.description}" (${seq.count}x observed)`,
+      domain,
+      confidence: Math.min(0.85, 0.5 + seq.count * 0.05),
+      patternIDs: [seq.id]
+    });
   }
-  return {
-    content: generateAgentMarkdown(suggestion.name, suggestion.description, suggestion.pattern),
-    filePath: join3(agentsDir, `${suggestion.name}.md`)
-  };
+  return instincts;
 }
-function buildPluginContent(suggestion) {
-  switch (suggestion.type) {
-    case "command":
-    case "shortcut":
-      return generateToolCode(suggestion.name, suggestion.description, suggestion.pattern);
-    case "hook":
-      return generateHookCode(suggestion.name, suggestion.description, suggestion.pattern);
-    case "skill":
-      return generateSkillCode(suggestion.name, suggestion.description, suggestion.pattern);
-    default:
-      return generateToolCode(suggestion.name, suggestion.description, suggestion.pattern);
+function extractHotspotInstincts(topFiles) {
+  if (topFiles.length < 3) return [];
+  const hotspots = topFiles.slice(0, 5);
+  const totalMods = hotspots.reduce((sum, [, count]) => sum + count, 0);
+  if (totalMods < 10) return [];
+  return [
+    {
+      title: "Hotspot files identified",
+      description: `Frequently modified files: ${hotspots.map(([f]) => f.split("/").pop()).join(", ")}`,
+      domain: "file-organization",
+      confidence: Math.min(0.75, 0.4 + totalMods * 0.02),
+      patternIDs: []
+    }
+  ];
+}
+async function analyzePatternsWithLLM(ctx, input, config) {
+  if (!ctx.client) {
+    return analyzePatterns(input);
+  }
+  const observerConfig = "observer" in config ? config.observer : void 0;
+  const modelId = observerConfig?.model || DEFAULT_OBSERVER_MODEL;
+  const providerId = observerConfig?.provider || modelId.split("/")[0] || DEFAULT_OBSERVER_PROVIDER;
+  try {
+    const prompt = buildObserverPrompt(input);
+    const session = await ctx.client.session.create({
+      body: { title: "Mimic Observer Analysis" }
+    });
+    if (!session.data?.id) {
+      return analyzePatterns(input);
+    }
+    const response = await ctx.client.session.prompt({
+      path: { id: session.data.id },
+      body: {
+        model: {
+          providerID: providerId,
+          modelID: modelId
+        },
+        parts: [{ type: "text", text: prompt }]
+      }
+    });
+    const responseParts = response.data?.parts || [];
+    let responseText = "";
+    for (const part of responseParts) {
+      if ("text" in part && typeof part.text === "string") {
+        responseText = part.text;
+        break;
+      }
+    }
+    if (!responseText) {
+      await ctx.client.session.delete({ path: { id: session.data.id } }).catch(() => {
+      });
+      return analyzePatterns(input);
+    }
+    const llmInstincts = parseInstinctsFromResponse(responseText);
+    await ctx.client.session.delete({ path: { id: session.data.id } }).catch(() => {
+    });
+    return llmInstincts.length > 0 ? llmInstincts : analyzePatterns(input);
+  } catch {
+    return analyzePatterns(input);
   }
 }
-async function buildPluginEvolution(ctx, suggestion) {
-  const pluginsDir = join3(ctx.directory, ".opencode", "plugins");
-  if (!existsSync3(pluginsDir)) {
-    await mkdir2(pluginsDir, { recursive: true });
+async function shouldRunObserver(ctx) {
+  const state = await ctx.stateManager.read();
+  if (!state.preferences.learningEnabled) {
+    return false;
   }
-  return {
-    content: buildPluginContent(suggestion),
-    filePath: join3(pluginsDir, `${suggestion.name}.js`)
+  if (!state.evolution.lastObserverRun) {
+    return true;
+  }
+  const lastRun = new Date(state.evolution.lastObserverRun).getTime();
+  const now = Date.now();
+  return now - lastRun >= OBSERVER_COOLDOWN_MS;
+}
+async function runObserver(ctx) {
+  const state = await ctx.stateManager.read();
+  const config = await loadMimicConfig().catch(() => ({}));
+  const newInstincts = [];
+  const recentPatterns = state.patterns.filter((p) => {
+    const age = Date.now() - p.lastSeen;
+    return age < 7 * 24 * 60 * 60 * 1e3;
+  });
+  if (recentPatterns.length === 0) {
+    state.evolution.lastObserverRun = (/* @__PURE__ */ new Date()).toISOString();
+    await ctx.stateManager.save(state);
+    return [];
+  }
+  const mimicDir = ctx.stateManager.getInstinctsDir().replace("/instincts", "");
+  const observationLog = new ObservationLog(mimicDir);
+  const recentObs = await observationLog.getRecentObservations(7);
+  const observations = recentObs.map((o) => `[${o.type}] ${JSON.stringify(o.data)}`);
+  const topFiles = Object.entries(state.statistics.filesModified).sort(([, a], [, b]) => b - a).slice(0, 10);
+  const input = {
+    patterns: recentPatterns,
+    recentSessions: [],
+    observations,
+    statistics: {
+      totalSessions: state.statistics.totalSessions,
+      totalToolCalls: state.statistics.totalToolCalls,
+      topFiles
+    }
   };
+  const observerCfg = "observer" in config ? config.observer : void 0;
+  const useLLM = observerCfg?.enabled !== false && (observerCfg?.model || ctx.client);
+  const rawInstincts = useLLM ? await analyzePatternsWithLLM(ctx, input, config) : analyzePatterns(input);
+  for (const raw of rawInstincts) {
+    const domain = normalizeDomain(raw.domain);
+    const id = generateDeterministicId(domain, raw.title);
+    if (await ctx.stateManager.hasInstinct(id)) {
+      continue;
+    }
+    const instinct = {
+      id,
+      title: raw.title,
+      description: raw.description,
+      domain,
+      confidence: raw.confidence,
+      status: "approved",
+      source: "personal",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      evidence: {
+        patternIDs: raw.patternIDs
+      }
+    };
+    await ctx.stateManager.writeInstinct(instinct);
+    newInstincts.push(instinct);
+  }
+  state.evolution.lastObserverRun = (/* @__PURE__ */ new Date()).toISOString();
+  await ctx.stateManager.save(state);
+  return newInstincts;
 }
-async function buildEvolutionOutput(ctx, suggestion) {
-  if (suggestion.type === "mcp") {
-    return buildMcpEvolution(ctx, suggestion);
+
+// src/lib/git.ts
+import { execSync } from "child_process";
+function getGitHistory(directory, limit = 50) {
+  try {
+    const result = execSync(`git log --oneline -n ${limit}`, {
+      cwd: directory,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return result.trim().split("\n").filter(Boolean);
+  } catch {
+    return [];
   }
-  if (suggestion.type === "agent") {
-    return buildAgentEvolution(ctx, suggestion);
+}
+function getRecentlyModifiedFiles(directory) {
+  try {
+    const result = execSync(
+      "git diff --name-only HEAD~10 HEAD 2>/dev/null || git diff --name-only",
+      {
+        cwd: directory,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }
+    );
+    return result.trim().split("\n").filter(Boolean);
+  } catch {
+    return [];
   }
-  return buildPluginEvolution(ctx, suggestion);
 }
-function createCapabilityFromSuggestion(suggestion) {
-  return {
-    id: crypto.randomUUID(),
-    type: suggestion.type,
-    name: suggestion.name,
-    description: suggestion.description,
-    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-    fromPattern: suggestion.pattern.id
-  };
+function getCommitMessages(directory, limit = 20) {
+  try {
+    const result = execSync(`git log --format=%s -n ${limit}`, {
+      cwd: directory,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return result.trim().split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
 }
-function updateEvolutionState(state, capability, suggestion) {
-  state.evolution.capabilities.push(capability);
-  state.evolution.lastEvolution = (/* @__PURE__ */ new Date()).toISOString();
-  const pattern = state.patterns.find((p) => p.id === suggestion.pattern.id);
-  if (pattern) {
-    pattern.surfaced = true;
+function detectCommitPatterns(messages) {
+  const patterns = /* @__PURE__ */ new Map();
+  for (const msg of messages) {
+    const normalized = msg.toLowerCase().replace(/\s+/g, " ").trim();
+    patterns.set(normalized, (patterns.get(normalized) || 0) + 1);
   }
+  return patterns;
 }
-function suggestEvolution(pattern, ctx) {
-  switch (pattern.type) {
-    case "tool":
-      if (pattern.count >= 10) {
-        const toolName = pattern.description;
-        if (BUILTIN_TOOLS.has(toolName)) {
-          return null;
+
+// src/modules/observation/patterns.ts
+async function detectPatterns(ctx) {
+  const state = await ctx.stateManager.read();
+  const newPatterns = [];
+  const commitMessages = getCommitMessages(ctx.directory);
+  const commitPatterns = detectCommitPatterns(commitMessages);
+  for (const [msg, count] of commitPatterns) {
+    if (count >= 3) {
+      const existing = state.patterns.find((p) => p.type === "commit" && p.description === msg);
+      if (!existing) {
+        newPatterns.push({
+          id: generateId(),
+          type: "commit",
+          description: msg,
+          count,
+          firstSeen: Date.now(),
+          lastSeen: Date.now(),
+          surfaced: false,
+          examples: []
+        });
+      }
+    }
+  }
+  const fileStats = state.statistics.filesModified;
+  for (const [file, count] of Object.entries(fileStats)) {
+    if (count >= 5) {
+      const existing = state.patterns.find((p) => p.type === "file" && p.description === file);
+      if (!existing) {
+        newPatterns.push({
+          id: generateId(),
+          type: "file",
+          description: file,
+          count,
+          firstSeen: Date.now(),
+          lastSeen: Date.now(),
+          surfaced: false,
+          examples: []
+        });
+      }
+    }
+  }
+  return newPatterns;
+}
+async function surfacePatterns(ctx) {
+  const state = await ctx.stateManager.read();
+  const suggestions = [];
+  for (const pattern of state.patterns) {
+    if (pattern.surfaced) continue;
+    if (pattern.count < state.preferences.minPatternCount) continue;
+    let suggestion = "";
+    switch (pattern.type) {
+      case "commit":
+        suggestion = ctx.i18n.t("suggest.commit", {
+          pattern: pattern.description,
+          count: pattern.count
+        });
+        break;
+      case "file":
+        suggestion = ctx.i18n.t("suggest.file", {
+          pattern: pattern.description,
+          count: pattern.count
+        });
+        break;
+      case "tool":
+        suggestion = ctx.i18n.t("suggest.tool", {
+          pattern: pattern.description,
+          count: pattern.count
+        });
+        break;
+      case "sequence":
+        suggestion = ctx.i18n.t("suggest.sequence", {
+          pattern: pattern.description,
+          count: pattern.count
+        });
+        break;
+    }
+    suggestions.push(suggestion);
+  }
+  return suggestions;
+}
+
+// src/tools/automation.ts
+import { tool } from "@opencode-ai/plugin";
+var createAutomationTools = (ctx) => {
+  const { stateManager, directory, i18n, i18nPromise } = ctx;
+  const mimicDir = stateManager.getInstinctsDir().replace("/instincts", "");
+  const observationLog = new ObservationLog(mimicDir);
+  const sessionMemory = new SessionMemoryManager(mimicDir, stateManager.getSessionsDir());
+  const skillGenerator = new SkillGenerator(directory);
+  return {
+    "mimic:observations": tool({
+      description: i18n.t("tool.observations.description"),
+      args: {
+        limit: tool.schema.number().optional().describe(i18n.t("tool.observations.args.limit")),
+        types: tool.schema.string().optional().describe(i18n.t("tool.observations.args.types"))
+      },
+      async execute(args) {
+        const i18n2 = await i18nPromise;
+        const types = args.types ? args.types.split(",").map((t) => t.trim()) : void 0;
+        const observations = await observationLog.query({
+          types,
+          limit: args.limit ?? 20
+        });
+        if (observations.length === 0) {
+          return i18n2.t("observations.empty");
+        }
+        const logSize = await observationLog.getLogSize();
+        const sizeStr = logSize < 1024 ? `${logSize}B` : logSize < 1024 * 1024 ? `${(logSize / 1024).toFixed(1)}KB` : `${(logSize / (1024 * 1024)).toFixed(1)}MB`;
+        let output = `${i18n2.t("observations.title")}
+
+`;
+        output += `${i18n2.t("observations.stats", { count: observations.length, size: sizeStr })}
+
+`;
+        for (const obs of observations.slice(0, 20)) {
+          const time = new Date(obs.timestamp).toLocaleTimeString();
+          const data = JSON.stringify(obs.data).slice(0, 60);
+          output += `- \`${time}\` **${obs.type}**: ${data}...
+`;
+        }
+        return output;
+      }
+    }),
+    "mimic:session-context": tool({
+      description: i18n.t("tool.session_context.description"),
+      args: {},
+      async execute() {
+        const i18n2 = await i18nPromise;
+        const memories = await sessionMemory.getRecentMemories(5);
+        if (memories.length === 0) {
+          return i18n2.t("session_context.empty");
+        }
+        let output = `${i18n2.t("session_context.title")}
+
+`;
+        const summary = await sessionMemory.getContextSummary();
+        output += `${summary}
+
+`;
+        const patterns = await sessionMemory.analyzeCrossSessionPatterns();
+        if (patterns.length > 0) {
+          output += `${i18n2.t("session_context.patterns_title")}
+`;
+          for (const pattern of patterns.slice(0, 5)) {
+            const confidence = "\u25CF".repeat(Math.round(pattern.confidence * 5)) + "\u25CB".repeat(5 - Math.round(pattern.confidence * 5));
+            output += `- [${confidence}] ${pattern.description} (${pattern.frequency}x)
+`;
+          }
+          output += "\n";
+        }
+        const hints = await sessionMemory.getContinuityHints();
+        if (hints.length > 0) {
+          output += "**Hints for this session:**\n";
+          for (const hint of hints) {
+            output += `- ${hint}
+`;
+          }
+        }
+        return output;
+      }
+    }),
+    "mimic:generate-skills": tool({
+      description: i18n.t("tool.generate_skills.description"),
+      args: {},
+      async execute() {
+        const i18n2 = await i18nPromise;
+        const innerCtx = { stateManager, directory, i18n: i18n2 };
+        await skillGenerator.initialize();
+        const skills = await skillGenerator.generateAllEligibleSkills(innerCtx);
+        if (skills.length === 0) {
+          return i18n2.t("generate_skills.empty");
+        }
+        let output = `${i18n2.t("generate_skills.title")}
+
+`;
+        output += `${i18n2.t("generate_skills.success", { count: skills.length })}
+
+`;
+        for (const skill of skills) {
+          output += `### \u{1F4DA} ${skill.name}
+`;
+          output += `- **Domain**: ${skill.metadata.domain}
+`;
+          output += `- **Path**: \`${skill.path}\`
+
+`;
+        }
+        return output;
+      }
+    })
+  };
+};
+
+// src/tools/core.ts
+import { tool as tool2 } from "@opencode-ai/plugin";
+
+// src/utils/format.ts
+import { differenceInHours, format, formatDistanceToNow } from "date-fns";
+import { enUS, ko } from "date-fns/locale";
+function analyzeTimeSinceLastSession(lastSession) {
+  if (!lastSession) return "first-time";
+  const hours = differenceInHours(/* @__PURE__ */ new Date(), new Date(lastSession));
+  if (hours < 1) return "continuing";
+  if (hours < 24) return "same-day";
+  if (hours < 72) return "short-break";
+  if (hours < 168) return "week-break";
+  return "long-break";
+}
+function formatJourney(ctx, state, gitHistory) {
+  const milestones = state.journey.milestones.slice(-10);
+  const observations = state.journey.observations.slice(-5);
+  const locale = ctx.i18n.language === "ko-KR" ? ko : enUS;
+  let output = `${ctx.i18n.t("journey.title", { project: state.project.name })}
+
+`;
+  output += `${ctx.i18n.t("journey.subtitle")}
+
+`;
+  output += `${ctx.i18n.t("journey.sessions_survived", {
+    count: state.journey.sessionCount
+  })}
+`;
+  output += `${ctx.i18n.t("journey.first_encounter", {
+    date: format(state.project.firstSession, "yyyy-MM-dd")
+  })}
+`;
+  output += `${ctx.i18n.t("journey.abilities_gained", {
+    count: state.evolution.capabilities.length
+  })}
+
+`;
+  if (state.project.stack && state.project.stack.length > 0) {
+    output += `${ctx.i18n.t("journey.treasures", {
+      stack: state.project.stack.join(", ")
+    })}
+`;
+  }
+  if (state.project.focus) {
+    output += `${ctx.i18n.t("journey.current_hunt", { focus: state.project.focus })}
+`;
+  }
+  output += "\n";
+  if (milestones.length > 0) {
+    output += `${ctx.i18n.t("journey.victories")}
+`;
+    for (const m of milestones) {
+      const timeAgo = formatDistanceToNow(new Date(m.timestamp), { addSuffix: true, locale });
+      output += `- ${m.milestone} (${timeAgo})
+`;
+    }
+    output += "\n";
+  }
+  if (observations.length > 0) {
+    output += `${ctx.i18n.t("journey.witnessed")}
+`;
+    for (const o of observations) {
+      output += `- ${o.observation}
+`;
+    }
+    output += "\n";
+  }
+  if (state.evolution.capabilities.length > 0) {
+    output += `${ctx.i18n.t("journey.powers")}
+`;
+    for (const cap of state.evolution.capabilities.slice(-5)) {
+      output += `- **${cap.name}** (${formatCapabilityType(
+        ctx.i18n,
+        cap.type
+      )}): ${cap.description}
+`;
+    }
+    output += "\n";
+  }
+  if (gitHistory.length > 0) {
+    output += `${ctx.i18n.t("journey.scrolls")}
+`;
+    for (const commit of gitHistory.slice(0, 5)) {
+      output += `- ${commit}
+`;
+    }
+  }
+  return output;
+}
+function formatDuration(ms) {
+  const minutes = Math.round(ms / 1e3 / 60);
+  if (minutes < 60) return `${minutes}min`;
+  const hours = Math.floor(minutes / 60);
+  const remainingMinutes = minutes % 60;
+  return `${hours}h ${remainingMinutes}min`;
+}
+function formatGrowAnalysis(ctx, state, _gitHistory, recentFiles) {
+  let output = `${ctx.i18n.t("grow.title", { project: state.project.name })}
+
+`;
+  output += `${ctx.i18n.t("grow.subtitle")}
+
+`;
+  const fileFrequency = Object.entries(state.statistics.filesModified).sort(([, a], [, b]) => b - a).slice(0, 10);
+  if (fileFrequency.length > 0) {
+    output += `${ctx.i18n.t("grow.feeding_grounds")}
+`;
+    for (const [file, count] of fileFrequency) {
+      output += `- \`${file}\` ${ctx.i18n.t("grow.files_modified", { count })}
+`;
+    }
+    output += "\n";
+  }
+  const toolPatterns = state.patterns.filter((p) => p.type === "tool").sort((a, b) => b.count - a.count);
+  if (toolPatterns.length > 0) {
+    output += `${ctx.i18n.t("grow.favorite_prey")}
+`;
+    for (const p of toolPatterns.slice(0, 5)) {
+      output += `- ${p.description}: ${p.count}
+`;
+    }
+    output += "\n";
+  }
+  if (recentFiles.length > 0) {
+    const dirCount = /* @__PURE__ */ new Map();
+    for (const file of recentFiles) {
+      const dir = file.split("/").slice(0, -1).join("/") || ".";
+      dirCount.set(dir, (dirCount.get(dir) || 0) + 1);
+    }
+    const sortedDirs = [...dirCount.entries()].sort((a, b) => b[1] - a[1]);
+    output += `${ctx.i18n.t("grow.hunting_grounds")}
+`;
+    for (const [dir, count] of sortedDirs.slice(0, 5)) {
+      output += `- \`${dir}/\` ${ctx.i18n.t("grow.prey", { count })}
+`;
+    }
+    output += "\n";
+  }
+  output += `${ctx.i18n.t("grow.questions")}
+`;
+  output += `${ctx.i18n.t("grow.question1")}
+`;
+  output += `${ctx.i18n.t("grow.question2")}
+`;
+  output += `${ctx.i18n.t("grow.question3")}
+`;
+  if (state.project.focus) {
+    output += `
+${ctx.i18n.t("grow.current_hunt", { focus: state.project.focus })}
+`;
+  }
+  return output;
+}
+
+// src/tools/core.ts
+var createCoreTools = (ctx) => {
+  const { stateManager, directory, toolCalls, i18n, i18nPromise } = ctx;
+  return {
+    "mimic:init": tool2({
+      description: i18n.t("tool.init.description"),
+      args: {},
+      async execute() {
+        const i18n2 = await i18nPromise;
+        const state = await stateManager.read();
+        const isFirstTime = state.journey.sessionCount <= 1;
+        if (isFirstTime) {
+          return i18n2.t("init.first_time", { project: state.project.name });
+        }
+        const timeSince = analyzeTimeSinceLastSession(state.journey.lastSession);
+        const recentObs = state.journey.observations.slice(-3);
+        let greeting = `${i18n2.t("init.returning.header")}
+
+`;
+        greeting += `${i18n2.t("init.returning.welcome", { project: state.project.name })}
+
+`;
+        greeting += `${i18n2.t("init.returning.stats", {
+          sessions: state.journey.sessionCount,
+          patterns: state.patterns.length
+        })}
+
+`;
+        if (timeSince === "long-break") {
+          greeting += `${i18n2.t("init.returning.long_break")}
+
+`;
+        }
+        if (recentObs.length > 0) {
+          greeting += `${i18n2.t("init.returning.recent_obs_title")}
+`;
+          for (const o of recentObs) {
+            greeting += `- ${o.observation}
+`;
+          }
+        }
+        return greeting;
+      }
+    }),
+    "mimic:status": tool2({
+      description: i18n.t("tool.status.description"),
+      args: {},
+      async execute() {
+        const i18n2 = await i18nPromise;
+        const innerCtx = { stateManager, directory, i18n: i18n2 };
+        const state = await stateManager.read();
+        const recentFiles = getRecentlyModifiedFiles(directory);
+        const gitHistory = getGitHistory(directory, 5);
+        let output = `${i18n2.t("status.title", { project: state.project.name })}
+
+`;
+        output += `${i18n2.t("status.session", { count: state.journey.sessionCount })}
+`;
+        output += `${i18n2.t("status.patterns", {
+          total: state.patterns.length,
+          surfaced: state.patterns.filter((p) => p.surfaced).length
+        })}
+`;
+        output += `${i18n2.t("status.tool_calls", { count: toolCalls.length })}
+
+`;
+        if (recentFiles.length > 0) {
+          output += `${i18n2.t("status.recent_files")}
+`;
+          for (const f of recentFiles.slice(0, 5)) {
+            output += `- ${f}
+`;
+          }
+          output += "\n";
+        }
+        if (gitHistory.length > 0) {
+          output += `${i18n2.t("status.recent_commits")}
+`;
+          for (const c of gitHistory) {
+            output += `- ${c}
+`;
+          }
         }
-        return {
-          type: "shortcut",
-          name: `quick-${pattern.description.toLowerCase().replace(/[^a-z0-9]/g, "-")}`,
-          description: ctx.i18n.t("evolution.suggest.tool.description", {
-            pattern: pattern.description
-          }),
-          reason: ctx.i18n.t("evolution.suggest.tool.reason", { count: pattern.count }),
-          pattern
-        };
-      }
-      break;
-    case "file":
-      if (pattern.count >= 5) {
-        return {
-          type: "hook",
-          name: `watch-${pattern.description.split("/").pop()?.replace(/\./g, "-") || "file"}`,
-          description: ctx.i18n.t("evolution.suggest.file.description", {
-            pattern: pattern.description
-          }),
-          reason: ctx.i18n.t("evolution.suggest.file.reason", { count: pattern.count }),
-          pattern
-        };
+        const suggestions = await surfacePatterns(innerCtx);
+        if (suggestions.length > 0) {
+          output += `
+${i18n2.t("status.suggestions")}
+`;
+          for (const s of suggestions) {
+            output += `- ${s}
+`;
+          }
+        }
+        return output;
       }
-      break;
-    case "commit":
-      if (pattern.count >= 3) {
-        return {
-          type: "command",
-          name: `commit-${pattern.description.slice(0, 20).replace(/\s+/g, "-").toLowerCase()}`,
-          description: ctx.i18n.t("evolution.suggest.commit.description", {
-            pattern: pattern.description
-          }),
-          reason: ctx.i18n.t("evolution.suggest.commit.reason", { count: pattern.count }),
-          pattern
-        };
+    }),
+    "mimic:journey": tool2({
+      description: i18n.t("tool.journey.description"),
+      args: {},
+      async execute() {
+        const i18n2 = await i18nPromise;
+        const innerCtx = { stateManager, directory, i18n: i18n2 };
+        const state = await stateManager.read();
+        const gitHistory = getGitHistory(directory, 10);
+        return formatJourney(innerCtx, state, gitHistory);
       }
-      break;
-    case "sequence":
-      if (pattern.count >= 5) {
-        return {
-          type: "agent",
-          name: `${pattern.description.slice(0, 15).replace(/\s+/g, "-").toLowerCase()}-specialist`,
-          description: ctx.i18n.t("evolution.suggest.sequence.agent.description", {
-            pattern: pattern.description
-          }),
-          reason: ctx.i18n.t("evolution.suggest.sequence.agent.reason", { count: pattern.count }),
-          pattern
-        };
+    }),
+    "mimic:patterns": tool2({
+      description: i18n.t("tool.patterns.description"),
+      args: {},
+      async execute() {
+        const i18n2 = await i18nPromise;
+        const state = await stateManager.read();
+        if (state.patterns.length === 0) {
+          return i18n2.t("patterns.none");
+        }
+        let output = `${i18n2.t("patterns.title")}
+
+`;
+        output += `${i18n2.t("patterns.total", { count: state.patterns.length })}
+
+`;
+        const byType = /* @__PURE__ */ new Map();
+        for (const p of state.patterns) {
+          const list = byType.get(p.type) || [];
+          list.push(p);
+          byType.set(p.type, list);
+        }
+        for (const [type, patterns] of byType) {
+          output += `${i18n2.t("patterns.section", {
+            type: formatPatternType(i18n2, type)
+          })}
+`;
+          for (const p of patterns.slice(0, 10)) {
+            const status = p.surfaced ? "\u2713" : "\u25CB";
+            output += `${status} **${p.description}** (${p.count}x)
+`;
+          }
+          output += "\n";
+        }
+        return output;
       }
-      if (pattern.count >= 3) {
-        return {
-          type: "skill",
-          name: `auto-${pattern.description.slice(0, 15).replace(/\s+/g, "-").toLowerCase()}`,
-          description: ctx.i18n.t("evolution.suggest.sequence.skill.description", {
-            pattern: pattern.description
-          }),
-          reason: ctx.i18n.t("evolution.suggest.sequence.skill.reason", { count: pattern.count }),
-          pattern
-        };
+    }),
+    "mimic:grow": tool2({
+      description: i18n.t("tool.grow.description"),
+      args: {},
+      async execute() {
+        const i18n2 = await i18nPromise;
+        const innerCtx = { stateManager, directory, i18n: i18n2 };
+        const state = await stateManager.read();
+        const gitHistory = getGitHistory(directory, 20);
+        const recentFiles = getRecentlyModifiedFiles(directory);
+        return formatGrowAnalysis(innerCtx, state, gitHistory, recentFiles);
       }
-      break;
-  }
-  return null;
-}
-async function getEvolutionSuggestions(ctx) {
-  const state = await ctx.stateManager.read();
-  const suggestions = [];
-  for (const pattern of state.patterns) {
-    if (pattern.surfaced) continue;
-    const suggestion = suggestEvolution(pattern, ctx);
-    if (suggestion) {
-      suggestions.push(suggestion);
-    }
-  }
-  return suggestions;
-}
-async function evolveCapability(ctx, suggestion) {
-  const state = await ctx.stateManager.read();
-  const { filePath, content } = await buildEvolutionOutput(ctx, suggestion);
-  await writeFile2(filePath, content, "utf-8");
-  const capability = createCapabilityFromSuggestion(suggestion);
-  updateEvolutionState(state, capability, suggestion);
-  await ctx.stateManager.save(state);
-  await ctx.stateManager.addMilestone(
-    ctx.i18n.t("milestone.evolved", {
-      name: capability.name,
-      type: formatCapabilityType(ctx.i18n, capability.type)
     })
-  );
-  return { capability, filePath };
-}
-function formatEvolutionResult(ctx, capability, filePath) {
-  const typeLabel = formatCapabilityType(ctx.i18n, capability.type);
-  let result = `### \u2728 ${capability.name}
+  };
+};
+
+// src/tools/evolution.ts
+import { tool as tool3 } from "@opencode-ai/plugin";
+import { format as format2 } from "date-fns";
+var createEvolutionTools = (ctx) => {
+  const { stateManager, directory, i18n, i18nPromise } = ctx;
+  return {
+    "mimic:evolve": tool3({
+      description: i18n.t("tool.evolve.description"),
+      args: {
+        accept: tool3.schema.string().optional().describe(i18n.t("tool.evolve.args.accept"))
+      },
+      async execute(args) {
+        const i18n2 = await i18nPromise;
+        const innerCtx = { stateManager, directory, i18n: i18n2 };
+        if (args.accept) {
+          const suggestions2 = await getEvolutionSuggestions(innerCtx);
+          const suggestion = suggestions2.find((s) => s.pattern.id === args.accept);
+          if (!suggestion) {
+            return i18n2.t("evolve.no_pattern", { id: args.accept });
+          }
+          const { capability, filePath } = await evolveCapability(innerCtx, suggestion);
+          return `${i18n2.t("evolve.absorbed_header")}
+
+${formatEvolutionResult(
+            innerCtx,
+            capability,
+            filePath
+          )}`;
+        }
+        const suggestions = await getEvolutionSuggestions(innerCtx);
+        if (suggestions.length === 0) {
+          return i18n2.t("evolve.empty");
+        }
+        let output = `${i18n2.t("evolve.menu_title")}
 
 `;
-  result += `**${ctx.i18n.t("evolution.result.type")}**: ${typeLabel}
+        output += `${i18n2.t("evolve.menu_intro")}
+
 `;
-  result += `**${ctx.i18n.t("evolution.result.description")}**: ${capability.description}
+        for (const s of suggestions) {
+          output += `### \u2728 ${s.name}
 `;
-  result += `**${ctx.i18n.t("evolution.result.file")}**: \`${filePath}\`
-
+          output += `- **${i18n2.t("evolve.menu_type")}**: ${formatCapabilityType(i18n2, s.type)}
 `;
-  result += `*${ctx.i18n.t("evolution.result.restart", { type: typeLabel })}*
+          output += `- **${i18n2.t("evolve.menu_reason")}**: ${s.reason}
+`;
+          output += `- **${i18n2.t("evolve.menu_pattern_id")}**: \`${s.pattern.id}\`
 
 `;
-  switch (capability.type) {
-    case "command":
-    case "shortcut":
-      result += `${ctx.i18n.t("evolution.result.command", { name: capability.name })}
+        }
+        output += `
+${i18n2.t("evolve.menu_footer")}`;
+        return output;
+      }
+    }),
+    "mimic:capabilities": tool3({
+      description: i18n.t("tool.capabilities.description"),
+      args: {},
+      async execute() {
+        const i18n2 = await i18nPromise;
+        const state = await stateManager.read();
+        if (state.evolution.capabilities.length === 0) {
+          return i18n2.t("capabilities.empty");
+        }
+        let output = `${i18n2.t("capabilities.title")}
+
 `;
-      break;
-    case "hook":
-      result += `${ctx.i18n.t("evolution.result.hook")}
+        output += `${i18n2.t("capabilities.intro")}
+
 `;
-      break;
-    case "skill":
-      result += `${ctx.i18n.t("evolution.result.skill")}
+        for (const cap of state.evolution.capabilities) {
+          output += `### \u2728 ${cap.name}
 `;
-      break;
-    case "agent":
-      result += `${ctx.i18n.t("evolution.result.agent", { name: capability.name })}
+          output += `- **${i18n2.t("capabilities.type")}**: ${formatCapabilityType(
+            i18n2,
+            cap.type
+          )}
 `;
-      break;
-    case "mcp":
-      result += `${ctx.i18n.t("evolution.result.mcp", { name: capability.name })}
+          output += `- **${i18n2.t("capabilities.description")}**: ${cap.description}
 `;
-      break;
-  }
-  return result;
-}
-
-// src/level.ts
-var LEVEL_CONFIGS = {
-  technical: {
-    greetingStyle: "minimal",
-    detailLevel: "high",
-    useEmoji: false,
-    technicalTerms: true
-  },
-  "semi-technical": {
-    greetingStyle: "casual",
-    detailLevel: "medium",
-    useEmoji: false,
-    technicalTerms: true
-  },
-  "non-technical": {
-    greetingStyle: "formal",
-    detailLevel: "low",
-    useEmoji: true,
-    technicalTerms: false
-  },
-  chaotic: {
-    greetingStyle: "chaotic",
-    detailLevel: "medium",
-    useEmoji: true,
-    technicalTerms: true
-  }
+          output += `- **${i18n2.t("capabilities.consumed")}**: ${format2(
+            new Date(cap.createdAt),
+            "yyyy-MM-dd"
+          )}
+
+`;
+        }
+        return output;
+      }
+    })
+  };
 };
-function getLevelConfig(level) {
-  return LEVEL_CONFIGS[level ?? "technical"];
-}
 
-// src/tools.ts
-function createTools(stateManager, directory, toolCalls, i18n) {
-  const baseI18n = i18n ?? createI18n(resolveLanguage(null));
-  const i18nPromise = i18n ? Promise.resolve(i18n) : loadMimicConfig().then((config) => createI18n(resolveLanguage(config))).catch(() => createI18n(resolveLanguage(null)));
+// src/tools/instincts.ts
+import { existsSync as existsSync7 } from "fs";
+import { mkdir as mkdir5, readFile as readFile6, writeFile as writeFile6 } from "fs/promises";
+import { join as join7 } from "path";
+import { tool as tool4 } from "@opencode-ai/plugin";
+import { format as format3 } from "date-fns";
+var createInstinctTools = (ctx) => {
+  const { stateManager, directory, toolCalls, i18n, i18nPromise } = ctx;
   return {
-    "mimic:init": tool({
-      description: baseI18n.t("tool.init.description"),
-      args: {},
-      async execute() {
+    "mimic:instincts": tool4({
+      description: i18n.t("tool.instincts.description"),
+      args: {
+        domain: tool4.schema.string().optional().describe(i18n.t("tool.instincts.args.domain"))
+      },
+      async execute(args) {
         const i18n2 = await i18nPromise;
-        const state = await stateManager.read();
-        const isFirstTime = state.journey.sessionCount <= 1;
-        if (isFirstTime) {
-          return i18n2.t("init.first_time", { project: state.project.name });
+        const instincts = await stateManager.listInstincts();
+        if (instincts.length === 0) {
+          return i18n2.t("instincts.empty");
         }
-        const timeSince = analyzeTimeSinceLastSession(state.journey.lastSession);
-        const recentObs = state.journey.observations.slice(-3);
-        let greeting = `${i18n2.t("init.returning.header")}
-
-`;
-        greeting += `${i18n2.t("init.returning.welcome", { project: state.project.name })}
+        let filtered = instincts;
+        if (args.domain) {
+          filtered = instincts.filter((inst) => inst.domain === args.domain);
+        }
+        const byDomain = groupInstinctsByDomain(filtered);
+        let output = `${i18n2.t("instincts.title")}
 
 `;
-        greeting += `${i18n2.t("init.returning.stats", {
-          sessions: state.journey.sessionCount,
-          patterns: state.patterns.length
-        })}
+        output += `${i18n2.t("instincts.total", { count: filtered.length })}
 
 `;
-        if (timeSince === "long-break") {
-          greeting += `${i18n2.t("init.returning.long_break")}
-
+        for (const [domain, domainInstincts] of byDomain) {
+          output += `### ${domain}
 `;
-        }
-        if (recentObs.length > 0) {
-          greeting += `${i18n2.t("init.returning.recent_obs_title")}
+          for (const inst of domainInstincts.slice(0, 10)) {
+            const bar = "\u25CF".repeat(Math.round(inst.confidence * 5)) + "\u25CB".repeat(5 - Math.round(inst.confidence * 5));
+            const sourceTag = inst.source === "inherited" ? " \u{1F4E5}" : "";
+            output += `- [${bar}] **${inst.title}**${sourceTag}
 `;
-          for (const o of recentObs) {
-            greeting += `- ${o.observation}
+            output += `  ${inst.description}
 `;
           }
+          output += "\n";
         }
-        return greeting;
+        return output;
       }
     }),
-    "mimic:status": tool({
-      description: baseI18n.t("tool.status.description"),
+    "mimic:export": tool4({
+      description: i18n.t("tool.export.description"),
       args: {},
       async execute() {
         const i18n2 = await i18nPromise;
-        const ctx = { stateManager, directory, i18n: i18n2 };
-        const state = await stateManager.read();
-        const recentFiles = getRecentlyModifiedFiles(directory);
-        const gitHistory = getGitHistory(directory, 5);
-        let output = `${i18n2.t("status.title", { project: state.project.name })}
+        const exported = await stateManager.exportInstincts();
+        if (exported.instincts.length === 0) {
+          return i18n2.t("export.empty");
+        }
+        const exportPath = join7(directory, ".opencode", "mimic", "exports");
+        if (!existsSync7(exportPath)) {
+          await mkdir5(exportPath, { recursive: true });
+        }
+        const filename = `instincts-${format3(/* @__PURE__ */ new Date(), "yyyy-MM-dd-HHmmss")}.json`;
+        const filePath = join7(exportPath, filename);
+        await writeFile6(filePath, JSON.stringify(exported, null, 2));
+        return i18n2.t("export.success", {
+          count: exported.instincts.length,
+          path: filePath
+        });
+      }
+    }),
+    "mimic:import": tool4({
+      description: i18n.t("tool.import.description"),
+      args: {
+        path: tool4.schema.string().describe(i18n.t("tool.import.args.path"))
+      },
+      async execute(args) {
+        const i18n2 = await i18nPromise;
+        if (!existsSync7(args.path)) {
+          return i18n2.t("import.not_found", { path: args.path });
+        }
+        try {
+          const content = await readFile6(args.path, "utf-8");
+          const data = JSON.parse(content);
+          const imported = await stateManager.importInstincts(
+            data.instincts,
+            data.metadata.projectName
+          );
+          await stateManager.updateIdentityStats();
+          return i18n2.t("import.success", {
+            count: imported,
+            from: data.metadata.projectName
+          });
+        } catch {
+          return i18n2.t("import.error");
+        }
+      }
+    }),
+    "mimic:apply": tool4({
+      description: i18n.t("tool.apply.description"),
+      args: {},
+      async execute() {
+        const i18n2 = await i18nPromise;
+        const innerCtx = { stateManager, directory, i18n: i18n2 };
+        const recentTools = toolCalls.slice(-10).map((t) => t.tool);
+        const recentFiles = getRecentlyModifiedFiles(directory).slice(0, 5);
+        const applicable = await getApplicableInstincts(innerCtx, recentTools, recentFiles);
+        if (applicable.length === 0) {
+          return i18n2.t("apply.none");
+        }
+        let output = `${i18n2.t("apply.title")}
 
 `;
-        output += `${i18n2.t("status.session", { count: state.journey.sessionCount })}
-`;
-        output += `${i18n2.t("status.patterns", {
-          total: state.patterns.length,
-          surfaced: state.patterns.filter((p) => p.surfaced).length
-        })}
+        for (const applied of applicable) {
+          output += `${formatInstinctSuggestion(applied, i18n2)}
 `;
-        output += `${i18n2.t("status.tool_calls", { count: toolCalls.length })}
+          output += `  \u2192 ${applied.instinct.description}
 
 `;
-        if (recentFiles.length > 0) {
-          output += `${i18n2.t("status.recent_files")}
+        }
+        return output;
+      }
+    }),
+    "mimic:identity": tool4({
+      description: i18n.t("tool.identity.description"),
+      args: {},
+      async execute() {
+        const i18n2 = await i18nPromise;
+        const state = await stateManager.read();
+        if (!state.project.identity) {
+          await stateManager.initializeIdentity();
+          const updated = await stateManager.read();
+          state.project.identity = updated.project.identity;
+        }
+        if (!state.project.identity) {
+          return i18n2.t("identity.error");
+        }
+        const identity = state.project.identity;
+        const awakened = new Date(identity.awakened);
+        const daysAlive = Math.floor((Date.now() - awakened.getTime()) / (1e3 * 60 * 60 * 24));
+        let output = `${i18n2.t("identity.title")}
+
 `;
-          for (const f of recentFiles.slice(0, 5)) {
-            output += `- ${f}
+        output += `**${i18n2.t("identity.personality")}**: ${identity.personality}
 `;
-          }
-          output += "\n";
-        }
-        if (gitHistory.length > 0) {
-          output += `${i18n2.t("status.recent_commits")}
+        output += `**${i18n2.t("identity.awakened")}**: ${format3(awakened, "yyyy-MM-dd")} (${daysAlive} ${i18n2.t("identity.days")})
 `;
-          for (const c of gitHistory) {
-            output += `- ${c}
+        output += `**${i18n2.t("identity.instincts_learned")}**: ${identity.totalInstinctsLearned}
 `;
-          }
-        }
-        const suggestions = await surfacePatterns(ctx);
-        if (suggestions.length > 0) {
-          output += `
-${i18n2.t("status.suggestions")}
+        output += `**${i18n2.t("identity.evolutions")}**: ${identity.totalEvolutions}
 `;
-          for (const s of suggestions) {
-            output += `- ${s}
+        if (identity.favoriteDomainsRank.length > 0) {
+          output += `**${i18n2.t("identity.favorite_domains")}**: ${identity.favoriteDomainsRank.join(", ")}
 `;
-          }
         }
         return output;
       }
     }),
-    "mimic:journey": tool({
-      description: baseI18n.t("tool.journey.description"),
+    "mimic:sequences": tool4({
+      description: i18n.t("tool.sequences.description"),
       args: {},
       async execute() {
         const i18n2 = await i18nPromise;
-        const ctx = { stateManager, directory, i18n: i18n2 };
         const state = await stateManager.read();
-        const gitHistory = getGitHistory(directory, 10);
-        return formatJourney(ctx, state, gitHistory);
+        const sequences = state.statistics.toolSequences || [];
+        if (sequences.length === 0) {
+          return i18n2.t("sequences.empty");
+        }
+        let output = `${i18n2.t("sequences.title")}
+
+`;
+        for (const seq of sequences.slice(0, 10)) {
+          output += `- **${seq.tools.join(" \u2192 ")}** (${seq.count}x)
+`;
+        }
+        return output;
+      }
+    })
+  };
+};
+function groupInstinctsByDomain(instincts) {
+  const byDomain = /* @__PURE__ */ new Map();
+  for (const inst of instincts) {
+    const list = byDomain.get(inst.domain) || [];
+    list.push(inst);
+    byDomain.set(inst.domain, list);
+  }
+  return byDomain;
+}
+
+// src/tools/mcp.ts
+import { existsSync as existsSync8 } from "fs";
+import { mkdir as mkdir6, readFile as readFile7, writeFile as writeFile7 } from "fs/promises";
+import { join as join8 } from "path";
+import { tool as tool5 } from "@opencode-ai/plugin";
+var createMcpTools = (ctx) => {
+  const { stateManager, directory, i18n, i18nPromise } = ctx;
+  return {
+    "mimic:mcp-search": tool5({
+      description: i18n.t("tool.mcp_search.description"),
+      args: {
+        query: tool5.schema.string().describe(i18n.t("tool.mcp_search.args.query"))
+      },
+      async execute(args) {
+        const i18n2 = await i18nPromise;
+        const searchUrl = `https://mcpmarket.com/search?q=${encodeURIComponent(args.query)}`;
+        const popular = [
+          {
+            name: "context7",
+            desc: i18n2.t("mcp_search.desc.context7"),
+            url: "https://mcp.context7.com/mcp"
+          },
+          {
+            name: "github",
+            desc: i18n2.t("mcp_search.desc.github"),
+            url: "https://mcp.github.com"
+          },
+          {
+            name: "supabase",
+            desc: i18n2.t("mcp_search.desc.supabase"),
+            url: "https://mcp.supabase.com"
+          },
+          { name: "playwright", desc: i18n2.t("mcp_search.desc.playwright") },
+          { name: "firecrawl", desc: i18n2.t("mcp_search.desc.firecrawl") }
+        ];
+        const popularLines = popular.map(
+          (server) => server.url ? `- **${server.name}** - ${server.desc}: \`${server.url}\`` : `- **${server.name}** - ${server.desc}`
+        ).join("\n");
+        return `${i18n2.t("mcp_search.header", {
+          query: args.query,
+          url: searchUrl
+        })}
+
+${i18n2.t("mcp_search.popular")}
+${popularLines}
+
+${i18n2.t("mcp_search.add")}`;
       }
     }),
-    "mimic:patterns": tool({
-      description: baseI18n.t("tool.patterns.description"),
-      args: {},
-      async execute() {
+    "mimic:mcp": tool5({
+      description: i18n.t("tool.mcp.description"),
+      args: {
+        name: tool5.schema.string().describe(i18n.t("tool.mcp.args.name")),
+        url: tool5.schema.string().optional().describe(i18n.t("tool.mcp.args.url")),
+        command: tool5.schema.string().optional().describe(i18n.t("tool.mcp.args.command"))
+      },
+      async execute(args) {
+        const i18n2 = await i18nPromise;
+        const opencodeDir = join8(directory, ".opencode");
+        if (!existsSync8(opencodeDir)) {
+          await mkdir6(opencodeDir, { recursive: true });
+        }
+        const configPath = join8(directory, "opencode.json");
+        let config = {};
+        if (existsSync8(configPath)) {
+          try {
+            config = JSON.parse(await readFile7(configPath, "utf-8"));
+          } catch {
+            config = {};
+          }
+        }
+        const mcpEntry = {};
+        if (args.url) {
+          mcpEntry.type = "remote";
+          mcpEntry.url = args.url;
+        } else if (args.command) {
+          mcpEntry.type = "local";
+          mcpEntry.command = args.command.split(",").map((s) => s.trim());
+        } else {
+          return i18n2.t("mcp.need_url_or_command");
+        }
+        mcpEntry.enabled = true;
+        config.mcp = { ...config.mcp || {}, [args.name]: mcpEntry };
+        await writeFile7(configPath, JSON.stringify(config, null, 2));
+        await stateManager.addMilestone(i18n2.t("milestone.mcp_added", { name: args.name }));
+        return i18n2.t("mcp.added", { name: args.name });
+      }
+    })
+  };
+};
+
+// src/tools/observation.ts
+import { tool as tool6 } from "@opencode-ai/plugin";
+var createObservationTools = (ctx) => {
+  const { stateManager, i18n, i18nPromise } = ctx;
+  return {
+    "mimic:observe": tool6({
+      description: i18n.t("tool.observe.description"),
+      args: {
+        observation: tool6.schema.string().describe(i18n.t("tool.observe.args.observation"))
+      },
+      async execute(args) {
+        const i18n2 = await i18nPromise;
+        await stateManager.addObservation(args.observation);
+        return i18n2.t("observe.recorded", { observation: args.observation });
+      }
+    }),
+    "mimic:milestone": tool6({
+      description: i18n.t("tool.milestone.description"),
+      args: {
+        milestone: tool6.schema.string().describe(i18n.t("tool.milestone.args.milestone"))
+      },
+      async execute(args) {
+        const i18n2 = await i18nPromise;
+        await stateManager.addMilestone(args.milestone);
+        return i18n2.t("milestone.recorded", { milestone: args.milestone });
+      }
+    }),
+    "mimic:surface": tool6({
+      description: i18n.t("tool.surface.description"),
+      args: {
+        patternId: tool6.schema.string().describe(i18n.t("tool.surface.args.patternId"))
+      },
+      async execute(args) {
         const i18n2 = await i18nPromise;
         const state = await stateManager.read();
-        if (state.patterns.length === 0) {
-          return i18n2.t("patterns.none");
+        const pattern = state.patterns.find((p) => p.id === args.patternId);
+        if (!pattern) {
+          return i18n2.t("surface.not_found", { id: args.patternId });
         }
-        let output = `${i18n2.t("patterns.title")}
+        pattern.surfaced = true;
+        await stateManager.save(state);
+        return i18n2.t("surface.marked", { description: pattern.description });
+      }
+    })
+  };
+};
 
-`;
-        output += `${i18n2.t("patterns.total", { count: state.patterns.length })}
+// src/tools/registry.ts
+var ToolRegistry = class {
+  factories = [];
+  /**
+   * Register a tool factory
+   */
+  register(factory) {
+    this.factories.push(factory);
+    return this;
+  }
+  /**
+   * Build all tools from registered factories
+   */
+  build(ctx) {
+    const tools = {};
+    for (const factory of this.factories) {
+      const factoryTools = factory(ctx);
+      Object.assign(tools, factoryTools);
+    }
+    return tools;
+  }
+};
+var toolRegistry = new ToolRegistry();
+
+// src/tools/settings.ts
+import { readdir as readdir3, writeFile as writeFile8 } from "fs/promises";
+import { tool as tool7 } from "@opencode-ai/plugin";
+import { format as format4 } from "date-fns";
+
+// src/modules/evolution/system.ts
+var LEVEL_CONFIGS = {
+  technical: {
+    greetingStyle: "minimal",
+    detailLevel: "high",
+    useEmoji: false,
+    technicalTerms: true
+  },
+  "semi-technical": {
+    greetingStyle: "casual",
+    detailLevel: "medium",
+    useEmoji: false,
+    technicalTerms: true
+  },
+  "non-technical": {
+    greetingStyle: "formal",
+    detailLevel: "low",
+    useEmoji: true,
+    technicalTerms: false
+  },
+  chaotic: {
+    greetingStyle: "chaotic",
+    detailLevel: "medium",
+    useEmoji: true,
+    technicalTerms: true
+  }
+};
+function getLevelConfig(level) {
+  return LEVEL_CONFIGS[level ?? "technical"];
+}
 
-`;
-        const byType = /* @__PURE__ */ new Map();
-        for (const p of state.patterns) {
-          const list = byType.get(p.type) || [];
-          list.push(p);
-          byType.set(p.type, list);
-        }
-        for (const [type, patterns] of byType) {
-          output += `${i18n2.t("patterns.section", {
-            type: formatPatternType(i18n2, type)
-          })}
-`;
-          for (const p of patterns.slice(0, 10)) {
-            const status = p.surfaced ? "\u2713" : "\u25CB";
-            output += `${status} **${p.description}** (${p.count}x)
-`;
-          }
-          output += "\n";
-        }
-        return output;
-      }
-    }),
-    "mimic:observe": tool({
-      description: baseI18n.t("tool.observe.description"),
-      args: {
-        observation: tool.schema.string().describe(baseI18n.t("tool.observe.args.observation"))
-      },
-      async execute(args) {
-        const i18n2 = await i18nPromise;
-        await stateManager.addObservation(args.observation);
-        return i18n2.t("observe.recorded", { observation: args.observation });
-      }
-    }),
-    "mimic:milestone": tool({
-      description: baseI18n.t("tool.milestone.description"),
-      args: {
-        milestone: tool.schema.string().describe(baseI18n.t("tool.milestone.args.milestone"))
-      },
-      async execute(args) {
-        const i18n2 = await i18nPromise;
-        await stateManager.addMilestone(args.milestone);
-        return i18n2.t("milestone.recorded", { milestone: args.milestone });
-      }
-    }),
-    "mimic:stats": tool({
-      description: baseI18n.t("tool.stats.description"),
+// src/tools/settings.ts
+var createSettingsTools = (ctx) => {
+  const { stateManager, i18n, i18nPromise } = ctx;
+  return {
+    "mimic:stats": tool7({
+      description: i18n.t("tool.stats.description"),
       args: {},
       async execute() {
         const i18n2 = await i18nPromise;
         const state = await stateManager.read();
-        const sessionFiles = await readdir(stateManager.getSessionsDir()).catch(() => []);
+        const sessionFiles = await readdir3(stateManager.getSessionsDir()).catch(() => []);
         return `## ${i18n2.t("stats.title")}
 
 - **${i18n2.t("stats.version")}**: ${state.version}
@@ -1422,17 +3644,17 @@ ${i18n2.t("status.suggestions")}
 - **${i18n2.t("stats.milestones")}**: ${state.journey.milestones.length}
 - **${i18n2.t("stats.observations")}**: ${state.journey.observations.length}
 - **${i18n2.t("stats.session_records")}**: ${sessionFiles.length}
-- **${i18n2.t("stats.first_session")}**: ${format2(state.project.firstSession, "yyyy-MM-dd HH:mm:ss")}
+- **${i18n2.t("stats.first_session")}**: ${format4(state.project.firstSession, "yyyy-MM-dd HH:mm:ss")}
 - **${i18n2.t("stats.learning_enabled")}**: ${state.preferences.learningEnabled}
 - **${i18n2.t("stats.suggestions_enabled")}**: ${state.preferences.suggestionEnabled}`;
       }
     }),
-    "mimic:configure": tool({
-      description: baseI18n.t("tool.configure.description"),
+    "mimic:configure": tool7({
+      description: i18n.t("tool.configure.description"),
       args: {
-        learningEnabled: tool.schema.boolean().optional().describe(baseI18n.t("tool.configure.args.learningEnabled")),
-        suggestionEnabled: tool.schema.boolean().optional().describe(baseI18n.t("tool.configure.args.suggestionEnabled")),
-        minPatternCount: tool.schema.number().optional().describe(baseI18n.t("tool.configure.args.minPatternCount"))
+        learningEnabled: tool7.schema.boolean().optional().describe(i18n.t("tool.configure.args.learningEnabled")),
+        suggestionEnabled: tool7.schema.boolean().optional().describe(i18n.t("tool.configure.args.suggestionEnabled")),
+        minPatternCount: tool7.schema.number().optional().describe(i18n.t("tool.configure.args.minPatternCount"))
       },
       async execute(args) {
         const i18n2 = await i18nPromise;
@@ -1451,105 +3673,27 @@ ${i18n2.t("status.suggestions")}
 ${JSON.stringify(state.preferences, null, 2)}`;
       }
     }),
-    "mimic:surface": tool({
-      description: baseI18n.t("tool.surface.description"),
-      args: {
-        patternId: tool.schema.string().describe(baseI18n.t("tool.surface.args.patternId"))
-      },
-      async execute(args) {
-        const i18n2 = await i18nPromise;
-        const state = await stateManager.read();
-        const pattern = state.patterns.find((p) => p.id === args.patternId);
-        if (!pattern) {
-          return i18n2.t("surface.not_found", { id: args.patternId });
-        }
-        pattern.surfaced = true;
-        await stateManager.save(state);
-        return i18n2.t("surface.marked", { description: pattern.description });
-      }
-    }),
-    "mimic:reset": tool({
-      description: baseI18n.t("tool.reset.description"),
+    "mimic:reset": tool7({
+      description: i18n.t("tool.reset.description"),
       args: {
-        confirm: tool.schema.boolean().describe(baseI18n.t("tool.reset.args.confirm"))
+        confirm: tool7.schema.boolean().describe(i18n.t("tool.reset.args.confirm"))
       },
       async execute(args) {
         const i18n2 = await i18nPromise;
         if (!args.confirm) {
           return i18n2.t("reset.cancelled");
         }
-        await writeFile3(
+        await writeFile8(
           stateManager.getStatePath(),
           JSON.stringify(createDefaultState(stateManager.getProjectName()), null, 2)
         );
         return i18n2.t("reset.done");
       }
     }),
-    "mimic:grow": tool({
-      description: baseI18n.t("tool.grow.description"),
-      args: {},
-      async execute() {
-        const i18n2 = await i18nPromise;
-        const ctx = { stateManager, directory, i18n: i18n2 };
-        const state = await stateManager.read();
-        const gitHistory = getGitHistory(directory, 20);
-        const recentFiles = getRecentlyModifiedFiles(directory);
-        return formatGrowAnalysis(ctx, state, gitHistory, recentFiles);
-      }
-    }),
-    "mimic:evolve": tool({
-      description: baseI18n.t("tool.evolve.description"),
-      args: {
-        accept: tool.schema.string().optional().describe(baseI18n.t("tool.evolve.args.accept"))
-      },
-      async execute(args) {
-        const i18n2 = await i18nPromise;
-        const ctx = { stateManager, directory, i18n: i18n2 };
-        if (args.accept) {
-          const suggestions2 = await getEvolutionSuggestions(ctx);
-          const suggestion = suggestions2.find((s) => s.pattern.id === args.accept);
-          if (!suggestion) {
-            return i18n2.t("evolve.no_pattern", { id: args.accept });
-          }
-          const { capability, filePath } = await evolveCapability(ctx, suggestion);
-          return `${i18n2.t("evolve.absorbed_header")}
-
-${formatEvolutionResult(
-            ctx,
-            capability,
-            filePath
-          )}`;
-        }
-        const suggestions = await getEvolutionSuggestions(ctx);
-        if (suggestions.length === 0) {
-          return i18n2.t("evolve.empty");
-        }
-        let output = `${i18n2.t("evolve.menu_title")}
-
-`;
-        output += `${i18n2.t("evolve.menu_intro")}
-
-`;
-        for (const s of suggestions) {
-          output += `### \u2728 ${s.name}
-`;
-          output += `- **${i18n2.t("evolve.menu_type")}**: ${formatCapabilityType(i18n2, s.type)}
-`;
-          output += `- **${i18n2.t("evolve.menu_reason")}**: ${s.reason}
-`;
-          output += `- **${i18n2.t("evolve.menu_pattern_id")}**: \`${s.pattern.id}\`
-
-`;
-        }
-        output += `
-${i18n2.t("evolve.menu_footer")}`;
-        return output;
-      }
-    }),
-    "mimic:level": tool({
-      description: baseI18n.t("tool.level.description"),
+    "mimic:level": tool7({
+      description: i18n.t("tool.level.description"),
       args: {
-        level: tool.schema.enum(["technical", "semi-technical", "non-technical", "chaotic"]).describe(baseI18n.t("tool.level.args.level"))
+        level: tool7.schema.enum(["technical", "semi-technical", "non-technical", "chaotic"]).describe(i18n.t("tool.level.args.level"))
       },
       async execute(args) {
         const i18n2 = await i18nPromise;
@@ -1564,11 +3708,11 @@ ${i18n2.t("evolve.menu_footer")}`;
         });
       }
     }),
-    "mimic:focus": tool({
-      description: baseI18n.t("tool.focus.description"),
+    "mimic:focus": tool7({
+      description: i18n.t("tool.focus.description"),
       args: {
-        focus: tool.schema.string().optional().describe(baseI18n.t("tool.focus.args.focus")),
-        stack: tool.schema.string().optional().describe(baseI18n.t("tool.focus.args.stack"))
+        focus: tool7.schema.string().optional().describe(i18n.t("tool.focus.args.focus")),
+        stack: tool7.schema.string().optional().describe(i18n.t("tool.focus.args.stack"))
       },
       async execute(args) {
         const i18n2 = await i18nPromise;
@@ -1591,126 +3735,26 @@ ${i18n2.t("evolve.menu_footer")}`;
 `;
         return output;
       }
-    }),
-    "mimic:mcp-search": tool({
-      description: baseI18n.t("tool.mcp_search.description"),
-      args: {
-        query: tool.schema.string().describe(baseI18n.t("tool.mcp_search.args.query"))
-      },
-      async execute(args) {
-        const i18n2 = await i18nPromise;
-        const searchUrl = `https://mcpmarket.com/search?q=${encodeURIComponent(args.query)}`;
-        const popular = [
-          {
-            name: "context7",
-            desc: i18n2.t("mcp_search.desc.context7"),
-            url: "https://mcp.context7.com/mcp"
-          },
-          {
-            name: "github",
-            desc: i18n2.t("mcp_search.desc.github"),
-            url: "https://mcp.github.com"
-          },
-          {
-            name: "supabase",
-            desc: i18n2.t("mcp_search.desc.supabase"),
-            url: "https://mcp.supabase.com"
-          },
-          { name: "playwright", desc: i18n2.t("mcp_search.desc.playwright") },
-          { name: "firecrawl", desc: i18n2.t("mcp_search.desc.firecrawl") }
-        ];
-        const popularLines = popular.map(
-          (server) => server.url ? `- **${server.name}** - ${server.desc}: \`${server.url}\`` : `- **${server.name}** - ${server.desc}`
-        ).join("\n");
-        return `${i18n2.t("mcp_search.header", {
-          query: args.query,
-          url: searchUrl
-        })}
-
-${i18n2.t("mcp_search.popular")}
-${popularLines}
-
-${i18n2.t("mcp_search.add")}`;
-      }
-    }),
-    "mimic:mcp": tool({
-      description: baseI18n.t("tool.mcp.description"),
-      args: {
-        name: tool.schema.string().describe(baseI18n.t("tool.mcp.args.name")),
-        url: tool.schema.string().optional().describe(baseI18n.t("tool.mcp.args.url")),
-        command: tool.schema.string().optional().describe(baseI18n.t("tool.mcp.args.command"))
-      },
-      async execute(args) {
-        const i18n2 = await i18nPromise;
-        const { existsSync: existsSync4 } = await import("fs");
-        const { readFile: readFile4, writeFile: fsWriteFile, mkdir: mkdir3 } = await import("fs/promises");
-        const { join: join4 } = await import("path");
-        const opencodeDir = join4(directory, ".opencode");
-        if (!existsSync4(opencodeDir)) {
-          await mkdir3(opencodeDir, { recursive: true });
-        }
-        const configPath = join4(directory, "opencode.json");
-        let config = {};
-        if (existsSync4(configPath)) {
-          try {
-            config = JSON.parse(await readFile4(configPath, "utf-8"));
-          } catch {
-            config = {};
-          }
-        }
-        const mcpEntry = {};
-        if (args.url) {
-          mcpEntry.type = "remote";
-          mcpEntry.url = args.url;
-        } else if (args.command) {
-          mcpEntry.type = "local";
-          mcpEntry.command = args.command.split(",").map((s) => s.trim());
-        } else {
-          return i18n2.t("mcp.need_url_or_command");
-        }
-        mcpEntry.enabled = true;
-        config.mcp = { ...config.mcp || {}, [args.name]: mcpEntry };
-        await fsWriteFile(configPath, JSON.stringify(config, null, 2));
-        await stateManager.addMilestone(i18n2.t("milestone.mcp_added", { name: args.name }));
-        return i18n2.t("mcp.added", { name: args.name });
-      }
-    }),
-    "mimic:capabilities": tool({
-      description: baseI18n.t("tool.capabilities.description"),
-      args: {},
-      async execute() {
-        const i18n2 = await i18nPromise;
-        const state = await stateManager.read();
-        if (state.evolution.capabilities.length === 0) {
-          return i18n2.t("capabilities.empty");
-        }
-        let output = `${i18n2.t("capabilities.title")}
-
-`;
-        output += `${i18n2.t("capabilities.intro")}
-
-`;
-        for (const cap of state.evolution.capabilities) {
-          output += `### \u2728 ${cap.name}
-`;
-          output += `- **${i18n2.t("capabilities.type")}**: ${formatCapabilityType(
-            i18n2,
-            cap.type
-          )}
-`;
-          output += `- **${i18n2.t("capabilities.description")}**: ${cap.description}
-`;
-          output += `- **${i18n2.t("capabilities.consumed")}**: ${format2(
-            new Date(cap.createdAt),
-            "yyyy-MM-dd"
-          )}
-
-`;
-        }
-        return output;
-      }
     })
   };
+};
+
+// src/tools/main.ts
+function createDefaultRegistry() {
+  return new ToolRegistry().register(createCoreTools).register(createSettingsTools).register(createEvolutionTools).register(createInstinctTools).register(createObservationTools).register(createMcpTools).register(createAutomationTools);
+}
+function createTools(stateManager, directory, toolCalls, i18n) {
+  const baseI18n = i18n ?? createI18n(resolveLanguage(null));
+  const i18nPromise = i18n ? Promise.resolve(i18n) : loadMimicConfig().then((config) => createI18n(resolveLanguage(config))).catch(() => createI18n(resolveLanguage(null)));
+  const ctx = {
+    stateManager,
+    directory,
+    toolCalls,
+    i18n: baseI18n,
+    i18nPromise
+  };
+  const registry = createDefaultRegistry();
+  return registry.build(ctx);
 }
 
 // src/index.ts
@@ -1718,12 +3762,24 @@ var mimic = async ({ directory, client }) => {
   const stateManager = new StateManager(directory);
   await stateManager.initialize();
   const i18n = createI18n(resolveLanguage(await loadMimicConfig()));
+  const observationLog = new ObservationLog(
+    stateManager.getInstinctsDir().replace("/instincts", "")
+  );
+  await observationLog.initialize();
+  const sessionMemory = new SessionMemoryManager(
+    stateManager.getInstinctsDir().replace("/instincts", ""),
+    stateManager.getSessionsDir()
+  );
+  const skillGenerator = new SkillGenerator(directory);
+  await skillGenerator.initialize();
   const ctx = { stateManager, directory, i18n, client };
-  const sessionId = crypto.randomUUID();
+  const sessionId = generateId();
   const sessionStartTime = Date.now();
   const toolCalls = [];
   const filesEdited = /* @__PURE__ */ new Set();
+  let currentBranch;
   const handleSessionCreated = async () => {
+    await stateManager.initializeIdentity();
     const state = await stateManager.read();
     const timeSince = analyzeTimeSinceLastSession(state.journey.lastSession);
     state.statistics.totalSessions += 1;
@@ -1731,19 +3787,78 @@ var mimic = async ({ directory, client }) => {
     state.journey.sessionCount += 1;
     state.journey.lastSession = (/* @__PURE__ */ new Date()).toISOString();
     await stateManager.save(state);
+    await observationLog.logSessionStart(sessionId);
     if (timeSince === "long-break") {
       await stateManager.addObservation(i18n.t("obs.returned_after_long_break"));
     }
+    const hints = await sessionMemory.getContinuityHints();
+    const hintMessage = hints.length > 0 ? `
+${hints[0]}` : "";
+    const instinctContext = await buildInstinctContext(ctx);
+    if (instinctContext) {
+      await client.tui.showToast({
+        body: {
+          title: "[Mimic] \u{1F9E0}",
+          message: i18n.t("instincts.auto_applied"),
+          variant: "info"
+        }
+      });
+    }
     await client.tui.showToast({
       body: {
         message: i18n.t("log.session_started", {
           sessions: state.journey.sessionCount,
           patterns: state.patterns.length
-        }),
+        }) + hintMessage,
         variant: "info"
       }
     });
   };
+  const notifyEvolution = async (domain, capability) => {
+    try {
+      const skill = await skillGenerator.fromCapability(ctx, capability);
+      if (skill) {
+        await client.tui.showToast({
+          body: {
+            title: "[Mimic] \u{1F4DA}",
+            message: i18n.t("observer.skill_generated", { name: skill.name }),
+            variant: "success"
+          }
+        });
+      }
+    } catch {
+    }
+    await client.tui.showToast({
+      body: {
+        title: "[Mimic] \u2728",
+        message: i18n.t("observer.evolved", {
+          name: capability.name,
+          domain
+        }),
+        variant: "success"
+      }
+    });
+  };
+  const processEvolution = async () => {
+    if (!await shouldRunObserver(ctx)) return;
+    const newInstincts = await runObserver(ctx);
+    if (newInstincts.length > 0) {
+      await client.tui.showToast({
+        body: {
+          title: "[Mimic]",
+          message: i18n.t("observer.new_instincts", { count: newInstincts.length }),
+          variant: "info"
+        }
+      });
+    }
+    const triggeredDomains = await clusterDomainsAndTriggerEvolution(ctx);
+    for (const domain of triggeredDomains) {
+      const result = await evolveDomain(ctx, domain);
+      if (result) {
+        await notifyEvolution(domain, result.capability);
+      }
+    }
+  };
   const handleSessionIdle = async () => {
     const newPatterns = await detectPatterns(ctx);
     if (newPatterns.length > 0) {
@@ -1751,6 +3866,7 @@ var mimic = async ({ directory, client }) => {
       state.patterns.push(...newPatterns);
       await stateManager.save(state);
     }
+    await processEvolution();
     const suggestions = await surfacePatterns(ctx);
     for (const suggestion of suggestions) {
       await client.tui.showToast({
@@ -1763,28 +3879,76 @@ var mimic = async ({ directory, client }) => {
     }
   };
   const handleFileEdited = async (event) => {
-    if (!("properties" in event)) return;
-    const filename = event.properties?.filename;
-    if (!filename) return;
-    filesEdited.add(filename);
+    if (!(event.type === OPENCODE_EVENTS.FILE_EDITED && "properties" in event)) return;
+    const file = event.properties?.file;
+    if (!file) return;
+    filesEdited.add(file);
+    await observationLog.logFileEdit(file, sessionId);
     const state = await stateManager.read();
-    state.statistics.filesModified[filename] = (state.statistics.filesModified[filename] || 0) + 1;
+    state.statistics.filesModified[file] = (state.statistics.filesModified[file] || 0) + 1;
     await stateManager.save(state);
   };
+  const handleVcsBranchUpdated = async (event) => {
+    if (!(event.type === OPENCODE_EVENTS.VCS_BRANCH_UPDATED && "properties" in event)) return;
+    const branch = event.properties?.branch;
+    if (branch !== currentBranch) {
+      currentBranch = branch;
+      await observationLog.logBranchChange(branch);
+    }
+  };
+  const handleCommandExecuted = async (event) => {
+    if (!(event.type === OPENCODE_EVENTS.COMMAND_EXECUTED && "properties" in event)) return;
+    const props = event.properties;
+    if (props.name) {
+      await observationLog.logCommand(props.name, sessionId, props.arguments);
+    }
+  };
+  const handleMessageUpdated = async (event) => {
+    if (!(event.type === OPENCODE_EVENTS.MESSAGE_UPDATED && "properties" in event)) return;
+    const info = event.properties?.info;
+    if (!info) return;
+    if (info.role === "assistant" && info.tokens) {
+      await observationLog.logAssistantMessage(
+        sessionId,
+        info.id || "",
+        info.tokens.input + info.tokens.output
+      );
+    }
+  };
   return {
     async event({ event }) {
       switch (event.type) {
-        case "session.created":
+        case OPENCODE_EVENTS.SESSION_CREATED:
           await handleSessionCreated();
           return;
-        case "session.idle":
+        case OPENCODE_EVENTS.SESSION_IDLE:
           await handleSessionIdle();
           return;
-        case "file.edited":
+        case OPENCODE_EVENTS.FILE_EDITED:
           await handleFileEdited(event);
+          return;
+        case OPENCODE_EVENTS.VCS_BRANCH_UPDATED:
+          await handleVcsBranchUpdated(event);
+          return;
+        case OPENCODE_EVENTS.COMMAND_EXECUTED:
+          await handleCommandExecuted(event);
+          return;
+        case OPENCODE_EVENTS.MESSAGE_UPDATED:
+          await handleMessageUpdated(event);
+          return;
+      }
+    },
+    /**
+     * Hook into user messages to capture prompts for pattern analysis
+     */
+    async [OPENCODE_EVENTS.CHAT_MESSAGE](input, output) {
+      const textParts = output.parts.filter((p) => p.type === "text").map((p) => p.text);
+      if (textParts.length > 0) {
+        const textPreview = textParts.join(" ").slice(0, 200);
+        await observationLog.logUserMessage(sessionId, input.messageID || "", textPreview);
       }
     },
-    async "tool.execute.after"(input, _output) {
+    async [OPENCODE_EVENTS.TOOL_EXECUTE_AFTER](input, _output) {
       const state = await stateManager.read();
       if (!state.preferences.learningEnabled) return;
       const toolCall = {
@@ -1794,6 +3958,7 @@ var mimic = async ({ directory, client }) => {
       };
       toolCalls.push(toolCall);
       state.statistics.totalToolCalls += 1;
+      await observationLog.logToolCall(input.tool, input.callID, sessionId);
       const toolPattern = input.tool;
       const existing = state.patterns.find(
         (p) => p.type === "tool" && p.description === toolPattern
@@ -1803,7 +3968,7 @@ var mimic = async ({ directory, client }) => {
         existing.lastSeen = Date.now();
       } else {
         state.patterns.push({
-          id: crypto.randomUUID(),
+          id: generateId(),
           type: "tool",
           description: toolPattern,
           count: 1,
@@ -1814,6 +3979,10 @@ var mimic = async ({ directory, client }) => {
         });
       }
       await stateManager.save(state);
+      if (toolCalls.length >= 2) {
+        const recentTools = toolCalls.slice(-3).map((t) => t.tool);
+        await stateManager.recordToolSequence(recentTools);
+      }
     },
     async stop() {
       const sessionDuration = Date.now() - sessionStartTime;
@@ -1826,6 +3995,19 @@ var mimic = async ({ directory, client }) => {
         filesEdited: Array.from(filesEdited)
       };
       await stateManager.saveSession(sessionId, sessionData);
+      await observationLog.logSessionEnd(sessionId, sessionDuration, toolCalls.length);
+      const state = await stateManager.read();
+      const recentToolNames = toolCalls.slice(-20).map((t) => t.tool);
+      const dominantDomains = detectDomainsFromTools(recentToolNames);
+      const recentPatterns = state.patterns.filter((p) => p.lastSeen > sessionStartTime).map((p) => p.description);
+      try {
+        await sessionMemory.createMemory(sessionData, dominantDomains, recentPatterns, {
+          branch: currentBranch,
+          focus: state.project.focus,
+          keyActions: recentToolNames.slice(-5)
+        });
+      } catch {
+      }
       if (toolCalls.length > 20) {
         await stateManager.addObservation(
           i18n.t("obs.intensive_session", { tools: toolCalls.length })