@rohirik/pi-ltm 2.16.2 → 2.17.0

package/README.md

@@ -26,12 +26,14 @@ The current Pi adapter does not register a compaction hook.
 
 ## Shared memory
 
-Default database path:
+When the Claude Code plugin is installed, Pi uses its database, so both agents share memories:
 
 ```text
-~/.claude/plugins/data/OpenLtm-openltm/openltm.db
+~/.claude/plugins/data/openltm-OpenLtm/openltm.db
 ```
 
+(An older install's `OpenLtm-openltm/openltm.db` is used if that is the one that exists.)
+
 Override it before starting Pi:
 
 ```bash

package/dist/index.js

@@ -1,11 +1,11 @@
-import{spawn as k,execSync as E}from"node:child_process";import{join as d}from"node:path";import{homedir as x}from"node:os";import{existsSync as g,readdirSync as M}from"node:fs";import{existsSync as T}from"node:fs";import{createRequire as P}from"node:module";import{dirname as h,resolve as S}from"node:path";function y(o){let n;try{n=P(o).resolve("@rohirik/openltm-core")}catch{return null}for(let t=h(n);t!==h(t);t=h(t)){let r=S(t,"src","cli","bin.ts");if(T(r))return{script:r,args:["mcp-serve"]}}return null}var v="LTM_BRIDGE_DEPTH";function C(){let o=[process.env.BUN_INSTALL?d(process.env.BUN_INSTALL,"bin","bun"):null,d(x(),".bun","bin","bun"),"/opt/homebrew/bin/bun","/usr/local/bin/bun","/usr/bin/bun"].filter(n=>n!==null&&g(n));if(o.length>0)return o[0];for(let n of["which bun","command -v bun"])try{let t=E(n,{encoding:"utf-8",stdio:"pipe"}).trim();if(t&&g(t)&&!/\bpi\b/.test(t))return t}catch{}return null}function _(){let o=d(x(),".claude","plugins","cache","ltm","ltm");if(g(o))try{let n=M(o).filter(t=>/^\d/.test(t)).sort().reverse();for(let t of n){let r=d(o,t,"src","mcp-server.ts");if(g(r))return{script:r,args:[]}}}catch{}return y(import.meta.url)}var w=class{constructor(n,t,r=[]){this.runtime=n;this.script=t;this.args=r}child=null;pending=new Map;buffer="";nextId=1;exited=!1;start(){if(this.child)return;let n=parseInt(process.env[v]??"0",10),t={...process.env,[v]:String(n+1)};this.child=k(this.runtime,[this.script,...this.args],{stdio:["pipe","pipe","pipe"],env:t}),this.child.stdout?.on("data",r=>{this.buffer+=r.toString("utf-8");let e=this.buffer.split(`
-`);this.buffer=e.pop()??"";for(let i of e){let c=i.trim();if(c)try{let l=JSON.parse(c);if(l.id!==void 0){let s=this.pending.get(l.id);s&&(this.pending.delete(l.id),l.error?s.reject(new Error(l.error.message)):s.resolve(l.result))}}catch{}}}),this.child.on("exit",()=>{this.exited=!0;for(let r of this.pending.values())r.reject(new Error("LTM MCP server exited"));this.pending.clear()}),this.child.on("error",()=>{this.exited=!0;for(let r of this.pending.values())r.reject(new Error("LTM MCP server error"));this.pending.clear()})}send(n,t,r){let e=JSON.stringify({jsonrpc:"2.0",id:r,method:n,params:t})+`
-`;this.child?.stdin?.write(e)}request(n,t,r=3e4){let e=this.nextId++;return new Promise((i,c)=>{let l=setTimeout(()=>{this.pending.delete(e),c(new Error(`LTM MCP timeout: ${n}`))},r);this.pending.set(e,{resolve:s=>{clearTimeout(l),i(s)},reject:s=>{clearTimeout(l),c(s)}}),this.send(n,t,e)})}async initialize(){await this.request("initialize",{protocolVersion:"2024-11-05",capabilities:{},clientInfo:{name:"pi-ltm-bridge",version:"1.0.0"}}),this.send("notifications/initialized")}async listTools(){return(await this.request("tools/list"))?.tools??[]}async callTool(n,t){let r=await this.request("tools/call",{name:n,arguments:t},6e4),e=(r?.content??[]).filter(i=>i?.type==="text"&&i.text).map(i=>i.text).join(`
-`);if(r?.isError)throw new Error(e||`${n} returned an error`);return e}};function j(o,n){try{let t=JSON.parse(n),r=Array.isArray(t.globals)?t.globals:[],e=Array.isArray(t.scoped)?t.scoped:[];if(r.length===0&&e.length===0)return"";let i=["## Prior Knowledge (LTM)",""];if(r.length>0){i.push("Global:");for(let c of r.slice(0,3))i.push(`- [${c.id}] ${String(c.content).replace(/\s+/g," ").trim()}`);i.push("")}if(e.length>0){i.push(`Project (${o}):`);for(let c of e.slice(0,7))i.push(`- [${c.id}] ${String(c.content).replace(/\s+/g," ").trim()}`);i.push("")}return i.join(`
+import{spawn as it,execSync as ct}from"node:child_process";import{dirname as at,join as p}from"node:path";import{homedir as lt}from"node:os";import{existsSync as b,readdirSync as ut}from"node:fs";import{existsSync as q}from"node:fs";import{createRequire as B}from"node:module";import{dirname as v,resolve as G}from"node:path";function _(r){let e;try{e=B(r).resolve("@rohirik/openltm-core")}catch{return null}for(let t=v(e);t!==v(t);t=v(t)){let o=G(t,"src","cli","bin.ts");if(q(o))return{script:o,args:["mcp-serve"]}}return null}import{copyFileSync as vt,constants as wt,existsSync as m,mkdirSync as Dt,readFileSync as O,statSync as W}from"node:fs";import{createRequire as V}from"node:module";import{homedir as z}from"node:os";import{basename as J,dirname as w,isAbsolute as X,join as g,resolve as D,sep as h}from"node:path";function k(){let r=process.platform==="win32"?process.env.USERPROFILE:process.env.HOME;return r&&r.trim()?r:z()}function y(){return g(k(),".claude")}var C=["openltm-OpenLtm","OpenLtm-openltm"];function S(r=process.env.CLAUDE_CONFIG_DIR||y()){let e=g(r,"plugins","data"),t=C.find(o=>m(g(e,o,"openltm.db")));return g(e,t??C[0])}function A(r){if(m(r))return r;let e=g(S(),"openltm.db");return m(e)?e:r}function K(){return g(y(),"projects")}function Y(){return g(K(),"registry.json")}function N(r){return r.normalize("NFC").toLowerCase().replace(/[^\p{L}\p{N}]+/gu,"-").replace(/^-+|-+$/g,"")}function j(r){return r.length>1?r.replace(/[\\/]+$/,""):r}function E(r){return j(r).split(/[\\/]/).pop()??""}function Q(r){if(!r||!X(r))return null;let e=D(k()),t=D(r);for(;;){if(m(g(t,".git"))){let n=w(t);return t===e||n===t?null:t}let o=w(t);if(o===t)return null;t=o}}function Z(r){let e=g(r,".git");try{if(!W(e).isFile())return r;let t=/^gitdir:\s*(.+)\s*$/m.exec(O(e,"utf-8"));if(!t)return r;let o=D(r,t[1].trim()),n=`${h}.git${h}worktrees${h}`,s=o.lastIndexOf(n);return s>0?o.slice(0,s):r}catch{return r}}function tt(r,e){if(!e)return null;let t=j(r);for(let n of[r,t])if(e[n])return{name:e[n],path:n,exact:!0};let o=Object.keys(e).sort((n,s)=>s.length-n.length);for(let n of o){let s=j(n);if(e[n]&&(t.startsWith(s+"/")||t.startsWith(s+h)))return{name:e[n],path:n,exact:!1}}return null}function et(r){let e=Q(r);if(e){let t=N(J(Z(e)));if(t)return{name:t,source:"repo-root"}}return{name:N(E(r)),source:"cwd"}}function rt(r,e={}){let t=tt(r,e.registry),o=t?null:et(r),n=t?{name:t.name,source:t.exact?"registry":"registry-prefix",registeredPath:t.path,candidate:t.name,legacyVerified:!1}:{name:o.name,source:o.source,registeredPath:null,candidate:o.name,legacyVerified:!1},s=e.legacyName?.trim()||null,a=u=>({...n,name:s,source:"legacy",registeredPath:null,legacyVerified:u});if(!s||s===n.name)return n;if(!n.name)return a(!1);if(t&&e.legacyScope!=="all")return n;let c=e.hasProjectData??(e.dbPath?u=>st(u,e.dbPath):null);if(!c)return n;let i=c(s);if(i===!1)return n;let l=c(n.name);return l===!0?n:a(i===!0&&l===!1)}function M(r,e={}){return rt(r,e).name}function I(r){try{if(!m(r))return{};let e=JSON.parse(O(r,"utf-8"));if(!e||typeof e!="object"||Array.isArray(e))return{};let t={};for(let[o,n]of Object.entries(e))typeof n=="string"&&n&&(t[o]=n);return t}catch{return{}}}function $(r,e=Y()){let t=I(r);return!e||e===r?t:{...I(e),...t}}var d;function nt(){if(d!==void 0)return d;if(d=null,process.versions?.bun)return null;let r=process.emitWarning;try{process.emitWarning=((t,...o)=>{let n=typeof t=="string"?t:t?.message;if(!/sqlite/i.test(String(n)))return r.call(process,t,...o)});let{DatabaseSync:e}=V(import.meta.url)("node:sqlite");d=t=>new e(t,{readOnly:!0})}catch{d=null}finally{process.emitWarning=r}return d}var ot=["SELECT 1 FROM memories WHERE project_scope = ? LIMIT 1","SELECT 1 FROM context_items WHERE project_name = ? LIMIT 1"];function st(r,e,t=nt()){if(!r||!e||!m(e))return!1;if(!t)return null;let o;try{o=t(e)}catch{return null}try{for(let n of ot)try{if(o.prepare(n).get(r)!=null)return!0}catch(s){if(!/no such table/i.test(String(s)))return null}return!1}finally{try{o.close()}catch{}}}function F(r){return process.env.LTM_DATA_DIR||process.env.CLAUDE_PLUGIN_DATA||w(r)}var L="LTM_BRIDGE_DEPTH";function pt(){let r=[process.env.BUN_INSTALL?p(process.env.BUN_INSTALL,"bin","bun"):null,p(lt(),".bun","bin","bun"),"/opt/homebrew/bin/bun","/usr/local/bin/bun","/usr/bin/bun"].filter(e=>e!==null&&b(e));if(r.length>0)return r[0];for(let e of["which bun","command -v bun"])try{let t=ct(e,{encoding:"utf-8",stdio:"pipe"}).trim();if(t&&b(t)&&!/\bpi\b/.test(t))return t}catch{}return null}function gt(r,e){let t=r.split(/[.-]/).map(n=>parseInt(n,10)||0),o=e.split(/[.-]/).map(n=>parseInt(n,10)||0);for(let n=0;n<Math.max(t.length,o.length);n++){let s=(t[n]??0)-(o[n]??0);if(s!==0)return s}return 0}function ft(){let r=process.env.LTM_DB_PATH||null,e=process.env.CLAUDE_CONFIG_DIR||y(),t=p(e,"plugins");for(let[s,a,c]of[["OpenLtm","openltm",S(e)],["ltm","ltm",p(t,"data","ltm-ltm")]]){let i=p(t,"cache",s,a);if(b(i))try{let l=ut(i).filter(u=>/^\d/.test(u)).sort(gt).reverse();for(let u of l){let f=p(i,u,"src","mcp-server.ts");if(b(f))return{script:f,args:[],dbPath:r??p(c,"openltm.db")}}}catch{}}let o=_(import.meta.url);if(!o)return null;let n=r??(process.env.CLAUDE_PLUGIN_DATA?p(process.env.CLAUDE_PLUGIN_DATA,"openltm.db"):null)??A(p(at(o.script),"..","..","..","..","data","openltm.db"));return{...o,dbPath:n}}var T=class{constructor(e,t,o=[],n={}){this.runtime=e;this.script=t;this.args=o;this.extraEnv=n}child=null;pending=new Map;buffer="";nextId=1;exited=!1;start(){if(this.child)return;let e=parseInt(process.env[L]??"0",10),t={...process.env,...this.extraEnv,[L]:String(e+1)};this.child=it(this.runtime,[this.script,...this.args],{stdio:["pipe","pipe","pipe"],env:t}),this.child.stdout?.on("data",o=>{this.buffer+=o.toString("utf-8");let n=this.buffer.split(`
+`);this.buffer=n.pop()??"";for(let s of n){let a=s.trim();if(a)try{let c=JSON.parse(a);if(c.id!==void 0){let i=this.pending.get(c.id);i&&(this.pending.delete(c.id),c.error?i.reject(new Error(c.error.message)):i.resolve(c.result))}}catch{}}}),this.child.on("exit",()=>{this.exited=!0;for(let o of this.pending.values())o.reject(new Error("LTM MCP server exited"));this.pending.clear()}),this.child.on("error",()=>{this.exited=!0;for(let o of this.pending.values())o.reject(new Error("LTM MCP server error"));this.pending.clear()})}send(e,t,o){let n=JSON.stringify({jsonrpc:"2.0",id:o,method:e,params:t})+`
+`;this.child?.stdin?.write(n)}request(e,t,o=3e4){let n=this.nextId++;return new Promise((s,a)=>{let c=setTimeout(()=>{this.pending.delete(n),a(new Error(`LTM MCP timeout: ${e}`))},o);this.pending.set(n,{resolve:i=>{clearTimeout(c),s(i)},reject:i=>{clearTimeout(c),a(i)}}),this.send(e,t,n)})}async initialize(){await this.request("initialize",{protocolVersion:"2024-11-05",capabilities:{},clientInfo:{name:"pi-ltm-bridge",version:"1.0.0"}}),this.send("notifications/initialized")}async listTools(){return(await this.request("tools/list"))?.tools??[]}async callTool(e,t){let o=await this.request("tools/call",{name:e,arguments:t},6e4),n=(o?.content??[]).filter(s=>s?.type==="text"&&s.text).map(s=>s.text).join(`
+`);if(o?.isError)throw new Error(n||`${e} returned an error`);return n}};function dt(r,e){try{let t=JSON.parse(e),o=Array.isArray(t.globals)?t.globals:[],n=Array.isArray(t.scoped)?t.scoped:[];if(o.length===0&&n.length===0)return"";let s=["## Prior Knowledge (LTM)",""];if(o.length>0){s.push("Global:");for(let a of o.slice(0,3))s.push(`- [${a.id}] ${String(a.content).replace(/\s+/g," ").trim()}`);s.push("")}if(n.length>0){s.push(`Project (${r}):`);for(let a of n.slice(0,7))s.push(`- [${a.id}] ${String(a.content).replace(/\s+/g," ").trim()}`);s.push("")}return s.join(`
 `).trimEnd()+`
-`}catch{return""}}function I(o){let n=o;if(parseInt(process.env[v]??"0",10)>0)return;let t=C(),r=_();if(!t||!r)return;let e=new w(t,r.script,r.args);e.start();let i=new Set,c=(async()=>{await e.initialize();let l=await e.listTools();for(let s of l){let a=s.name;i.add(a),n.registerTool({name:a,label:a,description:s.description??"",parameters:s.inputSchema??{type:"object",properties:{}},async execute(p,u){return{content:[{type:"text",text:await e.callTool(a,u??{})}],details:{}}}})}})().catch(()=>{});n.on("before_agent_start",async l=>{await c;let s=l;try{let p=String(s?.cwd??process.cwd()).replace(/\/$/,"").split("/").pop()??"",u=i.has("context")?"context":i.has("recall")?"recall":"";if(!u)return;let m=u==="context"?await e.callTool("context",{project:p}):await e.callTool("recall",{project:p,limit:8,sort_by:"relevance"}),f=u==="context"?j(p,m):`## Prior Knowledge (LTM)
+`}catch{return""}}var U=new Map;function H(r,e){let t=U.get(r);return t===void 0&&(t=M(r,{registry:e?$(p(F(e),"projects","registry.json")):null,legacyName:E(r),legacyScope:"all",dbPath:e}),U.set(r,t)),t}function mt(r){let e=r;if(parseInt(process.env[L]??"0",10)>0)return;let t=pt(),o=ft();if(!t||!o)return;let n=new T(t,o.script,o.args,o.dbPath?{LTM_DB_PATH:o.dbPath}:{});n.start();let s=new Set,a=(async()=>{await n.initialize();let c=await n.listTools();for(let i of c){let l=i.name;s.add(l),e.registerTool({name:l,label:l,description:i.description??"",parameters:i.inputSchema??{type:"object",properties:{}},async execute(u,f){return{content:[{type:"text",text:await n.callTool(l,f??{})}],details:{}}}})}})().catch(()=>{});e.on("before_agent_start",async c=>{await a;let i=c;try{let l=String(i?.cwd??process.cwd()),u=H(l,o.dbPath),f=s.has("context")?"context":s.has("recall")?"recall":"";if(!f)return;let x=f==="context"?await n.callTool("context",{project:u}):await n.callTool("recall",{project:u,limit:8,sort_by:"relevance"}),P=f==="context"?dt(u,x):`## Prior Knowledge (LTM)
 
-${m}
-`;if(!f.trim())return;let b=String(s?.systemPrompt??"");return{systemPrompt:b?`${b}
+${x}
+`;if(!P.trim())return;let R=String(i?.systemPrompt??"");return{systemPrompt:R?`${R}
 
-${f}`:f}}catch{}})}export{I as default};
+${P}`:P}}catch{}}),e.on("session_compact",async c=>{await a;let i=c;try{let l=String(i?.summary??"").replace(/\s+/g," ").trim();if(l.length<=50||!s.has("context_add"))return;let u=new Date().toISOString().split("T")[0];await n.callTool("context_add",{type:"progress",content:`\u2713 [${u}] Compacted: ${l.slice(0,300)}`,project:H(String(i?.cwd??process.cwd()),o.dbPath)})}catch{}})}export{mt as default,ft as findMcpServer};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rohirik/pi-ltm",
-  "version": "2.16.2",
+  "version": "2.17.0",
   "description": "LTM (Long-Term Memory) native extension for Pi \u2014 share memories with Claude Code and OpenCode",
   "type": "module",
   "main": "./dist/index.js",
@@ -41,7 +41,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@rohirik/openltm-core": "^2.16.2"
+    "@rohirik/openltm-core": "^2.17.0"
   },
   "peerDependencies": {
     "bun-types": ">=1.0.0"

package/src/__tests__/find-mcp-server.test.ts

@@ -0,0 +1,69 @@
+/**
+ * find-mcp-server.test.ts — Pi shares the database of the Claude Code plugin.
+ *
+ * Claude Code keeps an installed plugin's data in plugins/data/<plugin>-<marketplace>
+ * (measured: openltm@OpenLtm → openltm-OpenLtm). Pi must open that database, not a
+ * second one under the name OpenLTM ≤ 2.16 assumed (OpenLtm-openltm).
+ */
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { findMcpServer } from "../index.js";
+
+let home: string;
+const saved: Record<string, string | undefined> = {};
+const KEYS = ["HOME", "LTM_DB_PATH", "CLAUDE_CONFIG_DIR", "CLAUDE_PLUGIN_DATA"];
+
+function plugin(version: string): void {
+  const src = join(home, ".claude", "plugins", "cache", "OpenLtm", "openltm", version, "src");
+  mkdirSync(src, { recursive: true });
+  writeFileSync(join(src, "mcp-server.ts"), "");
+}
+function db(dirName: string): string {
+  const dir = join(home, ".claude", "plugins", "data", dirName);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, "openltm.db"), "");
+  return join(dir, "openltm.db");
+}
+
+beforeEach(() => {
+  for (const k of KEYS) saved[k] = process.env[k];
+  for (const k of KEYS) delete process.env[k];
+  home = mkdtempSync(join(tmpdir(), "pi-find-mcp-"));
+  process.env["HOME"] = home;
+});
+afterEach(() => {
+  for (const k of KEYS) saved[k] === undefined ? delete process.env[k] : (process.env[k] = saved[k]);
+  rmSync(home, { recursive: true, force: true });
+});
+
+describe("Pi finds the Claude Code plugin's MCP server and database", () => {
+  it("opens the database in openltm-OpenLtm, where Claude Code keeps it", () => {
+    plugin("2.17.0");
+    const real = db("openltm-OpenLtm");
+    const found = findMcpServer();
+    expect(found?.script).toBe(join(home, ".claude", "plugins", "cache", "OpenLtm", "openltm", "2.17.0", "src", "mcp-server.ts"));
+    expect(found?.dbPath).toBe(real);
+  });
+
+  it("keeps using a database under the older OpenLtm-openltm name when that is the one that exists", () => {
+    plugin("2.17.0");
+    const legacy = db("OpenLtm-openltm");
+    expect(findMcpServer()?.dbPath).toBe(legacy);
+  });
+
+  it("prefers openltm-OpenLtm when both exist", () => {
+    plugin("2.17.0");
+    db("OpenLtm-openltm");
+    const real = db("openltm-OpenLtm");
+    expect(findMcpServer()?.dbPath).toBe(real);
+  });
+
+  it("an explicit LTM_DB_PATH still wins", () => {
+    plugin("2.17.0");
+    db("openltm-OpenLtm");
+    process.env["LTM_DB_PATH"] = join(home, "explicit.db");
+    expect(findMcpServer()?.dbPath).toBe(join(home, "explicit.db"));
+  });
+});

package/src/__tests__/plugin.test.ts

@@ -1,144 +1,89 @@
-import { describe, it, expect, beforeAll, afterAll } from "bun:test";
-import { readFileSync, unlinkSync } from "fs";
+/**
+ * Pi extension — the real entry point (src/index.ts, what dist/index.js is built
+ * from), driven with a stub Pi host. It bridges to a real `mcp-serve` child over
+ * stdio against a temp DB, exactly as Pi runs it. (The old tests exercised
+ * hooks.ts/tools.ts, which Pi never loaded.)
+ */
+import { afterAll, beforeAll, describe, expect, it } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync } from "fs";
+import { tmpdir } from "os";
 import { join } from "path";
-import { Database } from "bun:sqlite";
 
-const dbPath = `/tmp/test-pi-ltm-${process.pid}-${Date.now()}.db`;
-const SCHEMA_PATH = join(import.meta.dir, "..", "..", "..", "openltm-core", "src", "schema.sql");
+type Tool = { name: string; execute: (id: string, params: Record<string, unknown>) => Promise<{ content: Array<{ text: string }> }> };
+type Handler = (event: unknown) => Promise<unknown> | unknown;
 
-function createMockPi() {
-  const tools: Array<{
-    name: string;
-    label: string;
-    description: string;
-    parameters: unknown;
-    execute: (toolCallId: string, params: Record<string, unknown>) => Promise<unknown>;
-  }> = [];
-  const handlers: Record<string, Array<(...args: unknown[]) => unknown>> = {};
+function createStubPi() {
+  const tools = new Map<string, Tool>();
+  const handlers = new Map<string, Handler>();
   return {
     tools,
     handlers,
-    registerTool(def: typeof tools[0]) { tools.push(def); },
-    on(event: string, handler: (...args: unknown[]) => unknown) {
-      if (!handlers[event]) handlers[event] = [];
-      handlers[event]!.push(handler);
-    },
+    registerTool(def: Tool) { tools.set(def.name, def); },
+    on(event: string, handler: Handler) { handlers.set(event, handler); },
   };
 }
 
-beforeAll(async () => {
-  const { runPendingMigrations, _setDbForTesting } = await import("@rohirik/openltm-core");
-  const db = new Database(dbPath, { create: true });
-  db.exec("PRAGMA journal_mode=WAL; PRAGMA foreign_keys=ON;");
-  db.exec(readFileSync(SCHEMA_PATH, "utf-8"));
-  await runPendingMigrations(db);
-  _setDbForTesting(db);
-}, 30_000);
-
-afterAll(() => {
-  try { unlinkSync(dbPath); } catch {}
-  try { unlinkSync(`${dbPath}-shm`); } catch {}
-  try { unlinkSync(`${dbPath}-wal`); } catch {}
-});
-
-describe("Pi LTM extension — registerTools()", () => {
-  it("registers exactly 3 tools", async () => {
-    const { registerTools } = await import("../tools.js");
-    const pi = createMockPi();
-    registerTools(pi);
-    expect(pi.tools).toHaveLength(3);
-  });
+async function until(cond: () => boolean, ms = 20_000): Promise<void> {
+  const t0 = Date.now();
+  while (!cond()) {
+    if (Date.now() - t0 > ms) throw new Error("timed out waiting for the MCP bridge");
+    await Bun.sleep(50);
+  }
+}
 
-  it("registers ltm_recall, ltm_learn, ltm_forget", async () => {
-    const { registerTools } = await import("../tools.js");
-    const pi = createMockPi();
-    registerTools(pi);
-    const names = pi.tools.map(t => t.name);
-    expect(names).toContain("ltm_recall");
-    expect(names).toContain("ltm_learn");
-    expect(names).toContain("ltm_forget");
+const text = (r: { content: Array<{ text: string }> }) => r.content.map((c) => c.text).join("\n");
+
+describe("Pi extension (real entry point over the MCP bridge)", () => {
+  const root = mkdtempSync(join(tmpdir(), "ltm-pi-"));
+  // Under Bun (this runner) node:sqlite is unavailable, so the legacy-name check
+  // cannot run and keeps the raw folder name; use one that is already normalized.
+  // Mixed-case unification is exercised under real Node in scripts/qa/adapters-smoke.ts.
+  const cwd = join(root, "code", "pi-demo");
+  const saved = { LTM_DB_PATH: process.env.LTM_DB_PATH, CLAUDE_PLUGIN_DATA: process.env.CLAUDE_PLUGIN_DATA };
+  const pi = createStubPi();
+
+  beforeAll(async () => {
+    mkdirSync(join(cwd, ".git"), { recursive: true });
+    process.env.LTM_DB_PATH = join(root, "openltm.db");
+    delete process.env.CLAUDE_PLUGIN_DATA;
+    const { default: ltmExtension } = await import("../index.js");
+    ltmExtension(pi);
+    await until(() => pi.tools.has("learn") && pi.tools.has("context_add"));
+  }, 30_000);
+
+  afterAll(() => {
+    for (const [k, v] of Object.entries(saved)) v === undefined ? delete process.env[k] : (process.env[k] = v);
+    rmSync(root, { recursive: true, force: true });
   });
 
-  it("tools have label and description", async () => {
-    const { registerTools } = await import("../tools.js");
-    const pi = createMockPi();
-    registerTools(pi);
-    for (const tool of pi.tools) {
-      expect(tool.label).toBeTruthy();
-      expect(tool.description).toBeTruthy();
+  it("registers every MCP tool and hooks before_agent_start + session_compact", () => {
+    for (const name of ["recall", "get", "learn", "context", "context_items", "context_add", "proposals"]) {
+      expect(pi.tools.has(name)).toBe(true);
     }
+    expect(pi.handlers.has("before_agent_start")).toBe(true);
+    expect(pi.handlers.has("session_compact")).toBe(true);
   });
-});
-
-describe("Pi LTM extension — registerHooks()", () => {
-  it("registers before_agent_start and session_compact hooks", async () => {
-    const { registerHooks } = await import("../hooks.js");
-    const pi = createMockPi();
-    registerHooks(pi);
-    expect(pi.handlers["before_agent_start"]?.length).toBeGreaterThan(0);
-    expect(pi.handlers["session_compact"]?.length).toBeGreaterThan(0);
-  });
-
-  it("before_agent_start returns systemPrompt with Prior Knowledge when memories exist", async () => {
-    const { learn } = await import("@rohirik/openltm-core");
-    learn({
-      content: "Pi test memory — use strict types",
-      category: "pattern",
-      importance: 3,
-      project_scope: "pi-test-proj",
-      skipExport: true,
-    });
-
-    const { registerHooks } = await import("../hooks.js");
-    const pi = createMockPi();
-    registerHooks(pi);
-
-    const result = await pi.handlers["before_agent_start"]![0]!({
-      cwd: "/tmp/pi-test-proj",
-      systemPrompt: "",
-    }) as { systemPrompt?: string } | undefined;
-
-    expect(result?.systemPrompt).toContain("Prior Knowledge");
-  });
-
-  it("before_agent_start returns undefined when no memories for project", async () => {
-    const { registerHooks } = await import("../hooks.js");
-    const pi = createMockPi();
-    registerHooks(pi);
-
-    const result = await pi.handlers["before_agent_start"]![0]!({
-      cwd: "/tmp/empty-pi-project-xyz-no-memories",
-      systemPrompt: "",
-    });
-
-    expect(result).toBeUndefined();
-  });
-});
 
-describe("ltm_learn / ltm_recall roundtrip via Pi tools", () => {
-  it("stores and retrieves a memory", async () => {
-    const { registerTools } = await import("../tools.js");
-    const pi = createMockPi();
-    registerTools(pi);
-
-    const learnTool = pi.tools.find(t => t.name === "ltm_learn")!;
-    const recallTool = pi.tools.find(t => t.name === "ltm_recall")!;
-
-    const learnResult = await learnTool.execute("call-1", {
-      content: "Pi roundtrip test — always verify types",
-      category: "gotcha",
-      importance: 4,
-    }) as { content: Array<{ type: string; text: string }> };
-
-    const learned = JSON.parse(learnResult.content[0]!.text) as { id: number; action: string };
-    expect(learned.id).toBeGreaterThan(0);
-    expect(learned.action).toBe("created");
-
-    const recallResult = await recallTool.execute("call-2", {
-      query: "Pi roundtrip verify types",
-    }) as { content: Array<{ type: string; text: string }> };
-
-    const memories = JSON.parse(recallResult.content[0]!.text) as Array<{ id: number }>;
-    expect(memories.some(m => m.id === learned.id)).toBe(true);
-  });
+  it("learn → before_agent_start injects it for the project resolved from cwd", async () => {
+    const learned = JSON.parse(text(await pi.tools.get("learn")!.execute("t1", {
+      content: "Pi demo: deploys go through the blue/green switch, never in place", category: "workflow", importance: 3, project: "pi-demo",
+    }))) as { id: number };
+    const res = (await pi.handlers.get("before_agent_start")!({ cwd, systemPrompt: "BASE" })) as { systemPrompt: string };
+    expect(res.systemPrompt.startsWith("BASE\n\n## Prior Knowledge (LTM)")).toBe(true);
+    expect(res.systemPrompt).toContain(`Project (pi-demo):`);
+    expect(res.systemPrompt).toContain(`[${learned.id}] Pi demo: deploys go through the blue/green switch`);
+  }, 30_000);
+
+  it("session_compact records the summary as project progress via context_add", async () => {
+    const summary = "Compacted session: wired the blue/green deploy switch and documented the rollback steps for the demo service.";
+    await pi.handlers.get("session_compact")!({ cwd, summary });
+    const items = text(await pi.tools.get("context_items")!.execute("t2", { project: "pi-demo", type: "progress" }));
+    expect(items).toContain("Compacted: Compacted session: wired the blue/green deploy switch");
+  }, 30_000);
+
+  it("ignores short compaction summaries", async () => {
+    await pi.handlers.get("session_compact")!({ cwd, summary: "too short" });
+    const items = text(await pi.tools.get("context_items")!.execute("t3", { project: "pi-demo", type: "progress" }));
+    expect(items).not.toContain("too short");
+  }, 30_000);
 });

package/src/index.ts

@@ -8,10 +8,12 @@
  * Pattern adapted from context-mode's Pi adapter (MIT).
  */
 import { spawn, execSync } from "node:child_process";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import { homedir } from "node:os";
 import { existsSync, readdirSync } from "node:fs";
 import { findCoreCli } from "./find-core.js";
+// Relative import so esbuild inlines the Node-safe resolver into dist (core itself is external).
+import { dataDirFor, getClaudePluginDataDir, getLegacyClaudeDir, legacyLastSegment, loadProjectRegistry, resolveProjectName, sharedDbPath } from "../../openltm-core/src/project.js";
 
 // ── Fork-bomb prevention ──────────────────────────────────────────────────────
 
@@ -42,25 +44,55 @@ function findBun(): string | null {
   return null;
 }
 
-function findMcpServer(): { script: string; args: string[] } | null {
-  // 1. Plugin cache — newest version first (Claude Code users)
-  const cacheBase = join(homedir(), ".claude", "plugins", "cache", "ltm", "ltm");
-  if (existsSync(cacheBase)) {
+/** Compare dotted versions numerically ("2.17.0" > "2.9.3"). */
+function compareVersions(a: string, b: string): number {
+  const pa = a.split(/[.-]/).map((x) => parseInt(x, 10) || 0);
+  const pb = b.split(/[.-]/).map((x) => parseInt(x, 10) || 0);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const d = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (d !== 0) return d;
+  }
+  return 0;
+}
+
+interface McpServerLocation {
+  script: string;
+  args: string[];
+  /** DB the server must open — passed to it as LTM_DB_PATH so naming and storage agree. */
+  dbPath: string | null;
+}
+
+export function findMcpServer(): McpServerLocation | null {
+  const explicitDb = process.env["LTM_DB_PATH"] || null;
+  // 1. Claude Code plugin cache — newest version first. Share Claude Code's
+  //    database (its plugin data dir) so both agents see the same memories.
+  const claudeDir = process.env["CLAUDE_CONFIG_DIR"] || getLegacyClaudeDir();
+  const plugins = join(claudeDir, "plugins");
+  for (const [marketplace, plugin, dataDir] of [
+    ["OpenLtm", "openltm", getClaudePluginDataDir(claudeDir)],
+    ["ltm", "ltm", join(plugins, "data", "ltm-ltm")],
+  ] as const) {
+    const cacheBase = join(plugins, "cache", marketplace, plugin);
+    if (!existsSync(cacheBase)) continue;
     try {
-      const versions = readdirSync(cacheBase)
-        .filter((v) => /^\d/.test(v))
-        .sort()
-        .reverse();
+      const versions = readdirSync(cacheBase).filter((v) => /^\d/.test(v)).sort(compareVersions).reverse();
       for (const v of versions) {
         const script = join(cacheBase, v, "src", "mcp-server.ts");
-        if (existsSync(script)) return { script, args: [] };
+        if (existsSync(script)) {
+          return { script, args: [], dbPath: explicitDb ?? join(dataDir, "openltm.db") };
+        }
       }
     } catch {
       // continue to next strategy
     }
   }
   // 2. openltm-core package — run the packaged CLI entrypoint with mcp-serve
-  return findCoreCli(import.meta.url);
+  const core = findCoreCli(import.meta.url);
+  if (!core) return null;
+  const dbPath = explicitDb
+    ?? (process.env["CLAUDE_PLUGIN_DATA"] ? join(process.env["CLAUDE_PLUGIN_DATA"]!, "openltm.db") : null)
+    ?? sharedDbPath(join(dirname(core.script), "..", "..", "..", "..", "data", "openltm.db"));
+  return { ...core, dbPath };
 }
 
 // ── Minimal MCP stdio client ──────────────────────────────────────────────────
@@ -82,12 +114,13 @@ class LtmMcpClient {
     private readonly runtime: string,
     private readonly script: string,
     private readonly args: string[] = [],
+    private readonly extraEnv: Record<string, string> = {},
   ) {}
 
   start(): void {
     if (this.child) return;
     const depth = parseInt(process.env[BRIDGE_DEPTH_ENV] ?? "0", 10);
-    const env = { ...process.env, [BRIDGE_DEPTH_ENV]: String(depth + 1) };
+    const env = { ...process.env, ...this.extraEnv, [BRIDGE_DEPTH_ENV]: String(depth + 1) };
 
     this.child = spawn(this.runtime, [this.script, ...this.args], { stdio: ["pipe", "pipe", "pipe"], env });
 
@@ -204,6 +237,26 @@ function formatContextPayload(project: string, raw: string): string {
   }
 }
 
+/**
+ * Shared resolver (registry → repo root → cwd basename), memoised per cwd. Pi used
+ * the raw cwd basename before unified identity; that name is kept while it is
+ * the only one with rows, so no memory is orphaned.
+ */
+const projectCache = new Map<string, string>();
+function projectOf(cwd: string, dbPath: string | null): string {
+  let name = projectCache.get(cwd);
+  if (name === undefined) {
+    name = resolveProjectName(cwd, {
+      registry: dbPath ? loadProjectRegistry(join(dataDirFor(dbPath), "projects", "registry.json")) : null,
+      legacyName: legacyLastSegment(cwd),
+      legacyScope: "all",
+      dbPath,
+    });
+    projectCache.set(cwd, name);
+  }
+  return name;
+}
+
 export default function ltmExtension(pi: unknown): void {
   const p = pi as {
     registerTool: (def: {
@@ -221,7 +274,7 @@ export default function ltmExtension(pi: unknown): void {
   const server = findMcpServer();
   if (!bun || !server) return; // degrade gracefully — no bun or server found
 
-  const client = new LtmMcpClient(bun, server.script, server.args);
+  const client = new LtmMcpClient(bun, server.script, server.args, server.dbPath ? { LTM_DB_PATH: server.dbPath } : {});
   client.start();
 
   // Bootstrap runs async — tools are registered once handshake completes.
@@ -252,7 +305,7 @@ export default function ltmExtension(pi: unknown): void {
     const ev = event as { cwd?: string; systemPrompt?: string } | null;
     try {
       const cwd = String(ev?.cwd ?? process.cwd());
-      const project = cwd.replace(/\/$/, "").split("/").pop() ?? "";
+      const project = projectOf(cwd, server.dbPath);
       const toolName = toolNames.has("context") ? "context" : (toolNames.has("recall") ? "recall" : "");
       if (!toolName) return;
       const text = toolName === "context"
@@ -268,4 +321,23 @@ export default function ltmExtension(pi: unknown): void {
       // non-fatal
     }
   });
+
+  // Record the compaction summary as a progress item for the project. Raw
+  // summaries are too noisy to store as memories.
+  p.on("session_compact", async (event: unknown) => {
+    await ready;
+    const ev = event as { cwd?: string; summary?: string } | null;
+    try {
+      const summary = String(ev?.summary ?? "").replace(/\s+/g, " ").trim();
+      if (summary.length <= 50 || !toolNames.has("context_add")) return;
+      const today = new Date().toISOString().split("T")[0];
+      await client.callTool("context_add", {
+        type: "progress",
+        content: `✓ [${today}] Compacted: ${summary.slice(0, 300)}`,
+        project: projectOf(String(ev?.cwd ?? process.cwd()), server.dbPath),
+      });
+    } catch {
+      // non-fatal
+    }
+  });
 }

package/src/hooks.ts

@@ -1,45 +0,0 @@
-import { buildPrefillContext, deriveProjectFromCwd, learn, PREFILL_DEFAULTS } from "@rohirik/openltm-core";
-
-type PiAny = any;
-
-function projectFromCwd(cwd: string): string {
-  return deriveProjectFromCwd(cwd);
-}
-
-export function registerHooks(pi: PiAny): void {
-  // Inject relevant memories into the system prompt before each agent turn
-  pi.on("before_agent_start", async (event: PiAny) => {
-    try {
-      const cwd = String(event?.cwd ?? process.cwd());
-      const project = projectFromCwd(cwd);
-      const block = buildPrefillContext({ project, ...PREFILL_DEFAULTS });
-      if (!block) return;
-      const existing = String(event?.systemPrompt ?? "");
-      const parts = existing ? [existing, block] : [block];
-      return { systemPrompt: parts.join("\n\n") };
-    } catch {
-      // Non-fatal — session continues without LTM context
-    }
-  });
-
-  // Learn from session summary after compact
-  pi.on("session_compact", (event: PiAny) => {
-    try {
-      const cwd = String(event?.cwd ?? process.cwd());
-      const project = projectFromCwd(cwd);
-      const summary = String(event?.summary ?? "");
-      if (summary.trim().length > 50) {
-        learn({
-          content: summary.slice(0, 500),
-          category: "pattern",
-          importance: 2,
-          project_scope: project,
-          actor: "pi:compact",
-          skipExport: true,
-        });
-      }
-    } catch {
-      // Non-fatal
-    }
-  });
-}

package/src/tools.ts

@@ -1,97 +0,0 @@
-import { recall, learn, forget } from "@rohirik/openltm-core";
-
-type PiAny = any; // Pi's extension API — no published types package
-
-function toText(value: unknown): string {
-  return JSON.stringify(value, null, 2);
-}
-
-export function registerTools(pi: PiAny): void {
-  pi.registerTool({
-    name: "ltm_recall",
-    label: "ltm_recall",
-    description:
-      "Search long-term memories by query, category, or project scope. Call before starting any non-trivial task.",
-    parameters: {
-      type: "object",
-      properties: {
-        query: { type: "string", description: "Full-text search query" },
-        project: { type: "string", description: "Filter by project scope" },
-        limit: { type: "number", description: "Max results (default 10)", minimum: 1, maximum: 50 },
-        category: {
-          type: "string",
-          enum: ["preference", "architecture", "gotcha", "pattern", "workflow", "constraint"],
-        },
-      },
-    },
-    async execute(_toolCallId: string, params: Record<string, unknown>) {
-      const results = await recall({
-        query: params["query"] as string | undefined,
-        project: params["project"] as string | undefined,
-        limit: params["limit"] as number | undefined,
-        category: params["category"] as string | undefined,
-      });
-      return {
-        content: [{ type: "text", text: toText(results.map(m => ({ id: m.id, content: m.content, category: m.category, importance: m.importance }))) }],
-        details: {},
-      };
-    },
-  });
-
-  pi.registerTool({
-    name: "ltm_learn",
-    label: "ltm_learn",
-    description:
-      "Store or reinforce a memory. Call after discovering a non-obvious pattern, gotcha, or architectural decision. Always provide a title: a concise noun-phrase label (≤60 chars).",
-    parameters: {
-      type: "object",
-      properties: {
-        content: { type: "string", description: "The insight, pattern, or decision to store" },
-        title: { type: "string", description: "Short label (≤60 chars, noun-phrase). Always provide this.", maxLength: 60 },
-        category: {
-          type: "string",
-          enum: ["preference", "architecture", "gotcha", "pattern", "workflow", "constraint"],
-        },
-        importance: { type: "number", description: "Importance 1-5 (default 3)", minimum: 1, maximum: 5 },
-        project: { type: "string", description: "Scope to a specific project" },
-      },
-      required: ["content"],
-    },
-    async execute(_toolCallId: string, params: Record<string, unknown>) {
-      const result = learn({
-        content: params["content"] as string,
-        title: params["title"] as string | undefined,
-        category: params["category"] as string | undefined,
-        importance: params["importance"] as number | undefined,
-        project_scope: params["project"] as string | undefined,
-        actor: "pi:ltm_learn",
-        skipExport: true,
-      });
-      return {
-        content: [{ type: "text", text: toText({ id: result.id, action: result.action, category: result.category }) }],
-        details: {},
-      };
-    },
-  });
-
-  pi.registerTool({
-    name: "ltm_forget",
-    label: "ltm_forget",
-    description: "Delete a memory by ID. Call when a memory is wrong or outdated.",
-    parameters: {
-      type: "object",
-      properties: {
-        id: { type: "number", description: "Memory ID to delete" },
-        reason: { type: "string", description: "Why this memory is being removed" },
-      },
-      required: ["id"],
-    },
-    async execute(_toolCallId: string, params: Record<string, unknown>) {
-      forget({ id: params["id"] as number, reason: params["reason"] as string | undefined, actor: "pi:ltm_forget" });
-      return {
-        content: [{ type: "text", text: toText({ ok: true, id: params["id"] }) }],
-        details: {},
-      };
-    },
-  });
-}