opencode-memelord 0.0.1 → 0.1.0

package/dist/embedder.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Lazy-loaded local embedding function using @huggingface/transformers.
+ * Downloads the model on first use and caches it locally.
+ *
+ * Default: Xenova/all-MiniLM-L6-v2 (384 dimensions, ~22M params)
+ * With quantized=true (default), uses the q8 (8-bit) ONNX variant.
+ *
+ * Verbatim from memelord's packages/cli/src/embedder.ts.
+ */
+import type { EmbedFn } from 'memelord';
+export declare function createEmbedder(): Promise<EmbedFn>;

package/dist/hooks.d.ts

@@ -0,0 +1,22 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { StoreManager } from './store.js';
+/**
+ * session.created → inject top memories into context.
+ * Equivalent to memelord's hookSessionStart.
+ */
+export declare function onSessionCreated(sessionId: string, client: PluginInput['client'], storeManager: StoreManager): Promise<void>;
+/**
+ * tool.execute.after → record tool failures.
+ * Equivalent to memelord's hookPostToolUse.
+ */
+export declare function onToolAfter(sessionId: string, toolName: string, toolInput: unknown, toolOutput: string, toolMetadata: unknown, storeManager: StoreManager): void;
+/**
+ * session.idle → analyze transcript for corrections, discoveries, and failure patterns.
+ * Equivalent to memelord's hookStop.
+ */
+export declare function onSessionIdle(sessionId: string, client: PluginInput['client'], storeManager: StoreManager): Promise<void>;
+/**
+ * session.deleted → embed pending memories, run decay, clean up.
+ * Equivalent to memelord's hookSessionEnd.
+ */
+export declare function onSessionDeleted(sessionId: string, storeManager: StoreManager): Promise<void>;

package/dist/index.d.ts

@@ -1,15 +1,16 @@
 /**
- * opencode-memelord: OpenCode plugin for memelord persistent memory.
+ * opencode-memelord: Standalone OpenCode plugin for memelord persistent memory.
  *
- * Thin wrapper that delegates to `memelord hook <event>` CLI commands.
- * No business logic is ported — all analysis, storage, embedding, and
- * decay happens in the memelord CLI.
+ * Uses the memelord SDK directly — no MCP server, no `memelord init`,
+ * no per-project configuration needed. Databases are stored globally
+ * at ~/.config/memelord/projects/<project-key>/memory.db, keyed by
+ * git remote URL so multiple worktrees share the same database.
  *
- * Hook mapping:
- *   session.created  → memelord hook session-start
- *   tool.execute.after → memelord hook post-tool-use
- *   session.idle     → memelord hook stop
- *   session.deleted  → memelord hook session-end
+ * Provides:
+ *   - 5 custom tools (memory_start_task, memory_report, memory_end_task,
+ *     memory_contradict, memory_status) replacing the MCP server
+ *   - Lifecycle hooks (session.created, tool.execute.after, session.idle,
+ *     session.deleted) for automatic memory instrumentation
  */
-import type { Plugin } from "@opencode-ai/plugin";
+import type { Plugin } from '@opencode-ai/plugin';
 export declare const MemelordPlugin: Plugin;

package/dist/index.js

@@ -1,150 +1,660 @@
-// src/index.ts
-import { dirname, join } from "path";
-import { createRequire } from "module";
-import { writeFileSync, unlinkSync, existsSync } from "fs";
-import { tmpdir } from "os";
-function resolveMemelordBin() {
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/store.ts
+import { createMemoryStore } from "memelord";
+import { createHash } from "crypto";
+import { homedir } from "os";
+import { join } from "path";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  appendFileSync,
+  unlinkSync
+} from "fs";
+
+// src/embedder.ts
+var cachedEmbedder = null;
+async function createEmbedder() {
+  if (cachedEmbedder)
+    return cachedEmbedder;
+  const { pipeline } = await import("@huggingface/transformers");
+  const model = process.env.MEMELORD_MODEL ?? "Xenova/all-MiniLM-L6-v2";
+  const extractor = await pipeline("feature-extraction", model, {
+    quantized: true
+  });
+  cachedEmbedder = async (text) => {
+    const output = await extractor(text, { pooling: "mean", normalize: true });
+    return new Float32Array(output.data);
+  };
+  return cachedEmbedder;
+}
+
+// src/store.ts
+var projectKeyCache = new Map;
+async function getProjectKey(worktree, $) {
+  const cached = projectKeyCache.get(worktree);
+  if (cached)
+    return cached;
+  let source = worktree;
   try {
-    const require2 = createRequire(import.meta.url);
-    const pkgPath = require2.resolve("memelord/package.json");
-    return join(dirname(pkgPath), "dist", "cli.mjs");
-  } catch {
-    return "";
-  }
+    const remoteUrl = await $`git -C ${worktree} remote get-url origin`.quiet().nothrow().text();
+    if (remoteUrl.trim()) {
+      source = remoteUrl.trim();
+    }
+  } catch {}
+  const key = createHash("sha256").update(source).digest("hex").slice(0, 16);
+  projectKeyCache.set(worktree, key);
+  return key;
+}
+function getProjectDir(projectKey) {
+  const dir = join(homedir(), ".config", "memelord", "projects", projectKey);
+  if (!existsSync(dir))
+    mkdirSync(dir, { recursive: true });
+  return dir;
 }
-var MemelordPlugin = async ({ client, directory, worktree, $ }) => {
-  const cwd = worktree || directory;
-  const memelordBin = resolveMemelordBin();
-  let currentSessionId = "";
-  async function callHook(event, stdinData) {
-    const json = JSON.stringify(stdinData);
+function getSessionsDir(projectKey) {
+  const dir = join(getProjectDir(projectKey), "sessions");
+  if (!existsSync(dir))
+    mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function sessionFilePath(projectKey, sessionId) {
+  return join(getSessionsDir(projectKey), `${sessionId}.json`);
+}
+function failuresFilePath(projectKey, sessionId) {
+  return join(getSessionsDir(projectKey), `${sessionId}.failures.jsonl`);
+}
+async function createStoreManager(worktree, $) {
+  const projectKey = await getProjectKey(worktree, $);
+  const dbPath = join(getProjectDir(projectKey), "memory.db");
+  const dummyEmbed = async () => new Float32Array(384);
+  let currentSessionId = "unknown";
+  let lightStore = null;
+  let liveStore = null;
+  let lightStoreSessionId = "";
+  let liveStoreSessionId = "";
+  function setCurrentSessionId(sessionId) {
+    currentSessionId = sessionId;
+  }
+  async function getStore() {
+    if (!lightStore || lightStoreSessionId !== currentSessionId) {
+      if (lightStore)
+        await lightStore.close().catch(() => {});
+      lightStore = createMemoryStore({
+        dbPath,
+        sessionId: currentSessionId,
+        embed: dummyEmbed
+      });
+      await lightStore.init();
+      lightStoreSessionId = currentSessionId;
+    }
+    return lightStore;
+  }
+  async function getLiveStore() {
+    if (!liveStore || liveStoreSessionId !== currentSessionId) {
+      if (liveStore)
+        await liveStore.close().catch(() => {});
+      const embed = await createEmbedder();
+      liveStore = createMemoryStore({
+        dbPath,
+        sessionId: currentSessionId,
+        embed
+      });
+      await liveStore.init();
+      liveStoreSessionId = currentSessionId;
+    }
+    return liveStore;
+  }
+  function getSessionState(sessionId) {
+    const path = sessionFilePath(projectKey, sessionId);
+    if (!existsSync(path))
+      return null;
     try {
-      if (memelordBin) {
-        return await $`echo ${json} | node ${memelordBin} hook ${event}`.quiet().nothrow().text();
-      }
-      return await $`echo ${json} | memelord hook ${event}`.quiet().nothrow().text();
+      return JSON.parse(readFileSync(path, "utf-8"));
     } catch {
-      return "";
+      return null;
     }
   }
-  function convertTranscript(messages) {
-    const lines = [];
-    for (const { info, parts } of messages) {
-      const content = [];
-      for (const part of parts) {
-        if (part.type === "text") {
-          content.push({ type: "text", text: part.text });
-        } else if (part.type === "tool") {
-          content.push({
-            type: "tool_use",
-            name: part.tool,
-            input: part.state.status !== "pending" ? part.state.input : {}
-          });
-          if (part.state.status === "completed") {
-            content.push({ type: "tool_result", content: part.state.output });
-          } else if (part.state.status === "error") {
-            content.push({
-              type: "tool_result",
-              content: part.state.error,
-              is_error: true
+  function setSessionState(sessionId, state) {
+    writeFileSync(sessionFilePath(projectKey, sessionId), JSON.stringify(state));
+  }
+  function getFailures(sessionId) {
+    const path = failuresFilePath(projectKey, sessionId);
+    if (!existsSync(path))
+      return [];
+    try {
+      return readFileSync(path, "utf-8").trim().split(`
+`).map((line) => {
+        try {
+          return JSON.parse(line);
+        } catch {
+          return null;
+        }
+      }).filter(Boolean);
+    } catch {
+      return [];
+    }
+  }
+  function appendFailure(sessionId, failure) {
+    appendFileSync(failuresFilePath(projectKey, sessionId), JSON.stringify(failure) + `
+`);
+  }
+  function cleanupSession(sessionId) {
+    const sf = sessionFilePath(projectKey, sessionId);
+    const ff = failuresFilePath(projectKey, sessionId);
+    if (existsSync(sf))
+      try {
+        unlinkSync(sf);
+      } catch {}
+    if (existsSync(ff))
+      try {
+        unlinkSync(ff);
+      } catch {}
+  }
+  return {
+    getStore,
+    getLiveStore,
+    setCurrentSessionId,
+    getSessionState,
+    setSessionState,
+    getFailures,
+    appendFailure,
+    cleanupSession
+  };
+}
+
+// src/tools.ts
+import { tool } from "@opencode-ai/plugin";
+function createTools(storeManager) {
+  return {
+    memory_start_task: tool({
+      description: `Start a new task and retrieve relevant memories. You MUST call this FIRST at the beginning of every task, before doing any work. Pass the user's request or task description.
+
+Returns memories from past experience that are relevant to this task. These memories contain lessons learned from previous sessions — patterns that worked, mistakes to avoid, project-specific knowledge. Using them will help you avoid repeating past mistakes and work more efficiently.
+
+Also returns a task_id that you MUST pass to memory_end_task when you finish.`,
+      args: {
+        description: tool.schema.string().describe("The user's request or task description")
+      },
+      async execute(args) {
+        try {
+          const store = await storeManager.getLiveStore();
+          try {
+            await store.embedPending();
+          } catch {}
+          const result = await store.startTask(args.description);
+          let text = `Task started (id: ${result.taskId})
+
+`;
+          if (result.memories.length === 0) {
+            text += "No relevant memories found. This appears to be a new type of task.";
+          } else {
+            text += `Retrieved ${result.memories.length} relevant memories:
+
+`;
+            for (const mem of result.memories) {
+              text += `--- [${mem.category}] (weight: ${mem.weight.toFixed(2)}, score: ${mem.score.toFixed(3)}) ---
+`;
+              text += `${mem.content}
+
+`;
+            }
+          }
+          return text;
+        } catch (e) {
+          return `Error: ${e.message}`;
+        }
+      }
+    }),
+    memory_report: tool({
+      description: `Report a self-correction or user-provided knowledge to persist across sessions.
+
+Use type "correction" when you:
+- Tried the wrong file path, function name, or API and had to search for the correct one
+- Used the wrong tool, command, or pattern for this project
+- Made an architectural assumption that turned out wrong
+- Wasted significant effort (3+ tool calls) on a wrong approach before finding the right one
+Do NOT report: typos, minor first-try search misses, or things that took <2 tool calls to resolve.
+
+Use type "user_input" when:
+- The user denies a tool call and explains why
+- The user corrects your approach ("no, use X instead of Y")
+- The user shares project-specific knowledge ("we use Turso, not SQLite")
+- The user states a preference ("always run tests before committing")
+The user should never have to tell you the same thing twice.
+
+Use type "insight" when you discover something useful about the codebase during exploration:
+- Key file locations ("auth middleware is in src/middleware/auth.rs")
+- Architecture patterns ("the project uses a VDBE architecture: translate -> bytecode -> execute")
+- Build/test conventions ("run 'make check' before committing, tests are in tests/")
+- Important relationships between components
+Store insights proactively — they save future sessions from re-exploring the same codebase.`,
+      args: {
+        type: tool.schema.enum(["correction", "user_input", "insight"]).describe("What kind of memory: correction (self-correction), user_input (user-provided knowledge), or insight (codebase knowledge discovered during exploration)"),
+        lesson: tool.schema.string().describe("The lesson learned — what the agent should remember"),
+        what_failed: tool.schema.string().optional().describe("(correction only) The approach that failed"),
+        what_worked: tool.schema.string().optional().describe("(correction only) The approach that worked"),
+        tokens_wasted: tool.schema.number().optional().describe("(correction only) Approximate tokens spent on the wrong approach"),
+        tools_wasted: tool.schema.number().optional().describe("(correction only) Number of tool calls wasted"),
+        source: tool.schema.enum(["user_denial", "user_correction", "user_input"]).optional().describe("(user_input only) How the user provided this")
+      },
+      async execute(args) {
+        try {
+          const store = await storeManager.getStore();
+          let id;
+          if (args.type === "correction") {
+            id = await store.reportCorrection({
+              lesson: args.lesson,
+              whatFailed: args.what_failed ?? "",
+              whatWorked: args.what_worked ?? "",
+              tokensWasted: args.tokens_wasted,
+              toolsWasted: args.tools_wasted
             });
+          } else if (args.type === "insight") {
+            id = await store.insertRawMemory(args.lesson, "insight", 1);
+          } else {
+            id = await store.reportUserInput({
+              lesson: args.lesson,
+              source: args.source ?? "user_input"
+            });
+          }
+          return `Memory saved (id: ${id}). This will be remembered across sessions.`;
+        } catch (e) {
+          return `Error: ${e.message}`;
+        }
+      }
+    }),
+    memory_end_task: tool({
+      description: `End the current task and provide outcome metrics. You MUST call this when you finish a task or when the user moves on to a different request. This updates memory weights so that useful memories are strengthened and unhelpful ones decay.
+
+For self_report: rate each memory that was retrieved at task start:
+  0 = ignored / not relevant
+  1 = glanced at but didn't use
+  2 = somewhat useful
+  3 = directly applied / saved significant effort`,
+      args: {
+        task_id: tool.schema.string().describe("The task_id returned by memory_start_task"),
+        tokens_used: tool.schema.number().describe("Total tokens used during this task"),
+        tool_calls: tool.schema.number().describe("Total tool calls made during this task"),
+        errors: tool.schema.number().describe("Number of errors encountered (failed commands, test failures, etc.)"),
+        user_corrections: tool.schema.number().describe("Number of times the user corrected you or denied a tool call"),
+        completed: tool.schema.boolean().describe("Whether the task was completed successfully"),
+        self_report: tool.schema.array(tool.schema.object({
+          memory_id: tool.schema.string(),
+          score: tool.schema.number().min(0).max(3)
+        })).optional().describe("Rate each retrieved memory: 0=ignored, 1=glanced, 2=useful, 3=directly applied")
+      },
+      async execute(args) {
+        try {
+          const store = await storeManager.getStore();
+          await store.endTask(args.task_id, {
+            tokensUsed: args.tokens_used,
+            toolCalls: args.tool_calls,
+            errors: args.errors,
+            userCorrections: args.user_corrections,
+            completed: args.completed,
+            selfReport: args.self_report?.map((s) => ({
+              memoryId: s.memory_id,
+              score: s.score
+            }))
+          });
+          const decayResult = await store.decay();
+          let text = "Task ended. Score recorded and memory weights updated.";
+          if (decayResult.deleted > 0) {
+            text += `
+${decayResult.deleted} stale memories cleaned up.`;
           }
+          return text;
+        } catch (e) {
+          return `Error: ${e.message}`;
         }
       }
-      const msg = { role: info.role, content };
-      if (info.role === "assistant") {
-        const a = info;
-        msg.usage = {
-          input_tokens: a.tokens.input,
-          output_tokens: a.tokens.output,
-          cache_creation_input_tokens: a.tokens.cache.write
-        };
+    }),
+    memory_contradict: tool({
+      description: `Flag a retrieved memory as incorrect and remove it. Call this when a memory is factually wrong or led you down the wrong path.
+
+Optionally provide a correction — the correct information that should replace the bad memory.
+
+Example: You retrieve a memory saying "config is in /etc/shadow" but discover it's actually in src/config/auth.toml. Call this with the memory_id and correction="Config is in src/config/auth.toml, not /etc/shadow".`,
+      args: {
+        memory_id: tool.schema.string().describe("The ID of the incorrect memory to remove"),
+        correction: tool.schema.string().optional().describe("What's actually true — stored as a new high-weight memory to replace the wrong one")
+      },
+      async execute(args) {
+        try {
+          const store = await storeManager.getStore();
+          const result = await store.contradictMemory(args.memory_id, args.correction);
+          if (!result.deleted) {
+            return `Memory ${args.memory_id} not found.`;
+          }
+          let text = "Incorrect memory deleted.";
+          if (result.correctionId) {
+            text += ` Correction saved (id: ${result.correctionId}).`;
+          }
+          return text;
+        } catch (e) {
+          return `Error: ${e.message}`;
+        }
       }
-      lines.push(JSON.stringify(msg));
-    }
-    return lines.join(`
+    }),
+    memory_status: tool({
+      description: "Show memory system statistics: total memories stored, memory health, task history. Use this to check that the memory system is working.",
+      args: {},
+      async execute() {
+        try {
+          const store = await storeManager.getStore();
+          const stats = await store.getStats();
+          const lines = [
+            "memelord status:",
+            `  Memories stored:    ${stats.totalMemories}`,
+            `  Tasks completed:    ${stats.taskCount}`,
+            `  Avg task score:     ${stats.avgTaskScore.toFixed(3)}`
+          ];
+          if (stats.topMemories.length > 0) {
+            lines.push(`
+  Top memories by weight:`);
+            for (const mem of stats.topMemories.slice(0, 5)) {
+              const preview = mem.content.length > 80 ? mem.content.slice(0, 80) + "..." : mem.content;
+              lines.push(`    [w=${mem.weight.toFixed(2)}, used=${mem.retrievalCount}x] ${preview}`);
+            }
+          }
+          return lines.join(`
 `);
+        } catch (e) {
+          return `Error: ${e.message}`;
+        }
+      }
+    })
+  };
+}
+
+// src/hooks.ts
+function extractToolSequences(messages) {
+  const sequence = [];
+  for (const { parts } of messages) {
+    for (const part of parts) {
+      if (part.type !== "tool")
+        continue;
+      if (part.state.status === "completed") {
+        const output = part.state.output ?? "";
+        const hasError = output.includes("Error:") || output.includes("ENOENT") || output.includes("command not found");
+        sequence.push({
+          tool: part.tool,
+          input: part.state.input,
+          failed: hasError
+        });
+      } else if (part.state.status === "error") {
+        sequence.push({
+          tool: part.tool,
+          input: part.state.input,
+          failed: true
+        });
+      }
+    }
   }
-  async function onSessionCreated(sessionId) {
-    currentSessionId = sessionId;
-    if (!existsSync(join(cwd, ".memelord")))
-      return;
-    const stdout = await callHook("session-start", {
-      session_id: sessionId,
-      cwd
+  return sequence;
+}
+function detectCorrections(sequence) {
+  const corrections = [];
+  for (let i = 0;i < sequence.length - 1; i++) {
+    if (!sequence[i].failed)
+      continue;
+    for (let j = i + 1;j < Math.min(i + 4, sequence.length); j++) {
+      if (sequence[j].tool === sequence[i].tool && !sequence[j].failed) {
+        const failedInput = typeof sequence[i].input === "string" ? sequence[i].input : JSON.stringify(sequence[i].input).slice(0, 200);
+        const succeededInput = typeof sequence[j].input === "string" ? sequence[j].input : JSON.stringify(sequence[j].input).slice(0, 200);
+        if (failedInput !== succeededInput) {
+          corrections.push({
+            failedTool: sequence[i].tool,
+            failedInput,
+            succeededTool: sequence[j].tool,
+            succeededInput
+          });
+        }
+        break;
+      }
+    }
+  }
+  return corrections;
+}
+function sumTokens(messages) {
+  let total = 0;
+  for (const { info } of messages) {
+    if (info.role === "assistant") {
+      const a = info;
+      total += a.tokens.input;
+      total += a.tokens.output;
+      total += a.tokens.cache.write;
+    }
+  }
+  return total;
+}
+function extractTextBlocks(messages) {
+  const texts = [];
+  for (const { info, parts } of messages) {
+    if (info.role !== "assistant")
+      continue;
+    for (const part of parts) {
+      if (part.type === "text" && typeof part.text === "string" && part.text.length > 80) {
+        texts.push(part.text);
+      }
+    }
+  }
+  return texts;
+}
+function isToolFailure(output, metadata) {
+  return metadata != null && typeof metadata.exitCode === "number" && metadata.exitCode !== 0 || typeof output === "string" && (output.startsWith("Error:") || output.startsWith("error:") || output.includes("ENOENT") || output.includes("command not found") || output.includes("No such file") || output.includes("Permission denied"));
+}
+async function onSessionCreated(sessionId, client, storeManager) {
+  storeManager.setCurrentSessionId(sessionId);
+  const store = await storeManager.getStore();
+  try {
+    const memories = await store.getTopByWeight(5);
+    storeManager.setSessionState(sessionId, {
+      sessionId,
+      startedAt: Math.floor(Date.now() / 1000),
+      injectedMemoryIds: memories.map((m) => m.id)
     });
-    if (!stdout.trim())
-      return;
-    try {
-      const parsed = JSON.parse(stdout);
-      const context = parsed?.hookSpecificOutput?.additionalContext;
-      if (context) {
-        await client.session.prompt({
-          path: { id: sessionId },
-          body: {
-            noReply: true,
-            parts: [{ type: "text", text: context }]
-          }
-        });
+    let context = "";
+    if (memories.length > 0) {
+      context += `# Memories from past sessions
+
+`;
+      for (const mem of memories) {
+        context += `[${mem.category}] (id: ${mem.id}, weight: ${mem.weight.toFixed(2)})
+${mem.content}
+
+`;
       }
-    } catch {}
+    }
+    context += `# Memory system instructions
+
+You have a persistent memory system available via tools. Use it:
+
+1. At the START of every task, call memory_start_task with the user's request. This retrieves task-relevant memories using vector search (more precise than the weight-based ones above).
+
+2. When you self-correct (tried something that failed, then found the right approach), call memory_report with type "correction".
+
+3. When the user corrects you or shares project knowledge, call memory_report with type "user_input". The user should never have to tell you the same thing twice.
+
+4. When you discover something useful about the codebase (key file locations, architecture patterns, build/test conventions), call memory_report with type "insight". This saves future sessions from re-exploring the same codebase.
+
+5. IMPORTANT — Before finishing a task, review the memories above against what you actually found. If any memory contains incorrect information (wrong file paths, wrong function names, wrong explanations), you MUST call memory_contradict with its id to remove it. Provide the correct information so future sessions get it right. Bad memories poison every future session if not removed.
+
+6. When you finish a task, call memory_end_task with outcome metrics and rate each retrieved memory (0=ignored, 1=glanced, 2=useful, 3=directly applied).`;
+    await client.session.prompt({
+      path: { id: sessionId },
+      body: {
+        noReply: true,
+        parts: [{ type: "text", text: context }]
+      }
+    });
+  } catch (e) {
+    console.error(`memelord SessionStart error: ${e.message}`);
   }
-  async function onSessionIdle(sessionId) {
-    if (!existsSync(join(cwd, ".memelord")))
-      return;
-    const stdinData = {
-      session_id: sessionId,
-      cwd
-    };
+}
+function onToolAfter(sessionId, toolName, toolInput, toolOutput, toolMetadata, storeManager) {
+  const meta = toolMetadata;
+  if (!isToolFailure(toolOutput, meta))
+    return;
+  const errorSummary = toolOutput.slice(0, 500);
+  storeManager.appendFailure(sessionId, {
+    timestamp: Math.floor(Date.now() / 1000),
+    toolName,
+    toolInput,
+    errorSummary
+  });
+}
+async function onSessionIdle(sessionId, client, storeManager) {
+  const store = await storeManager.getStore();
+  try {
+    let correctionsFound = 0;
+    let discoveryStored = false;
+    let messages = [];
     try {
       const response = await client.session.messages({
         path: { id: sessionId }
       });
-      const messages = response.data;
-      if (messages && messages.length > 0) {
-        const transcript = convertTranscript(messages);
-        const tmpFile = join(tmpdir(), `memelord-transcript-${sessionId}.jsonl`);
-        writeFileSync(tmpFile, transcript);
-        stdinData.transcript_path = tmpFile;
-        await callHook("stop", stdinData);
-        try {
-          unlinkSync(tmpFile);
-        } catch {}
-        return;
-      }
+      messages = response.data ?? [];
     } catch {}
-    await callHook("stop", stdinData);
+    if (messages.length > 0) {
+      const sequence = extractToolSequences(messages);
+      const corrections = detectCorrections(sequence);
+      for (const c of corrections) {
+        const content = `Auto-detected correction with ${c.failedTool}:
+
+Failed approach: ${c.failedInput}
+Working approach: ${c.succeededInput}`;
+        await store.insertRawMemory(content, "correction", 1.5);
+        correctionsFound++;
+      }
+      const totalTokens = sumTokens(messages);
+      if (totalTokens >= 50000) {
+        const exploration = { reads: 0, searches: 0, edits: 0 };
+        for (const s of sequence) {
+          const t = s.tool;
+          if (t === "Read" || t === "read" || t.includes("cachebro_read_file") || t.includes("cachebro_read_files")) {
+            exploration.reads++;
+          } else if (t === "Grep" || t === "grep" || t === "Glob" || t === "glob" || t === "LSP" || t === "lsp") {
+            exploration.searches++;
+          } else if (t === "Edit" || t === "edit" || t === "Write" || t === "write") {
+            exploration.edits++;
+          }
+        }
+        const ratio = (exploration.reads + exploration.searches) / Math.max(exploration.reads + exploration.searches + exploration.edits, 1);
+        if (ratio > 0.5) {
+          const texts = extractTextBlocks(messages);
+          if (texts.length > 0) {
+            const sorted = [...texts].sort((a, b) => b.length - a.length);
+            const combined = new Set([
+              ...sorted.slice(0, 5),
+              ...texts.slice(-2)
+            ]);
+            const ordered = texts.filter((t) => combined.has(t));
+            const summary = ordered.map((t) => t.slice(0, 500)).join(`
+
+`).slice(0, 2000);
+            if (summary.length >= 100) {
+              await store.insertRawMemory(`[Discovery after ${Math.round(totalTokens / 1000)}k tokens, ${sequence.length} tool calls]
+
+${summary}`, "discovery", 1);
+              discoveryStored = true;
+            }
+          }
+        }
+      }
+      const totalTokens2 = sumTokens(messages);
+      if (totalTokens2 >= 20000) {
+        const session = storeManager.getSessionState(sessionId);
+        const injectedIds = session?.injectedMemoryIds ?? [];
+        if (injectedIds.length > 0) {
+          let penalized = 0;
+          for (const id of injectedIds) {
+            await store.penalizeMemory(id, 0.999);
+            penalized++;
+          }
+          if (penalized > 0) {
+            console.error(`memelord: penalized ${penalized} injected memories (session used ${Math.round(totalTokens2 / 1000)}k tokens)`);
+          }
+        }
+      }
+    }
+    const failures = storeManager.getFailures(sessionId);
+    if (failures.length > 0) {
+      const toolFailCounts = new Map;
+      for (const f of failures) {
+        toolFailCounts.set(f.toolName, (toolFailCounts.get(f.toolName) ?? 0) + 1);
+      }
+      for (const [toolName, count] of toolFailCounts) {
+        if (count >= 3) {
+          const examples = failures.filter((f) => f.toolName === toolName).slice(0, 2).map((f) => f.errorSummary.slice(0, 100)).join("; ");
+          await store.insertRawMemory(`Repeated failures with ${toolName} (${count}x in session): ${examples}`, "correction", 1);
+          correctionsFound++;
+        }
+      }
+    }
+    if (correctionsFound > 0) {
+      console.error(`memelord: stored ${correctionsFound} auto-detected corrections`);
+    }
+    if (discoveryStored) {
+      console.error("memelord: stored 1 discovery from high-token exploration");
+    }
+  } catch (e) {
+    console.error(`memelord Stop error: ${e.message}`);
   }
-  async function onSessionDeleted(sessionId) {
-    if (!existsSync(join(cwd, ".memelord")))
-      return;
-    await callHook("session-end", {
-      session_id: sessionId,
-      cwd
-    });
+}
+async function onSessionDeleted(sessionId, storeManager) {
+  try {
+    const store = await storeManager.getLiveStore();
+    const embedded = await store.embedPending();
+    if (embedded > 0) {
+      console.error(`memelord: embedded ${embedded} pending memories`);
+    }
+    const decayResult = await store.decay();
+    if (decayResult.deleted > 0) {
+      console.error(`memelord: cleaned up ${decayResult.deleted} stale memories`);
+    }
+    storeManager.cleanupSession(sessionId);
+  } catch (e) {
+    console.error(`memelord SessionEnd error: ${e.message}`);
   }
+}
+
+// src/index.ts
+var MemelordPlugin = async ({ client, worktree, $ }) => {
+  const storeManager = await createStoreManager(worktree, $);
   return {
+    tool: createTools(storeManager),
     "tool.execute.after": async (input, output) => {
-      if (!existsSync(join(cwd, ".memelord")))
-        return;
-      if (!currentSessionId)
-        return;
-      callHook("post-tool-use", {
-        session_id: currentSessionId,
-        cwd,
-        tool_name: input.tool,
-        tool_input: input.args,
-        tool_response: output.output ?? ""
-      }).catch(() => {});
+      onToolAfter(input.sessionID, input.tool, input.args, output.output ?? "", output.metadata, storeManager);
     },
     event: async (input) => {
       const { event } = input;
       if (event.type === "session.created") {
-        await onSessionCreated(event.properties.info.id);
+        await onSessionCreated(event.properties.info.id, client, storeManager);
       } else if (event.type === "session.idle") {
-        onSessionIdle(event.properties.sessionID).catch(() => {});
+        onSessionIdle(event.properties.sessionID, client, storeManager).catch(() => {});
       } else if (event.type === "session.deleted") {
-        await onSessionDeleted(event.properties.info.id);
+        await onSessionDeleted(event.properties.info.id, storeManager);
       }
     }
   };

package/dist/store.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Store management: DB path resolution, store factory, and session state on disk.
+ *
+ * Databases live at ~/.config/memelord/projects/<project-key>/memory.db
+ * where project-key is derived from the git remote URL (stable across worktrees).
+ *
+ * Session state (injected memory IDs, failures) is stored alongside the DB
+ * in a sessions/ subdirectory, surviving OpenCode restarts.
+ */
+import { type MemoryStore } from 'memelord';
+import type { PluginInput } from '@opencode-ai/plugin';
+type BunShell = PluginInput['$'];
+/**
+ * Derive a stable project key from the git remote URL.
+ * Falls back to hashing the worktree path if no remote is available.
+ * Results are cached so the hash is only computed once per worktree.
+ */
+export declare function getProjectKey(worktree: string, $: BunShell): Promise<string>;
+export interface SessionState {
+    sessionId: string;
+    startedAt: number;
+    injectedMemoryIds: string[];
+}
+export interface ToolFailure {
+    timestamp: number;
+    toolName: string;
+    toolInput: unknown;
+    errorSummary: string;
+}
+export interface StoreManager {
+    /** Light store with dummy embedder — for hooks (fast, no model loading). */
+    getStore(): Promise<MemoryStore>;
+    /** Live store with real embedder — for tools + session.deleted (lazy-loads model). */
+    getLiveStore(): Promise<MemoryStore>;
+    /** Set the current session ID (called on session.created). */
+    setCurrentSessionId(sessionId: string): void;
+    getSessionState(sessionId: string): SessionState | null;
+    setSessionState(sessionId: string, state: SessionState): void;
+    getFailures(sessionId: string): ToolFailure[];
+    appendFailure(sessionId: string, failure: ToolFailure): void;
+    cleanupSession(sessionId: string): void;
+}
+export declare function createStoreManager(worktree: string, $: BunShell): Promise<StoreManager>;
+export {};

package/dist/tools.d.ts

@@ -0,0 +1,84 @@
+import type { StoreManager } from './store.js';
+export declare function createTools(storeManager: StoreManager): {
+    memory_start_task: {
+        description: string;
+        args: {
+            description: import("zod").ZodString;
+        };
+        execute(args: {
+            description: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    memory_report: {
+        description: string;
+        args: {
+            type: import("zod").ZodEnum<{
+                correction: "correction";
+                insight: "insight";
+                user_input: "user_input";
+            }>;
+            lesson: import("zod").ZodString;
+            what_failed: import("zod").ZodOptional<import("zod").ZodString>;
+            what_worked: import("zod").ZodOptional<import("zod").ZodString>;
+            tokens_wasted: import("zod").ZodOptional<import("zod").ZodNumber>;
+            tools_wasted: import("zod").ZodOptional<import("zod").ZodNumber>;
+            source: import("zod").ZodOptional<import("zod").ZodEnum<{
+                user_input: "user_input";
+                user_denial: "user_denial";
+                user_correction: "user_correction";
+            }>>;
+        };
+        execute(args: {
+            type: "correction" | "insight" | "user_input";
+            lesson: string;
+            what_failed?: string | undefined;
+            what_worked?: string | undefined;
+            tokens_wasted?: number | undefined;
+            tools_wasted?: number | undefined;
+            source?: "user_input" | "user_denial" | "user_correction" | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    memory_end_task: {
+        description: string;
+        args: {
+            task_id: import("zod").ZodString;
+            tokens_used: import("zod").ZodNumber;
+            tool_calls: import("zod").ZodNumber;
+            errors: import("zod").ZodNumber;
+            user_corrections: import("zod").ZodNumber;
+            completed: import("zod").ZodBoolean;
+            self_report: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                memory_id: import("zod").ZodString;
+                score: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>>>;
+        };
+        execute(args: {
+            task_id: string;
+            tokens_used: number;
+            tool_calls: number;
+            errors: number;
+            user_corrections: number;
+            completed: boolean;
+            self_report?: {
+                memory_id: string;
+                score: number;
+            }[] | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    memory_contradict: {
+        description: string;
+        args: {
+            memory_id: import("zod").ZodString;
+            correction: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            memory_id: string;
+            correction?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    memory_status: {
+        description: string;
+        args: {};
+        execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+};

package/package.json

@@ -1,13 +1,15 @@
 {
   "name": "opencode-memelord",
-  "version": "0.0.1",
-  "description": "OpenCode plugin for memelord - persistent memory for coding agents",
+  "version": "0.1.0",
+  "description": "OpenCode plugin for memelord — persistent memory for coding agents",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
-    "build": "bun build ./src/index.ts --outdir ./dist --target node && tsc --emitDeclarationOnly",
-    "typecheck": "tsc --noEmit"
+    "build": "bun build ./src/index.ts --outdir ./dist --target node --external memelord --external @opencode-ai/plugin --external @opencode-ai/sdk --external @huggingface/transformers --external zod && tsc --emitDeclarationOnly",
+    "typecheck": "tsc --noEmit",
+    "format": "oxfmt --write",
+    "format:check": "oxfmt --check"
   },
   "keywords": [
     "opencode",
@@ -24,11 +26,13 @@
   },
   "dependencies": {
     "@opencode-ai/plugin": "^1.2.10",
+    "@huggingface/transformers": "^3.0.0",
     "memelord": "^0.1.4"
   },
   "devDependencies": {
     "@opencode-ai/sdk": "^1.2.10",
     "@types/bun": "latest",
+    "oxfmt": "^0.34.0",
     "typescript": "^5.0.0"
   },
   "opencode": {