apsolut-cortex 0.1.2 → 0.2.0

package/dist/cli.js

@@ -1,335 +1,32 @@
 #!/usr/bin/env node
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-
-// src/db.ts
-var exports_db = {};
-__export(exports_db, {
-  upsertSession: () => upsertSession,
-  upsertProject: () => upsertProject,
-  updateWeight: () => updateWeight,
-  searchVector: () => searchVector,
-  searchBM25: () => searchBM25,
-  mergeRRF: () => mergeRRF,
-  markObservationsPromoted: () => markObservationsPromoted,
-  insertObservation: () => insertObservation,
-  insertMemory: () => insertMemory,
-  getSessionObservations: () => getSessionObservations,
-  getRecentSummaries: () => getRecentSummaries,
-  getDb: () => getDb,
-  decayAndPrune: () => decayAndPrune,
-  cosineSimilarity: () => cosineSimilarity,
-  applyMMR: () => applyMMR,
-  REGISTRY_PATH: () => REGISTRY_PATH,
-  MODELS_DIR: () => MODELS_DIR,
-  DB_PATH: () => DB_PATH,
-  CORTEX_DIR: () => CORTEX_DIR
-});
-import Database from "better-sqlite3";
-import { existsSync, mkdirSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-function getDb() {
-  if (_db)
-    return _db;
-  if (!existsSync(CORTEX_DIR))
-    mkdirSync(CORTEX_DIR, { recursive: true });
-  if (!existsSync(MODELS_DIR))
-    mkdirSync(MODELS_DIR, { recursive: true });
-  _db = new Database(DB_PATH);
-  _db.pragma("journal_mode = WAL");
-  _db.pragma("synchronous = NORMAL");
-  _db.pragma("foreign_keys = ON");
-  _db.pragma("cache_size = -32000");
-  _db.exec(`
-    CREATE TABLE IF NOT EXISTS projects (
-      id           TEXT PRIMARY KEY,
-      name         TEXT NOT NULL,
-      path         TEXT,
-      created_at   INTEGER NOT NULL,
-      last_session INTEGER
-    );
-
-    CREATE TABLE IF NOT EXISTS sessions (
-      id                 TEXT PRIMARY KEY,
-      project_id         TEXT NOT NULL REFERENCES projects(id),
-      started_at         INTEGER NOT NULL,
-      ended_at           INTEGER,
-      summary            TEXT,
-      memories_injected  INTEGER NOT NULL DEFAULT 0,
-      memories_stored    INTEGER NOT NULL DEFAULT 0,
-      tool_failures      INTEGER NOT NULL DEFAULT 0
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_sessions_project
-      ON sessions(project_id, started_at DESC);
-
-    CREATE TABLE IF NOT EXISTS observations (
-      id          TEXT PRIMARY KEY,
-      session_id  TEXT NOT NULL REFERENCES sessions(id),
-      project_id  TEXT NOT NULL,
-      tool_name   TEXT,
-      content     TEXT NOT NULL,
-      category    TEXT,
-      created_at  INTEGER NOT NULL,
-      promoted    INTEGER NOT NULL DEFAULT 0
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_obs_session ON observations(session_id);
-    CREATE INDEX IF NOT EXISTS idx_obs_project ON observations(project_id, created_at DESC);
-
-    CREATE TABLE IF NOT EXISTS memories (
-      id           TEXT PRIMARY KEY,
-      project_id   TEXT NOT NULL,
-      tier         TEXT NOT NULL DEFAULT 'semantic',
-      category     TEXT NOT NULL DEFAULT 'insight',
-      trust        TEXT NOT NULL DEFAULT 'observed',
-      content      TEXT NOT NULL,
-      context      TEXT,
-      source       TEXT NOT NULL DEFAULT 'manual',
-      embedding    BLOB,
-      weight       REAL NOT NULL DEFAULT 1.0,
-      used_count   INTEGER NOT NULL DEFAULT 0,
-      last_used    INTEGER,
-      created_at   INTEGER NOT NULL,
-      session_id   TEXT REFERENCES sessions(id),
-      flagged      INTEGER NOT NULL DEFAULT 0,
-      flag_reason  TEXT
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_mem_project ON memories(project_id);
-    CREATE INDEX IF NOT EXISTS idx_mem_weight  ON memories(project_id, weight DESC);
-    CREATE INDEX IF NOT EXISTS idx_mem_tier    ON memories(project_id, tier);
-    CREATE INDEX IF NOT EXISTS idx_mem_trust   ON memories(project_id, trust);
-    CREATE INDEX IF NOT EXISTS idx_mem_flagged ON memories(project_id, flagged)
-      WHERE flagged = 1;
-
-    CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
-      content, context,
-      content='memories',
-      content_rowid='rowid',
-      tokenize='porter ascii'
-    );
-
-    CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN
-      INSERT INTO memories_fts(rowid, content, context)
-      VALUES (new.rowid, new.content, COALESCE(new.context, ''));
-    END;
-
-    CREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN
-      INSERT INTO memories_fts(memories_fts, rowid, content, context)
-      VALUES ('delete', old.rowid, old.content, COALESCE(old.context, ''));
-      INSERT INTO memories_fts(rowid, content, context)
-      VALUES (new.rowid, new.content, COALESCE(new.context, ''));
-    END;
-
-    CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN
-      INSERT INTO memories_fts(memories_fts, rowid, content, context)
-      VALUES ('delete', old.rowid, old.content, COALESCE(old.context, ''));
-    END;
-  `);
-  return _db;
-}
-function upsertProject(db, project) {
-  const existing = db.prepare("SELECT id FROM projects WHERE id = ?").get(project.id);
-  if (existing) {
-    db.prepare("UPDATE projects SET last_session = ? WHERE id = ?").run(Date.now(), project.id);
-  } else {
-    db.prepare("INSERT INTO projects (id, name, path, created_at) VALUES (?, ?, ?, ?)").run(project.id, project.name, project.path ?? null, Date.now());
-  }
-}
-function upsertSession(db, s) {
-  const existing = db.prepare("SELECT id FROM sessions WHERE id = ?").get(s.id);
-  if (existing) {
-    const sets = [];
-    const vals = [];
-    if (s.ended_at !== undefined) {
-      sets.push("ended_at = ?");
-      vals.push(s.ended_at);
-    }
-    if (s.summary !== undefined) {
-      sets.push("summary = ?");
-      vals.push(s.summary);
-    }
-    if (s.memories_stored !== undefined) {
-      sets.push("memories_stored = ?");
-      vals.push(s.memories_stored);
-    }
-    if (s.tool_failures !== undefined) {
-      sets.push("tool_failures = ?");
-      vals.push(s.tool_failures);
-    }
-    if (sets.length) {
-      vals.push(s.id);
-      db.prepare(`UPDATE sessions SET ${sets.join(", ")} WHERE id = ?`).run(...vals);
-    }
-  } else {
-    db.prepare("INSERT INTO sessions (id, project_id, started_at) VALUES (?, ?, ?)").run(s.id, s.project_id, Date.now());
-  }
-}
-function getRecentSummaries(db, projectId, limit = 3) {
-  const rows = db.prepare(`
-    SELECT summary FROM sessions
-    WHERE project_id = ? AND summary IS NOT NULL AND summary != ''
-    ORDER BY started_at DESC LIMIT ?
-  `).all(projectId, limit);
-  return rows.map((r) => r.summary);
-}
-function insertObservation(db, obs) {
-  db.prepare(`
-    INSERT INTO observations (id, session_id, project_id, tool_name, content, category, created_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?)
-  `).run(crypto.randomUUID(), obs.session_id, obs.project_id, obs.tool_name ?? null, obs.content, obs.category ?? null, Date.now());
-}
-function getSessionObservations(db, sessionId) {
-  return db.prepare("SELECT tool_name, content, category FROM observations WHERE session_id = ? AND promoted = 0 ORDER BY created_at ASC").all(sessionId);
-}
-function markObservationsPromoted(db, sessionId) {
-  db.prepare("UPDATE observations SET promoted = 1 WHERE session_id = ?").run(sessionId);
-}
-function insertMemory(db, m) {
-  const id = crypto.randomUUID();
-  db.prepare(`
-    INSERT INTO memories
-      (id, project_id, tier, category, trust, content, context,
-       source, embedding, weight, used_count, created_at, session_id)
-    VALUES
-      (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, ?, ?)
-  `).run(id, m.project_id, m.tier, m.category, m.trust, m.content, m.context ?? null, m.source, m.embedding ?? null, m.weight, Date.now(), m.session_id ?? null);
-  return id;
-}
-function searchBM25(db, projectId, query, limit) {
-  return db.prepare(`
-    SELECT m.* FROM memories_fts
-    JOIN memories m ON m.rowid = memories_fts.rowid
-    WHERE memories_fts MATCH ? AND m.project_id = ?
-    ORDER BY bm25(memories_fts) LIMIT ?
-  `).all(query, projectId, limit);
-}
-function cosineSimilarity(a, b) {
-  let dot = 0, na = 0, nb = 0;
-  for (let i = 0;i < a.length; i++) {
-    dot += a[i] * b[i];
-    na += a[i] * a[i];
-    nb += b[i] * b[i];
-  }
-  const d = Math.sqrt(na) * Math.sqrt(nb);
-  return d === 0 ? 0 : dot / d;
-}
-function searchVector(db, projectId, queryEmb, limit) {
-  const candidates = db.prepare("SELECT * FROM memories WHERE project_id = ? AND embedding IS NOT NULL").all(projectId);
-  return candidates.map((m) => ({
-    ...m,
-    similarity: cosineSimilarity(queryEmb, new Float32Array(m.embedding.buffer))
-  })).sort((a, b) => b.similarity - a.similarity).slice(0, limit);
-}
-function mergeRRF(list1, list2, limit, allItems) {
-  const k = 60;
-  const scores = new Map;
-  list1.forEach((r, i) => scores.set(r.id, (scores.get(r.id) ?? 0) + 1 / (i + k)));
-  list2.forEach((r, i) => scores.set(r.id, (scores.get(r.id) ?? 0) + 1 / (i + k)));
-  return [...scores.entries()].sort(([, a], [, b]) => b - a).slice(0, limit).map(([id]) => allItems.get(id)).filter(Boolean);
-}
-function applyMMR(candidates, queryEmb, limit, lambda = 0.7) {
-  if (!queryEmb || candidates.length <= limit)
-    return candidates.slice(0, limit);
-  const selected = [];
-  const remaining = [...candidates];
-  while (selected.length < limit && remaining.length > 0) {
-    let bestIdx = 0;
-    let bestScore = -Infinity;
-    for (let i = 0;i < remaining.length; i++) {
-      const cand = remaining[i];
-      const candEmb = cand.embedding ? new Float32Array(cand.embedding.buffer) : null;
-      if (!candEmb) {
-        bestIdx = i;
-        break;
-      }
-      const relevance = cand.similarity ?? cosineSimilarity(queryEmb, candEmb);
-      const maxSim = selected.reduce((max, s) => {
-        if (!s.embedding)
-          return max;
-        const sim = cosineSimilarity(candEmb, new Float32Array(s.embedding.buffer));
-        return Math.max(max, sim);
-      }, 0);
-      const score = lambda * relevance - (1 - lambda) * maxSim;
-      if (score > bestScore) {
-        bestScore = score;
-        bestIdx = i;
-      }
-    }
-    selected.push(remaining[bestIdx]);
-    remaining.splice(bestIdx, 1);
-  }
-  return selected;
-}
-function updateWeight(db, id, score) {
-  const mem = db.prepare("SELECT weight, used_count FROM memories WHERE id = ?").get(id);
-  if (!mem)
-    return;
-  const alpha = 0.3;
-  const newWeight = alpha * (score / 3) + (1 - alpha) * mem.weight;
-  const newTrust = newWeight > 1.4 || mem.used_count + 1 >= 3 ? "validated" : undefined;
-  if (newTrust) {
-    db.prepare("UPDATE memories SET weight = ?, used_count = used_count + 1, last_used = ?, trust = CASE WHEN trust = 'observed' THEN ? ELSE trust END WHERE id = ?").run(newWeight, Date.now(), newTrust, id);
-  } else {
-    db.prepare("UPDATE memories SET weight = ?, used_count = used_count + 1, last_used = ? WHERE id = ?").run(newWeight, Date.now(), id);
-  }
-}
-function decayAndPrune(db, projectId) {
-  const cutoff = Date.now() - 7 * 24 * 60 * 60 * 1000;
-  const decayed = db.prepare(`
-    UPDATE memories
-    SET weight = weight * CASE
-      WHEN trust IN ('proven', 'canonical') THEN 1.0
-      WHEN trust = 'validated' THEN 0.98
-      ELSE 0.95
-    END
-    WHERE project_id = ?
-      AND trust NOT IN ('canonical')
-      AND (last_used IS NULL OR last_used < ?)
-  `).run(projectId, cutoff).changes;
-  const pruned = db.prepare(`
-    DELETE FROM memories
-    WHERE project_id = ? AND weight < 0.1 AND used_count > 3
-      AND trust NOT IN ('proven', 'canonical')
-  `).run(projectId).changes;
-  return { decayed, pruned };
-}
-var CORTEX_DIR, DB_PATH, REGISTRY_PATH, MODELS_DIR, _db = null;
-var init_db = __esm(() => {
-  CORTEX_DIR = join(homedir(), ".apsolut");
-  DB_PATH = join(CORTEX_DIR, "memory.db");
-  REGISTRY_PATH = join(CORTEX_DIR, "registry.json");
-  MODELS_DIR = join(CORTEX_DIR, "models");
-});
 
 // src/cli.ts
 import {
-  existsSync as existsSync3,
-  mkdirSync as mkdirSync3,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
   readFileSync as readFileSync2,
   writeFileSync as writeFileSync2
 } from "fs";
 import { join as join2, resolve, dirname as dirname2 } from "path";
 import { homedir as homedir2 } from "os";
-import { fileURLToPath } from "url";
+import { fileURLToPath, pathToFileURL } from "url";
 
 // src/registry.ts
-init_db();
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { dirname } from "path";
+
+// src/db.ts
+import Database from "better-sqlite3";
+import { homedir } from "os";
+import { join } from "path";
+var CORTEX_DIR = join(homedir(), ".apsolut");
+var DB_PATH = join(CORTEX_DIR, "memory.db");
+var REGISTRY_PATH = join(CORTEX_DIR, "registry.json");
+var MODELS_DIR = join(CORTEX_DIR, "models");
+
+// src/registry.ts
 function readRegistry() {
-  if (!existsSync2(REGISTRY_PATH))
+  if (!existsSync(REGISTRY_PATH))
     return { projects: {} };
   try {
     return JSON.parse(readFileSync(REGISTRY_PATH, "utf-8"));
@@ -339,8 +36,8 @@ function readRegistry() {
 }
 function writeRegistry(reg) {
   const dir = dirname(REGISTRY_PATH);
-  if (!existsSync2(dir))
-    mkdirSync2(dir, { recursive: true });
+  if (!existsSync(dir))
+    mkdirSync(dir, { recursive: true });
   writeFileSync(REGISTRY_PATH, JSON.stringify(reg, null, 2));
 }
 function registerProject(id, name, path) {
@@ -398,23 +95,23 @@ Models: ~/.apsolut/models/
 }
 async function runHook(name) {
   const hookPath = IS_DIST ? join2(__dirname2, "hooks", `${name}.js`) : join2(__dirname2, "hooks", `${name}.ts`);
-  if (!existsSync3(hookPath)) {
+  if (!existsSync2(hookPath)) {
     process.stderr.write(`[apsolut-cortex] hook not found: ${hookPath}
 `);
     process.exit(0);
   }
-  await import(hookPath);
+  await import(pathToFileURL(hookPath).href);
 }
 async function init() {
   console.log(`
 apsolut-cortex init
 `);
-  if (!existsSync3(PROJECT_APSOLUT)) {
-    mkdirSync3(PROJECT_APSOLUT, { recursive: true });
+  if (!existsSync2(PROJECT_APSOLUT)) {
+    mkdirSync2(PROJECT_APSOLUT, { recursive: true });
   }
   let projectId;
   let projectName;
-  if (existsSync3(PROJECT_CONFIG)) {
+  if (existsSync2(PROJECT_CONFIG)) {
     const existing = JSON.parse(readFileSync2(PROJECT_CONFIG, "utf-8"));
     projectId = existing.id;
     projectName = existing.name;
@@ -437,7 +134,7 @@ apsolut-cortex init
   const mcpCommand = IS_DIST ? "node" : "bun";
   const mcpArgs = [mcpServerPath];
   let mcp = {};
-  if (existsSync3(MCP_JSON)) {
+  if (existsSync2(MCP_JSON)) {
     try {
       mcp = JSON.parse(readFileSync2(MCP_JSON, "utf-8"));
     } catch {}
@@ -453,16 +150,16 @@ apsolut-cortex init
   console.log(`✓ Written .mcp.json`);
   const hookCmd = IS_DIST ? "apsolut-cortex" : `bun run ${join2(__dirname2, "cli.ts")}`;
   const hookEntries = {
-    SessionStart: [{ command: `${hookCmd} hook:session-start` }],
-    PostToolUse: [{ command: `${hookCmd} hook:post-tool-use` }],
-    Stop: [{ command: `${hookCmd} hook:stop` }],
-    SessionEnd: [{ command: `${hookCmd} hook:session-end` }]
+    SessionStart: [{ matcher: "", hooks: [{ type: "command", command: `${hookCmd} hook:session-start` }] }],
+    PostToolUse: [{ matcher: "", hooks: [{ type: "command", command: `${hookCmd} hook:post-tool-use` }] }],
+    Stop: [{ matcher: "", hooks: [{ type: "command", command: `${hookCmd} hook:stop` }] }],
+    SessionEnd: [{ matcher: "", hooks: [{ type: "command", command: `${hookCmd} hook:session-end` }] }]
   };
   let settings = {};
   const settingsDir = dirname2(CLAUDE_SETTINGS);
-  if (!existsSync3(settingsDir))
-    mkdirSync3(settingsDir, { recursive: true });
-  if (existsSync3(CLAUDE_SETTINGS)) {
+  if (!existsSync2(settingsDir))
+    mkdirSync2(settingsDir, { recursive: true });
+  if (existsSync2(CLAUDE_SETTINGS)) {
     try {
       settings = JSON.parse(readFileSync2(CLAUDE_SETTINGS, "utf-8"));
     } catch {}
@@ -481,7 +178,7 @@ apsolut-cortex init
   writeFileSync2(CLAUDE_SETTINGS, JSON.stringify(settings, null, 2));
   console.log(added > 0 ? `✓ Registered ${added} hooks in ~/.claude/settings.json` : `✓ Hooks already registered`);
   const gitignore = join2(PROJECT_ROOT, ".gitignore");
-  if (existsSync3(gitignore)) {
+  if (existsSync2(gitignore)) {
     const content = readFileSync2(gitignore, "utf-8");
     if (!content.includes(".apsolut/")) {
       writeFileSync2(gitignore, content + `
@@ -501,7 +198,7 @@ apsolut-cortex init
   │  ██║  ██║██║     ███████║╚██████╔╝███████╗╚██████╔╝   ██║    │
   │  ╚═╝  ╚═╝╚═╝     ╚══════╝ ╚═════╝ ╚══════╝ ╚═════╝    ╚═╝    │
   │                                                         │
-  │            c o r t e x  ·  v 0 . 1 . 0                 │
+  │            c o r t e x  ·  v ${PKG_VERSION}                 │
   │                                                         │
   └─────────────────────────────────────────────────────────┘
 
@@ -519,13 +216,13 @@ apsolut-cortex init
   console.log(BANNER);
 }
 async function status() {
-  const { getDb: getDb2 } = await Promise.resolve().then(() => (init_db(), exports_db));
-  if (!existsSync3(PROJECT_CONFIG)) {
+  const { getDb } = await import(pathToFileURL(join2(__dirname2, "db.js")).href);
+  if (!existsSync2(PROJECT_CONFIG)) {
     console.log("No project found. Run: apsolut-cortex init");
     process.exit(1);
   }
   const project = JSON.parse(readFileSync2(PROJECT_CONFIG, "utf-8"));
-  const db = getDb2();
+  const db = getDb();
   const total = db.prepare("SELECT COUNT(*) as n FROM memories WHERE project_id = ?").get(project.id).n;
   const sessions = db.prepare("SELECT COUNT(*) as n FROM sessions WHERE project_id = ?").get(project.id).n;
   const byTrust = db.prepare(`
@@ -555,7 +252,7 @@ DB: ~/.apsolut/memory.db
 `);
 }
 function uninstall() {
-  if (existsSync3(MCP_JSON)) {
+  if (existsSync2(MCP_JSON)) {
     try {
       const mcp = JSON.parse(readFileSync2(MCP_JSON, "utf-8"));
       if (mcp.mcpServers?.["apsolut-cortex"]) {
@@ -565,14 +262,21 @@ function uninstall() {
       }
     } catch {}
   }
-  if (existsSync3(CLAUDE_SETTINGS)) {
+  if (existsSync2(CLAUDE_SETTINGS)) {
     try {
       const settings = JSON.parse(readFileSync2(CLAUDE_SETTINGS, "utf-8"));
       const hooks = settings.hooks;
       if (hooks) {
         for (const event of ["SessionStart", "PostToolUse", "Stop", "SessionEnd"]) {
           if (hooks[event]) {
-            hooks[event] = hooks[event].filter((e) => !(typeof e === "object" && e.command?.includes("apsolut-cortex")));
+            hooks[event] = hooks[event].filter((e) => {
+              if (typeof e !== "object")
+                return true;
+              if (Array.isArray(e.hooks)) {
+                return !e.hooks.some((h) => h.command?.includes("apsolut-cortex"));
+              }
+              return !e.command?.includes("apsolut-cortex");
+            });
           }
         }
         writeFileSync2(CLAUDE_SETTINGS, JSON.stringify(settings, null, 2));

package/dist/hooks/post-tool-use.js

@@ -1,6 +1,3 @@
-#!/usr/bin/env bun
-// @bun
-
 // src/hooks/post-tool-use.ts
 import { readFileSync, existsSync as existsSync2 } from "fs";
 import { join as join2 } from "path";
@@ -190,7 +187,12 @@ function classifyToolUse(toolName, toolInput, toolResponse) {
 
 // src/hooks/post-tool-use.ts
 async function main() {
-  const raw = await Bun.stdin.text();
+  const raw = await new Promise((resolve) => {
+    let d = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (c) => d += c);
+    process.stdin.on("end", () => resolve(d));
+  });
   let data = {};
   try {
     data = JSON.parse(raw);

package/dist/hooks/session-end.js

@@ -1,9 +1,6 @@
-#!/usr/bin/env bun
-// @bun
-
 // src/hooks/session-end.ts
 import { readFileSync, existsSync as existsSync2 } from "fs";
-import { join as join3 } from "path";
+import { join as join2 } from "path";
 
 // src/db.ts
 import Database from "better-sqlite3";
@@ -324,18 +321,7 @@ async function compressSession(observations, project) {
 
 // src/embed.ts
 import { pipeline, env } from "@xenova/transformers";
-
-// src/db.ts
-import Database2 from "better-sqlite3";
-import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
-var CORTEX_DIR2 = join2(homedir2(), ".apsolut");
-var DB_PATH2 = join2(CORTEX_DIR2, "memory.db");
-var REGISTRY_PATH2 = join2(CORTEX_DIR2, "registry.json");
-var MODELS_DIR2 = join2(CORTEX_DIR2, "models");
-
-// src/embed.ts
-env.cacheDir = MODELS_DIR2;
+env.cacheDir = MODELS_DIR;
 env.allowRemoteModels = true;
 var _embedder = null;
 async function getEmbedder() {
@@ -355,7 +341,12 @@ function float32ToBuffer(arr) {
 
 // src/hooks/session-end.ts
 async function main() {
-  const raw = await Bun.stdin.text();
+  const raw = await new Promise((resolve) => {
+    let d = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (c) => d += c);
+    process.stdin.on("end", () => resolve(d));
+  });
   let data = {};
   try {
     data = JSON.parse(raw);
@@ -364,7 +355,7 @@ async function main() {
   }
   const cwd = data.cwd ?? process.cwd();
   const sessionId = data.session_id ?? "unknown";
-  const projectFile = join3(cwd, ".apsolut", "project.json");
+  const projectFile = join2(cwd, ".apsolut", "project.json");
   if (!existsSync2(projectFile))
     process.exit(0);
   let project = null;

package/dist/hooks/session-start.js

@@ -1,6 +1,3 @@
-#!/usr/bin/env bun
-// @bun
-
 // src/hooks/session-start.ts
 import { readFileSync, existsSync as existsSync2 } from "fs";
 import { join as join2 } from "path";
@@ -156,7 +153,12 @@ function upsertSession(db, s) {
 
 // src/hooks/session-start.ts
 async function main() {
-  const raw = await Bun.stdin.text();
+  const raw = await new Promise((resolve) => {
+    let d = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (c) => d += c);
+    process.stdin.on("end", () => resolve(d));
+  });
   let data = {};
   try {
     data = JSON.parse(raw);
@@ -180,7 +182,7 @@ async function main() {
     const db = getDb();
     upsertProject(db, { id: project.id, name: project.name, path: cwd });
     upsertSession(db, { id: sessionId, project_id: project.id });
-    process.stdout.write(`[apsolut-cortex] Project: ${project.name} \u2014 say "remember <topic>" to search memory.`);
+    process.stdout.write(`[apsolut-cortex] Project: ${project.name} — say "remember <topic>" to search memory.`);
   } catch {
     process.exit(0);
   }

package/dist/hooks/stop.js

@@ -1,6 +1,3 @@
-#!/usr/bin/env bun
-// @bun
-
 // src/hooks/stop.ts
 import { readFileSync, existsSync as existsSync2 } from "fs";
 import { join as join2 } from "path";
@@ -158,7 +155,7 @@ var CORRECTION_PATTERNS = [
   /(?:my mistake|i was wrong|incorrect)[^.]*[.!]\s*(.{20,150})/gi,
   /(?:wait|oops)[,.]?\s+(.{20,150})/gi,
   /(?:turns? out|it seems?)\s+(.{20,150})/gi,
-  /(?:should(?:n'?t)? have|shouldn'?t).{0,30}[\u2014\u2013-]\s*(.{20,150})/gi,
+  /(?:should(?:n'?t)? have|shouldn'?t).{0,30}[—–-]\s*(.{20,150})/gi,
   /(?:the correct|correct(?:ly)?)\s+(?:way|path|file|approach)\s+is\s+(.{20,150})/gi
 ];
 function extractCorrections(transcript) {
@@ -175,7 +172,12 @@ function extractCorrections(transcript) {
   return [...new Set(found)].slice(0, 5);
 }
 async function main() {
-  const raw = await Bun.stdin.text();
+  const raw = await new Promise((resolve) => {
+    let d = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (c) => d += c);
+    process.stdin.on("end", () => resolve(d));
+  });
   let data = {};
   try {
     data = JSON.parse(raw);

package/dist/mcp/server.js

@@ -9,7 +9,8 @@ import {
   ListToolsRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
 import { readFileSync, existsSync as existsSync2 } from "fs";
-import { join as join3 } from "path";
+import { join as join3, dirname, resolve } from "path";
+import { fileURLToPath } from "url";
 
 // src/db.ts
 import Database from "better-sqlite3";
@@ -264,7 +265,9 @@ var db = getDb();
 if (project?.id) {
   upsertProject(db, { id: project.id, name: project.name, path: PROJECT_PATH });
 }
-var server = new Server({ name: "apsolut-cortex", version: "0.1.0" }, { capabilities: { tools: {} } });
+var __mcp_dirname = dirname(fileURLToPath(import.meta.url));
+var PKG_VERSION = JSON.parse(readFileSync(resolve(__mcp_dirname, "..", "package.json"), "utf-8")).version;
+var server = new Server({ name: "apsolut-cortex", version: PKG_VERSION }, { capabilities: { tools: {} } });
 function requireProject() {
   if (!project?.id)
     throw new Error("No project found. Run: apsolut-cortex init");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apsolut-cortex",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "Persistent memory for Claude Code projects — stores corrections, decisions, and patterns across sessions",
   "type": "module",
   "bin": {