kontex-core 1.0.0

package/dist/index.js

@@ -0,0 +1,1750 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/secrets.ts
+function buildExtraPatterns(extraPatterns) {
+  const result = [];
+  for (const pattern of extraPatterns) {
+    try {
+      result.push({ name: `custom:${pattern.slice(0, 30)}`, regex: new RegExp(pattern) });
+    } catch {}
+  }
+  return result;
+}
+function scanForSecrets(content, extraPatterns = []) {
+  const allPatterns = [...SECRET_PATTERNS, ...buildExtraPatterns(extraPatterns)];
+  for (const { name, regex } of allPatterns) {
+    if (regex.test(content)) {
+      return { blocked: true, pattern: name };
+    }
+  }
+  return { blocked: false };
+}
+var SECRET_PATTERNS;
+var init_secrets = __esm(() => {
+  SECRET_PATTERNS = [
+    { name: "generic-long-token", regex: /['"]\w{32,}['"]/ },
+    { name: "api-key-assignment", regex: /api[_-]?key\s*[:=]\s*['"]?\w+/i },
+    { name: "secret-key-assignment", regex: /secret[_-]?key\s*[:=]\s*['"]?\w+/i },
+    { name: "password-assignment", regex: /password\s*[:=]\s*['"]?[^\s'"]{8,}/i },
+    { name: "postgres-connection", regex: /postgres:\/\/[^@]+:[^@]+@/ },
+    { name: "mysql-connection", regex: /mysql:\/\/[^@]+:[^@]+@/ },
+    { name: "mongodb-connection", regex: /mongodb\+srv:\/\/[^@]+:[^@]+@/ },
+    { name: "openai-key", regex: /sk-[a-zA-Z0-9]{40,}/ },
+    { name: "github-personal-token", regex: /ghp_[a-zA-Z0-9]{36}/ },
+    { name: "aws-access-key", regex: /AKIA[A-Z0-9]{16}/ }
+  ];
+});
+
+// src/storage/db.ts
+var exports_db = {};
+__export(exports_db, {
+  getDatabase: () => getDatabase,
+  closeDatabase: () => closeDatabase,
+  EMBEDDING_DIM: () => EMBEDDING_DIM
+});
+import { Database } from "bun:sqlite";
+import { join as join2 } from "path";
+import { existsSync as existsSync2, mkdirSync } from "fs";
+import * as sqliteVec from "sqlite-vec";
+function getDatabase(workspaceRoot) {
+  if (dbInstance)
+    return dbInstance;
+  const indexDir = join2(workspaceRoot, INDEX_DIR);
+  if (!existsSync2(indexDir))
+    mkdirSync(indexDir, { recursive: true });
+  const db = new Database(join2(indexDir, DB_FILENAME));
+  db.exec("PRAGMA journal_mode=WAL");
+  db.exec("PRAGMA synchronous=NORMAL");
+  tryLoadVecExtension(db);
+  runMigrations(db);
+  dbInstance = db;
+  return db;
+}
+function closeDatabase() {
+  if (dbInstance) {
+    dbInstance.close();
+    dbInstance = null;
+  }
+}
+function runMigrations(db) {
+  db.exec(`CREATE TABLE IF NOT EXISTS schema_version (version INTEGER PRIMARY KEY)`);
+  const currentVersion = db.prepare("SELECT COALESCE(MAX(version), 0) as v FROM schema_version").get();
+  if (currentVersion.v < 1)
+    migrateV1(db);
+}
+function migrateV1(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS memories (
+      uri TEXT PRIMARY KEY,
+      content TEXT NOT NULL,
+      type TEXT NOT NULL CHECK(type IN ('decision', 'pattern', 'gotcha', 'convention', 'resource')),
+      l0 TEXT NOT NULL DEFAULT '',
+      l1 TEXT NOT NULL DEFAULT '',
+      l2 TEXT NOT NULL DEFAULT '',
+      confidence REAL NOT NULL DEFAULT 0.0,
+      verified INTEGER NOT NULL DEFAULT 0,
+      stale INTEGER NOT NULL DEFAULT 0,
+      global INTEGER NOT NULL DEFAULT 0,
+      ref_count INTEGER NOT NULL DEFAULT 0,
+      author TEXT NOT NULL DEFAULT '',
+      affected_paths TEXT NOT NULL DEFAULT '[]',
+      tags TEXT NOT NULL DEFAULT '[]',
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  try {
+    db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS memory_embeddings USING vec0(
+        uri TEXT PRIMARY KEY,
+        embedding float[${EMBEDDING_DIM}]
+      )
+    `);
+  } catch {}
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(type)`);
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_memories_verified ON memories(verified)`);
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_memories_stale ON memories(stale)`);
+  db.exec("INSERT INTO schema_version (version) VALUES (1)");
+}
+function tryLoadVecExtension(db) {
+  try {
+    const extPath = sqliteVec.getLoadablePath();
+    db.loadExtension(extPath);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "unknown error";
+    console.warn(`kontex: sqlite-vec extension not available (${message}). Semantic search will use keyword matching.`);
+  }
+}
+var INDEX_DIR = ".kontex-index", DB_FILENAME = "index.db", EMBEDDING_DIM = 384, dbInstance = null;
+var init_db = () => {};
+
+// src/storage/embeddings.ts
+import { join as join3 } from "path";
+import { homedir } from "os";
+async function initEmbeddingModel(modelName = DEFAULT_MODEL) {
+  if (pipeline)
+    return;
+  if (!modelLoading)
+    modelLoading = loadPipeline(modelName);
+  pipeline = await modelLoading;
+}
+async function embed(text) {
+  if (!pipeline)
+    await initEmbeddingModel();
+  const result = await pipeline(text, { pooling: "mean", normalize: true });
+  return result.data;
+}
+async function loadPipeline(modelName) {
+  const { pipeline: createPipeline, env } = await import("@xenova/transformers");
+  env.cacheDir = CACHE_DIR;
+  env.allowLocalModels = true;
+  const pipe = await createPipeline("feature-extraction", modelName);
+  return pipe;
+}
+var DEFAULT_MODEL = "Xenova/all-MiniLM-L6-v2", CACHE_DIR, pipeline = null, modelLoading = null;
+var init_embeddings = __esm(() => {
+  CACHE_DIR = join3(homedir(), ".cache", "kontex", "models");
+});
+
+// src/memory/write.ts
+var exports_write = {};
+__export(exports_write, {
+  writeMemory: () => writeMemory,
+  logDecision: () => logDecision,
+  invalidateMemory: () => invalidateMemory
+});
+import { writeFileSync as writeFileSync2, readFileSync as readFileSync2, existsSync as existsSync3, mkdirSync as mkdirSync2, appendFileSync } from "fs";
+import { join as join4, dirname } from "path";
+import matter from "gray-matter";
+async function writeMemory(entry, workspaceRoot, config) {
+  const logPath = join4(workspaceRoot, ".kontex-log", "quality.log");
+  const secretResult = scanForSecrets(entry.content, config.secrets.extraPatterns);
+  if (secretResult.blocked) {
+    logQualityEvent(logPath, "BLOCKED", `Secret detected: ${secretResult.pattern}`);
+    logSecurityEvent(workspaceRoot, secretResult.pattern);
+    return { success: false, error: `Write blocked: content contains a secret (pattern: ${secretResult.pattern})` };
+  }
+  const db = getDatabase(workspaceRoot);
+  const dedupResult = await dedupCheck(entry.content, db, config);
+  if (dedupResult.status === "duplicate") {
+    logQualityEvent(logPath, "DEDUP", `Duplicate of ${dedupResult.existing_uri}`);
+    return { success: false, error: `Duplicate: too similar to ${dedupResult.existing_uri}` };
+  }
+  if (dedupResult.status === "conflict") {
+    logQualityEvent(logPath, "CONFLICT", `Conflicts with ${dedupResult.existing_uri}`);
+    return { success: false, error: dedupResult.message, conflict: dedupResult };
+  }
+  if (entry.confidence < config.quality.minConfidence) {
+    logQualityEvent(logPath, "DISCARDED", `Confidence ${entry.confidence} below ${config.quality.minConfidence}`);
+    return { success: false, error: `Discarded: confidence ${entry.confidence} below minimum ${config.quality.minConfidence}` };
+  }
+  const verified = entry.confidence >= config.quality.autoVerifyThreshold;
+  const uri = generateUri(entry.type, entry.content);
+  const now = new Date().toISOString();
+  const author = await getGitAuthor(workspaceRoot);
+  const frontmatter = {
+    uri,
+    type: entry.type,
+    created: now,
+    updated: now,
+    author,
+    confidence: entry.confidence,
+    verified,
+    stale: false,
+    global: false,
+    affected_paths: entry.affected_paths ?? [],
+    ref_count: 0,
+    tags: extractTags(entry.content)
+  };
+  const l0 = entry.content.split(`
+`)[0]?.slice(0, 200) ?? entry.content.slice(0, 200);
+  const l1 = entry.why_memorable ? `## Why
+
+${entry.why_memorable}
+
+${entry.content}` : entry.content;
+  const fileContent = matter.stringify(`# L0
+${l0}
+
+# L1
+${l1}
+
+# L2
+[Session context]
+`, frontmatter);
+  const filePath = join4(workspaceRoot, ".context", `${uri}.md`);
+  const fileDir = dirname(filePath);
+  if (!existsSync3(fileDir))
+    mkdirSync2(fileDir, { recursive: true });
+  writeFileSync2(filePath, fileContent, "utf-8");
+  await indexMemoryEntry(uri, entry.content, entry.type, verified, entry.confidence, entry.affected_paths ?? [], db, l0, l1, "");
+  logQualityEvent(logPath, "WRITTEN", `${uri} (verified: ${verified})`);
+  return { success: true, uri, verified };
+}
+async function invalidateMemory(uri, reason, workspaceRoot) {
+  const filePath = join4(workspaceRoot, ".context", `${uri}.md`);
+  if (!existsSync3(filePath))
+    return { success: false, error: `Entry not found: ${uri}` };
+  const raw = readFileSync2(filePath, "utf-8");
+  const parsed = matter(raw);
+  parsed.data.stale = true;
+  parsed.data.updated = new Date().toISOString();
+  writeFileSync2(filePath, matter.stringify(parsed.content, parsed.data), "utf-8");
+  const db = getDatabase(workspaceRoot);
+  db.prepare("UPDATE memories SET stale = 1, updated_at = datetime('now') WHERE uri = ?").run(uri);
+  logQualityEvent(join4(workspaceRoot, ".kontex-log", "quality.log"), "INVALIDATED", `${uri}: ${reason}`);
+  return { success: true, uri };
+}
+async function logDecision(adr, workspaceRoot, _config) {
+  const decisionsDir = join4(workspaceRoot, ".context", "memory", "decisions");
+  if (!existsSync3(decisionsDir))
+    mkdirSync2(decisionsDir, { recursive: true });
+  const { readdirSync } = await import("fs");
+  const existing = readdirSync(decisionsDir).filter((f) => f.endsWith(".md"));
+  const nextNum = String(existing.length + 1).padStart(3, "0");
+  const slug = slugify(adr.title);
+  const uri = `memory/decisions/${nextNum}-${slug}`;
+  const now = new Date().toISOString();
+  const author = await getGitAuthor(workspaceRoot);
+  const frontmatter = {
+    uri,
+    type: "decision",
+    created: now,
+    updated: now,
+    author,
+    confidence: 0.95,
+    verified: true,
+    stale: false,
+    global: false,
+    affected_paths: adr.affected_paths ?? [],
+    ref_count: 0,
+    tags: extractTags(adr.title + " " + adr.decision)
+  };
+  const alternativesSection = adr.alternatives?.length ? `
+
+## Alternatives considered
+${adr.alternatives.map((a) => `- ${a}`).join(`
+`)}` : "";
+  const consequencesSection = adr.consequences ? `
+
+## Consequences
+${adr.consequences}` : "";
+  const l0 = `${adr.title}. Decision: ${now.slice(0, 10)}.`;
+  const body = `# L0
+${l0}
+
+# L1
+## Context
+${adr.context}
+
+## Decision
+${adr.decision}
+
+## Rationale
+${adr.rationale}${alternativesSection}${consequencesSection}
+`;
+  const fileContent = matter.stringify(body, frontmatter);
+  const filePath = join4(workspaceRoot, ".context", `${uri}.md`);
+  const fileDir = dirname(filePath);
+  if (!existsSync3(fileDir))
+    mkdirSync2(fileDir, { recursive: true });
+  writeFileSync2(filePath, fileContent, "utf-8");
+  const db = getDatabase(workspaceRoot);
+  const adrContent = `${adr.title} ${adr.decision} ${adr.context}`;
+  await indexMemoryEntry(uri, adrContent, "decision", true, 0.95, adr.affected_paths ?? [], db, l0, body, "");
+  return { success: true, uri, verified: true };
+}
+async function dedupCheck(content, db, config) {
+  try {
+    const embedding = await embed(content);
+    const embeddingBuffer = Buffer.from(embedding.buffer);
+    const similar = db.prepare(`
+      SELECT m.uri, m.content, m.verified, m.confidence, vec_distance_cosine(e.embedding, ?) AS distance
+      FROM memory_embeddings e JOIN memories m ON m.uri = e.uri ORDER BY distance ASC LIMIT 5
+    `).all(embeddingBuffer);
+    if (!similar.length)
+      return { status: "clear" };
+    const top = similar[0];
+    const similarity = 1 - top.distance;
+    if (similarity > config.quality.deduplicateThreshold)
+      return { status: "duplicate", existing_uri: top.uri };
+    if (similarity > config.quality.contradictionThreshold)
+      return { status: "conflict", existing_uri: top.uri, existing_content: top.content, message: `Similar memory exists at ${top.uri}. If this supersedes it, call kontex_invalidate first.` };
+    return { status: "clear" };
+  } catch {
+    return { status: "clear" };
+  }
+}
+async function indexMemoryEntry(uri, content, type, verified, confidence, affectedPaths, db, l0 = "", l1 = "", l2 = "") {
+  db.prepare(`INSERT OR REPLACE INTO memories (uri, content, type, l0, l1, l2, verified, confidence, affected_paths, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))`).run(uri, content, type, l0, l1, l2, verified ? 1 : 0, confidence, JSON.stringify(affectedPaths));
+  try {
+    const embedding = await embed(content);
+    db.prepare(`INSERT OR REPLACE INTO memory_embeddings (uri, embedding) VALUES (?, ?)`).run(uri, Buffer.from(embedding.buffer));
+  } catch {}
+}
+function generateUri(type, content) {
+  const slug = slugify(content.split(`
+`)[0]?.slice(0, 60) ?? "entry");
+  return `memory/${type}s/${slug}-${Date.now().toString(36)}`;
+}
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 50);
+}
+function extractTags(content) {
+  const words = content.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((w) => w.length > 3 && w.length < 20);
+  const counts = new Map;
+  for (const word of words)
+    counts.set(word, (counts.get(word) ?? 0) + 1);
+  return [...counts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([word]) => word);
+}
+async function getGitAuthor(workspaceRoot) {
+  try {
+    const proc = Bun.spawn(["git", "config", "user.email"], { cwd: workspaceRoot, stdout: "pipe" });
+    return (await new Response(proc.stdout).text()).trim() || "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function logQualityEvent(logPath, event, message) {
+  const logDir = dirname(logPath);
+  if (!existsSync3(logDir))
+    mkdirSync2(logDir, { recursive: true });
+  appendFileSync(logPath, `[${new Date().toISOString()}] ${event}: ${message}
+`, "utf-8");
+}
+function logSecurityEvent(workspaceRoot, pattern) {
+  logQualityEvent(join4(workspaceRoot, ".kontex-log", "security.log"), "SECRET_BLOCKED", pattern);
+}
+var init_write = __esm(() => {
+  init_secrets();
+  init_embeddings();
+  init_db();
+});
+
+// src/llm.ts
+var exports_llm = {};
+__export(exports_llm, {
+  createLLMModel: () => createLLMModel
+});
+async function createLLMModel(config, token) {
+  const { createOpenAI } = await import("@ai-sdk/openai");
+  switch (config.llm.provider) {
+    case "github-models":
+      return createOpenAI({
+        baseURL: "https://models.inference.ai.azure.com",
+        apiKey: token ?? ""
+      })(config.llm.model);
+    case "openai":
+      return createOpenAI({
+        apiKey: config.llm.apiKey ?? process.env.OPENAI_API_KEY ?? ""
+      })(config.llm.model);
+    case "ollama":
+      return createOpenAI({
+        baseURL: "http://localhost:11434/v1",
+        apiKey: "ollama"
+      })(config.llm.model);
+    case "anthropic":
+      return null;
+    case "none":
+      return null;
+    default:
+      return null;
+  }
+}
+
+// src/config.ts
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { join } from "path";
+var DEFAULT_CONFIG = {
+  compile: {
+    tokenBudget: 3000,
+    alwaysInclude: ["memory/project.md"],
+    excludePaths: ["memory/sessions/archive/"]
+  },
+  embedding: {
+    provider: "local",
+    model: "Xenova/all-MiniLM-L6-v2"
+  },
+  llm: {
+    provider: "github-models",
+    model: "gpt-4o-mini"
+  },
+  quality: {
+    minConfidence: 0.6,
+    autoVerifyThreshold: 0.85,
+    deduplicateThreshold: 0.92,
+    contradictionThreshold: 0.75
+  },
+  hooks: {
+    postCommitExtract: true,
+    postMergeRecompile: true,
+    maxBackgroundRetries: 2
+  },
+  secrets: {
+    scan: true,
+    extraPatterns: []
+  },
+  decay: {
+    sessionArchiveDays: 7,
+    unverifiedExpireDays: 30,
+    maxSessionsDirKB: 500
+  }
+};
+var CONFIG_FILENAME = "kontex.config.json";
+function resolveEnvVars(value) {
+  return value.replace(/\$\{(\w+)\}/g, (_, envKey) => {
+    return process.env[envKey] ?? "";
+  });
+}
+function deepMerge(defaults, overrides) {
+  const result = { ...defaults };
+  for (const key of Object.keys(overrides)) {
+    const overrideVal = overrides[key];
+    const defaultVal = defaults[key];
+    if (overrideVal !== undefined && typeof overrideVal === "object" && !Array.isArray(overrideVal) && typeof defaultVal === "object" && !Array.isArray(defaultVal) && defaultVal !== null) {
+      result[key] = deepMerge(defaultVal, overrideVal);
+    } else if (overrideVal !== undefined) {
+      result[key] = overrideVal;
+    }
+  }
+  return result;
+}
+function loadConfig(workspaceRoot) {
+  const configPath = join(workspaceRoot, CONFIG_FILENAME);
+  if (!existsSync(configPath)) {
+    return { ...DEFAULT_CONFIG };
+  }
+  try {
+    const raw = readFileSync(configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    const merged = deepMerge(DEFAULT_CONFIG, parsed);
+    if (merged.llm && merged.llm.apiKey) {
+      merged.llm.apiKey = resolveEnvVars(merged.llm.apiKey);
+    }
+    return merged;
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+function writeConfig(workspaceRoot, config) {
+  const configPath = join(workspaceRoot, CONFIG_FILENAME);
+  const serializable = { ...config };
+  writeFileSync(configPath, JSON.stringify(serializable, null, 2) + `
+`, "utf-8");
+}
+
+// src/index.ts
+init_secrets();
+
+// src/auth.ts
+import keytar from "keytar";
+var KEYCHAIN_SERVICE = "kontex";
+var KEYCHAIN_ACCOUNT = "github-oauth";
+var GITHUB_CLIENT_ID = "Ov23liMXcybhETe03nNJ";
+async function login() {
+  const { createOAuthDeviceAuth } = await import("@octokit/auth-oauth-device");
+  const auth = createOAuthDeviceAuth({
+    clientType: "oauth-app",
+    clientId: GITHUB_CLIENT_ID,
+    scopes: [],
+    onVerification: (verification) => {
+      console.log(`
+Visit: ${verification.verification_uri}`);
+      console.log(`Code:  ${verification.user_code}
+`);
+      console.log(`Waiting for authorization...
+`);
+      openBrowser(verification.verification_uri).catch(() => {});
+    }
+  });
+  const { token } = await auth({ type: "oauth" });
+  await keytar.setPassword(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT, token);
+  const username = await fetchGitHubUsername(token);
+  console.log(`\u2713 Authenticated as @${username}`);
+  console.log("\u2713 GitHub Models access confirmed");
+  return username;
+}
+async function logout() {
+  const deleted = await keytar.deletePassword(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT);
+  console.log(deleted ? "\u2713 Token removed from keychain" : "No token found in keychain");
+}
+async function getToken() {
+  return keytar.getPassword(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT);
+}
+async function isAuthenticated() {
+  const token = await getToken();
+  return token !== null;
+}
+async function fetchGitHubUsername(token) {
+  const response = await fetch("https://api.github.com/user", {
+    headers: { Authorization: `Bearer ${token}`, Accept: "application/vnd.github+json" }
+  });
+  if (!response.ok)
+    throw new Error(`GitHub API returned ${response.status}`);
+  const data = await response.json();
+  return data.login;
+}
+async function openBrowser(url) {
+  const { exec } = await import("child_process");
+  const command = process.platform === "darwin" ? `open "${url}"` : process.platform === "win32" ? `start "${url}"` : `xdg-open "${url}"`;
+  return new Promise((resolve, reject) => {
+    exec(command, (error) => {
+      if (error)
+        reject(error);
+      else
+        resolve();
+    });
+  });
+}
+
+// src/index.ts
+init_db();
+init_embeddings();
+init_write();
+
+// src/memory/read.ts
+init_embeddings();
+init_db();
+import { readFileSync as readFileSync3, readdirSync, existsSync as existsSync4 } from "fs";
+import { join as join5, relative } from "path";
+import matter2 from "gray-matter";
+async function findMemories(query, limit = 5, workspaceRoot) {
+  const db = getDatabase(workspaceRoot);
+  try {
+    return await vectorSearch(query, limit, db);
+  } catch {
+    return keywordSearch(query, limit, db);
+  }
+}
+function loadAllEntries(workspaceRoot) {
+  const memoryDir = join5(workspaceRoot, ".context", "memory");
+  if (!existsSync4(memoryDir))
+    return [];
+  const entries = [];
+  collectEntries(memoryDir, workspaceRoot, entries);
+  return entries;
+}
+function loadEntry(uri, workspaceRoot) {
+  const filePath = join5(workspaceRoot, ".context", `${uri}.md`);
+  return existsSync4(filePath) ? parseMemoryFile(filePath, workspaceRoot) : null;
+}
+async function vectorSearch(query, limit, db) {
+  const queryEmbedding = await embed(query);
+  const results = db.prepare(`
+    SELECT m.uri, m.content, m.type, m.verified, vec_distance_cosine(e.embedding, ?) AS distance
+    FROM memory_embeddings e JOIN memories m ON m.uri = e.uri WHERE m.stale = 0 ORDER BY distance ASC LIMIT ?
+  `).all(Buffer.from(queryEmbedding.buffer), limit);
+  return results.map((row) => ({
+    uri: row.uri,
+    type: row.type,
+    content: row.content,
+    similarity: 1 - row.distance,
+    verified: row.verified === 1,
+    tier: "l1"
+  }));
+}
+function keywordSearch(query, limit, db) {
+  const keywords = query.toLowerCase().split(/\s+/).filter(Boolean);
+  if (keywords.length === 0)
+    return [];
+  const conditions = keywords.map(() => "LOWER(content) LIKE ?").join(" AND ");
+  const params = keywords.map((k) => `%${k}%`);
+  const results = db.prepare(`
+    SELECT uri, content, type, verified, confidence FROM memories
+    WHERE stale = 0 AND (${conditions}) ORDER BY ref_count DESC, confidence DESC LIMIT ?
+  `).all(...params, limit);
+  return results.map((row, i) => ({
+    uri: row.uri,
+    type: row.type,
+    content: row.content,
+    similarity: 1 - i * 0.1,
+    verified: row.verified === 1,
+    tier: "l1"
+  }));
+}
+function collectEntries(dir, workspaceRoot, entries) {
+  for (const item of readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = join5(dir, item.name);
+    if (item.isDirectory())
+      collectEntries(fullPath, workspaceRoot, entries);
+    else if (item.name.endsWith(".md")) {
+      const e = parseMemoryFile(fullPath, workspaceRoot);
+      if (e)
+        entries.push(e);
+    }
+  }
+}
+function parseMemoryFile(filePath, workspaceRoot) {
+  try {
+    const raw = readFileSync3(filePath, "utf-8");
+    const parsed = matter2(raw);
+    const data = parsed.data;
+    const { l0, l1, l2 } = splitTiers(parsed.content);
+    const relPath = relative(join5(workspaceRoot, ".context"), filePath).replace(/\.md$/, "");
+    return {
+      uri: data.uri ?? relPath,
+      type: data.type ?? "convention",
+      content: parsed.content,
+      created: data.created ?? new Date().toISOString(),
+      updated: data.updated ?? new Date().toISOString(),
+      author: data.author ?? "unknown",
+      confidence: data.confidence ?? 0.5,
+      verified: data.verified ?? false,
+      stale: data.stale ?? false,
+      global: data.global ?? false,
+      affected_paths: data.affected_paths ?? [],
+      ref_count: data.ref_count ?? 0,
+      tags: data.tags ?? [],
+      l0,
+      l1,
+      l2
+    };
+  } catch {
+    return null;
+  }
+}
+function splitTiers(content) {
+  const sections = content.split(/^# (L[012])\s*$/m);
+  let l0 = "", l1 = "", l2 = "";
+  for (let i = 0;i < sections.length; i++) {
+    const s = sections[i]?.trim();
+    if (s === "L0" && sections[i + 1])
+      l0 = sections[i + 1].trim();
+    else if (s === "L1" && sections[i + 1])
+      l1 = sections[i + 1].trim();
+    else if (s === "L2" && sections[i + 1])
+      l2 = sections[i + 1].trim();
+  }
+  if (!l0 && !l1 && !l2) {
+    l0 = content.trim().split(`
+`)[0]?.slice(0, 200) ?? "";
+    l1 = content.trim();
+  }
+  return { l0, l1, l2 };
+}
+// src/memory/compile.ts
+import { writeFileSync as writeFileSync3 } from "fs";
+import { join as join6 } from "path";
+import { encoding_for_model } from "tiktoken";
+var cachedEncoder = null;
+function getEncoder() {
+  if (!cachedEncoder) {
+    try {
+      cachedEncoder = encoding_for_model("gpt-4o-mini");
+    } catch {
+      return { encode: (text) => new Uint32Array(Math.ceil(text.length / 4)) };
+    }
+  }
+  return cachedEncoder;
+}
+async function compile(workspaceRoot, config) {
+  const allEntries = loadAllEntries(workspaceRoot);
+  const recentFiles = await getRecentlyModifiedFiles(workspaceRoot, 7);
+  let tokenCount = 0;
+  const sections = [];
+  const systemPrompt = buildSystemPrompt();
+  sections.push(systemPrompt);
+  tokenCount += estimateTokens(systemPrompt);
+  const verifiedEntries = allEntries.filter((e) => e.verified && !e.stale);
+  const l0Section = buildL0Index(verifiedEntries);
+  sections.push(l0Section);
+  tokenCount += estimateTokens(l0Section);
+  const relevant = verifiedEntries.filter((e) => e.global || isRecentlyTouched(e, recentFiles) || isRecentlyCreated(e, 7)).sort((a, b) => b.ref_count - a.ref_count);
+  const includedUris = new Set;
+  for (const entry of relevant) {
+    const l1Content = formatL1Section(entry);
+    const tokens = estimateTokens(l1Content);
+    if (tokenCount + tokens > config.compile.tokenBudget)
+      break;
+    sections.push(l1Content);
+    tokenCount += tokens;
+    includedUris.add(entry.uri);
+  }
+  const l2Available = allEntries.filter((e) => !e.stale && !includedUris.has(e.uri));
+  if (l2Available.length > 0)
+    sections.push(buildL2Footer(l2Available));
+  const output = sections.join(`
+
+---
+
+`);
+  writeFileSync3(join6(workspaceRoot, ".context", "KONTEX.md"), output, "utf-8");
+}
+function buildSystemPrompt() {
+  return `## Project memory (kontex)
+
+You have access to a persistent memory store for this codebase.
+
+**On session start:** Read KONTEX.md in this workspace before answering
+any codebase questions. It contains compiled project context.
+
+**Write proactively, not constantly.** Call kontex_remember only for:
+- Architectural decisions that were committed to (not just discussed)
+- Non-obvious constraints or gotchas discovered in the code
+- Patterns established that apply across the codebase
+- Conventions confirmed by the developer
+
+Never call kontex_remember for routine edits or things already in KONTEX.md.
+
+**Correct stale memory immediately.** If KONTEX.md contains something
+outdated, call kontex_invalidate on that entry, then kontex_remember with
+the correction.
+
+**Search before answering.** For architecture and convention questions,
+call kontex_find before responding. Do not reconstruct from code what
+memory already knows.`;
+}
+function buildL0Index(entries) {
+  if (entries.length === 0)
+    return `## Memory index (L0)
+
+No memory entries yet.`;
+  const lines = entries.map((e) => `- \`${e.uri}\` \u2014 ${e.l0 || e.content.split(`
+`)[0]?.slice(0, 100)}`);
+  return `## Memory index (L0)
+
+${lines.join(`
+`)}`;
+}
+function formatL1Section(entry) {
+  return `### ${entry.uri} (${entry.type})
+
+${entry.l1 || entry.content}`;
+}
+function buildL2Footer(entries) {
+  const lines = entries.slice(0, 20).map((e) => `- \`${e.uri}\` \u2014 search "${e.l0 || e.content.split(`
+`)[0]?.slice(0, 80)}"`);
+  return `## Available detail
+
+The following entries have full detail accessible via kontex_find:
+${lines.join(`
+`)}`;
+}
+function isRecentlyTouched(entry, recentFiles) {
+  if (!entry.affected_paths.length || !recentFiles.length)
+    return false;
+  return entry.affected_paths.some((ap) => recentFiles.some((rf) => rf.startsWith(ap) || ap.startsWith(rf)));
+}
+function isRecentlyCreated(entry, days) {
+  const cutoff = new Date;
+  cutoff.setDate(cutoff.getDate() - days);
+  return new Date(entry.created) >= cutoff;
+}
+async function getRecentlyModifiedFiles(workspaceRoot, days) {
+  try {
+    const proc = Bun.spawn(["git", "log", "--since", `${days}.days.ago`, "--name-only", "--pretty=format:"], { cwd: workspaceRoot, stdout: "pipe" });
+    const output = await new Response(proc.stdout).text();
+    return [...new Set(output.split(`
+`).map((l) => l.trim()).filter(Boolean))];
+  } catch {
+    return [];
+  }
+}
+function estimateTokens(text) {
+  try {
+    return getEncoder().encode(text).length;
+  } catch {
+    return Math.ceil(text.length / 4);
+  }
+}
+// src/memory/decay.ts
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, readdirSync as readdirSync2, statSync, existsSync as existsSync5, mkdirSync as mkdirSync3 } from "fs";
+import { join as join7, basename } from "path";
+import matter3 from "gray-matter";
+async function runDecay(workspaceRoot, config) {
+  const result = { promoted: [], expired: [], archived: [], flaggedStale: [] };
+  const memoryDir = join7(workspaceRoot, ".context", "memory");
+  if (!existsSync5(memoryDir))
+    return result;
+  await promoteEntries(memoryDir, result);
+  await expireEntries(memoryDir, config.decay.unverifiedExpireDays, result);
+  await archiveSessions(memoryDir, config.decay.sessionArchiveDays, result);
+  await flagStaleEntries(memoryDir, workspaceRoot, result);
+  await enforceSessionsSizeCap(memoryDir, config.decay.maxSessionsDirKB, result);
+  return result;
+}
+async function promoteEntries(memoryDir, result) {
+  for (const filePath of collectMemoryFiles(memoryDir)) {
+    try {
+      const raw = readFileSync4(filePath, "utf-8");
+      const parsed = matter3(raw);
+      if (!parsed.data.verified && (parsed.data.ref_count ?? 0) >= 3) {
+        parsed.data.verified = true;
+        parsed.data.updated = new Date().toISOString();
+        writeFileSync4(filePath, matter3.stringify(parsed.content, parsed.data), "utf-8");
+        result.promoted.push(parsed.data.uri ?? basename(filePath));
+      }
+    } catch {}
+  }
+}
+async function expireEntries(memoryDir, expireDays, result) {
+  const cutoff = new Date;
+  cutoff.setDate(cutoff.getDate() - expireDays);
+  for (const filePath of collectMemoryFiles(memoryDir)) {
+    try {
+      const raw = readFileSync4(filePath, "utf-8");
+      const parsed = matter3(raw);
+      if (!parsed.data.verified && (parsed.data.ref_count ?? 0) === 0 && new Date(parsed.data.updated ?? parsed.data.created) < cutoff) {
+        parsed.data.stale = true;
+        parsed.data.updated = new Date().toISOString();
+        writeFileSync4(filePath, matter3.stringify(parsed.content, parsed.data), "utf-8");
+        result.expired.push(parsed.data.uri ?? basename(filePath));
+      }
+    } catch {}
+  }
+}
+async function archiveSessions(memoryDir, archiveDays, result) {
+  const sessionsDir = join7(memoryDir, "sessions");
+  const archiveDir = join7(sessionsDir, "archive");
+  if (!existsSync5(sessionsDir))
+    return;
+  if (!existsSync5(archiveDir))
+    mkdirSync3(archiveDir, { recursive: true });
+  const cutoff = new Date;
+  cutoff.setDate(cutoff.getDate() - archiveDays);
+  for (const file of readdirSync2(sessionsDir, { withFileTypes: true })) {
+    if (!file.isFile() || !file.name.endsWith(".md"))
+      continue;
+    const filePath = join7(sessionsDir, file.name);
+    try {
+      if (statSync(filePath).mtime < cutoff) {
+        writeFileSync4(join7(archiveDir, file.name), readFileSync4(filePath, "utf-8"), "utf-8");
+        writeFileSync4(filePath, `---
+archived: true
+archived_at: ${new Date().toISOString()}
+---
+Archived to archive/${file.name}
+`, "utf-8");
+        result.archived.push(file.name);
+      }
+    } catch {}
+  }
+}
+async function flagStaleEntries(memoryDir, workspaceRoot, result) {
+  for (const filePath of collectMemoryFiles(memoryDir)) {
+    try {
+      const raw = readFileSync4(filePath, "utf-8");
+      const parsed = matter3(raw);
+      if (parsed.data.stale)
+        continue;
+      const paths = parsed.data.affected_paths ?? [];
+      if (paths.length > 0 && paths.every((p) => !existsSync5(join7(workspaceRoot, p)))) {
+        parsed.data.stale = true;
+        parsed.data.updated = new Date().toISOString();
+        writeFileSync4(filePath, matter3.stringify(parsed.content, parsed.data), "utf-8");
+        result.flaggedStale.push(parsed.data.uri ?? basename(filePath));
+      }
+    } catch {}
+  }
+}
+async function enforceSessionsSizeCap(memoryDir, maxSizeKB, result) {
+  const sessionsDir = join7(memoryDir, "sessions");
+  if (!existsSync5(sessionsDir))
+    return;
+  let totalKB = getDirSize(sessionsDir) / 1024;
+  if (totalKB <= maxSizeKB)
+    return;
+  const archiveDir = join7(sessionsDir, "archive");
+  if (!existsSync5(archiveDir))
+    mkdirSync3(archiveDir, { recursive: true });
+  const files = readdirSync2(sessionsDir, { withFileTypes: true }).filter((f) => f.isFile() && f.name.endsWith(".md")).map((f) => ({ name: f.name, path: join7(sessionsDir, f.name), mtime: statSync(join7(sessionsDir, f.name)).mtime })).sort((a, b) => a.mtime.getTime() - b.mtime.getTime());
+  for (const file of files) {
+    if (totalKB <= maxSizeKB)
+      break;
+    totalKB -= statSync(file.path).size / 1024;
+    writeFileSync4(join7(archiveDir, file.name), readFileSync4(file.path, "utf-8"), "utf-8");
+    writeFileSync4(file.path, `---
+archived: true
+---
+Compressed due to size cap.
+`, "utf-8");
+    result.archived.push(file.name);
+  }
+}
+function collectMemoryFiles(dir) {
+  const files = [];
+  for (const item of readdirSync2(dir, { withFileTypes: true })) {
+    const fullPath = join7(dir, item.name);
+    if (item.isDirectory() && item.name !== "archive")
+      files.push(...collectMemoryFiles(fullPath));
+    else if (item.isFile() && item.name.endsWith(".md"))
+      files.push(fullPath);
+  }
+  return files;
+}
+function getDirSize(dir) {
+  let total = 0;
+  for (const item of readdirSync2(dir, { withFileTypes: true })) {
+    if (item.isFile())
+      total += statSync(join7(dir, item.name)).size;
+  }
+  return total;
+}
+// src/mcp/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+
+// src/mcp/tools.ts
+var TOOLS = [
+  {
+    name: "kontex_remember",
+    description: `Store a memory about this codebase.
+Call when: architectural decision made, non-obvious constraint discovered,
+pattern established, convention confirmed by developer.
+Do NOT call for: routine edits, temporary context, things already in KONTEX.md.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        content: { type: "string", description: "The memory content to store" },
+        type: { type: "string", enum: ["decision", "pattern", "gotcha", "convention", "resource"], description: "Category of memory" },
+        why_memorable: { type: "string", description: "Why this outlives the current session" },
+        confidence: { type: "number", minimum: 0, maximum: 1, description: "Confidence level (0.0 - 1.0)" },
+        affected_paths: { type: "array", items: { type: "string" }, description: "File paths this memory is relevant to" }
+      },
+      required: ["content", "type", "why_memorable", "confidence"]
+    }
+  },
+  {
+    name: "kontex_invalidate",
+    description: `Mark an existing memory as outdated.
+Call when existing memory is discovered to be wrong.
+Always follow with kontex_remember to store the correction.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        uri: { type: "string", description: "URI of the memory entry to invalidate" },
+        reason: { type: "string", description: "Why this memory is no longer valid" }
+      },
+      required: ["uri", "reason"]
+    }
+  },
+  {
+    name: "kontex_log_decision",
+    description: `Log a structured ADR. Call when the developer commits to an
+architectural approach after discussion \u2014 not for suggestions, only decisions.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        title: { type: "string", description: "Short title for the decision" },
+        context: { type: "string", description: "What problem or situation prompted this decision" },
+        decision: { type: "string", description: "What was decided" },
+        rationale: { type: "string", description: "Why this approach was chosen" },
+        alternatives: { type: "array", items: { type: "string" }, description: "Other approaches considered" },
+        consequences: { type: "string", description: "Expected consequences" }
+      },
+      required: ["title", "context", "decision", "rationale"]
+    }
+  },
+  {
+    name: "kontex_find",
+    description: `Semantic search across project memory.
+Call before answering architecture or convention questions.
+Do not guess what memory contains \u2014 search it.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Natural language search query" },
+        limit: { type: "number", description: "Maximum number of results (default: 5)" }
+      },
+      required: ["query"]
+    }
+  }
+];
+
+// src/mcp/handlers.ts
+init_write();
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync5, existsSync as existsSync6 } from "fs";
+import { join as join8 } from "path";
+import matter4 from "gray-matter";
+async function handleRemember(args, workspaceRoot) {
+  const { content, type, why_memorable, confidence, affected_paths } = args;
+  if (!content || !type || !why_memorable || confidence === undefined)
+    return errorResponse("Missing required fields");
+  const config = loadConfig(workspaceRoot);
+  const result = await writeMemory({ content, type, why_memorable, confidence, affected_paths: affected_paths ?? [] }, workspaceRoot, config);
+  if (!result.success)
+    return errorResponse(result.error ?? "Write failed");
+  await compile(workspaceRoot, config);
+  return textResponse(`Written: ${result.uri} (verified: ${result.verified})`);
+}
+async function handleInvalidate(args, workspaceRoot) {
+  const { uri, reason } = args;
+  if (!uri || !reason)
+    return errorResponse("Missing required fields: uri, reason");
+  const result = await invalidateMemory(uri, reason, workspaceRoot);
+  if (!result.success)
+    return errorResponse(result.error ?? "Invalidation failed");
+  await compile(workspaceRoot, loadConfig(workspaceRoot));
+  return textResponse(`Invalidated: ${uri}. Use kontex_remember to store the correction.`);
+}
+async function handleLogDecision(args, workspaceRoot) {
+  const adr = {
+    title: args.title,
+    context: args.context,
+    decision: args.decision,
+    rationale: args.rationale,
+    alternatives: args.alternatives,
+    consequences: args.consequences
+  };
+  if (!adr.title || !adr.context || !adr.decision || !adr.rationale)
+    return errorResponse("Missing required fields");
+  const config = loadConfig(workspaceRoot);
+  const result = await logDecision(adr, workspaceRoot, config);
+  if (!result.success)
+    return errorResponse(result.error ?? "Decision logging failed");
+  await compile(workspaceRoot, config);
+  return textResponse(`Decision logged: ${result.uri}`);
+}
+async function handleFind(args, workspaceRoot) {
+  const query = args.query;
+  const limit = args.limit ?? 5;
+  if (!query)
+    return errorResponse("Missing required field: query");
+  const results = await findMemories(query, limit, workspaceRoot);
+  if (results.length === 0)
+    return textResponse("No matching memories found.");
+  const { getDatabase: getDatabase2 } = await Promise.resolve().then(() => (init_db(), exports_db));
+  const db = getDatabase2(workspaceRoot);
+  for (const r of results) {
+    db.prepare("UPDATE memories SET ref_count = ref_count + 1 WHERE uri = ?").run(r.uri);
+    syncRefCountToFile(r.uri, workspaceRoot, db);
+  }
+  const formatted = results.map((r, i) => `${i + 1}. **${r.uri}** (${r.type}, similarity: ${r.similarity.toFixed(2)}, verified: ${r.verified})
+   ${r.content.slice(0, 300)}`).join(`
+
+`);
+  return textResponse(formatted);
+}
+function syncRefCountToFile(uri, workspaceRoot, db) {
+  try {
+    const filePath = join8(workspaceRoot, ".context", `${uri}.md`);
+    if (!existsSync6(filePath))
+      return;
+    const row = db.prepare("SELECT ref_count FROM memories WHERE uri = ?").get(uri);
+    if (!row)
+      return;
+    const raw = readFileSync5(filePath, "utf-8");
+    const parsed = matter4(raw);
+    parsed.data.ref_count = row.ref_count;
+    writeFileSync5(filePath, matter4.stringify(parsed.content, parsed.data), "utf-8");
+  } catch {}
+}
+function textResponse(text) {
+  return { content: [{ type: "text", text }] };
+}
+function errorResponse(text) {
+  return { content: [{ type: "text", text }], isError: true };
+}
+
+// src/mcp/server.ts
+async function createMCPServer(workspaceRoot) {
+  const server = new Server({ name: "kontex", version: "1.0.0" }, { capabilities: { tools: {} } });
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: [...TOOLS] }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const toolArgs = args ?? {};
+    switch (name) {
+      case "kontex_remember":
+        return handleRemember(toolArgs, workspaceRoot);
+      case "kontex_invalidate":
+        return handleInvalidate(toolArgs, workspaceRoot);
+      case "kontex_log_decision":
+        return handleLogDecision(toolArgs, workspaceRoot);
+      case "kontex_find":
+        return handleFind(toolArgs, workspaceRoot);
+      default:
+        return { content: [{ type: "text", text: `Unknown tool: ${name}` }], isError: true };
+    }
+  });
+  const transport = new StdioServerTransport;
+  await server.connect(transport);
+}
+// src/hooks/pre-commit.ts
+init_db();
+import { writeFileSync as writeFileSync6, existsSync as existsSync7 } from "fs";
+import { join as join9 } from "path";
+async function handlePreCommit(stagedFiles, workspaceRoot) {
+  const files = stagedFiles.split(/[\n\s]+/).map((f) => f.trim()).filter(Boolean);
+  if (files.length === 0)
+    return;
+  const affectedMemories = findAffectedMemories(files, workspaceRoot);
+  const queue = { staged_files: files, affected_memories: affectedMemories, commit_sha_pending: true, timestamp: new Date().toISOString() };
+  writeFileSync6(join9(workspaceRoot, ".kontex-queue.json"), JSON.stringify(queue, null, 2), "utf-8");
+  const config = loadConfig(workspaceRoot);
+  if (existsSync7(join9(workspaceRoot, ".context"))) {
+    await compile(workspaceRoot, config);
+    try {
+      Bun.spawnSync(["git", "add", ".context/KONTEX.md"], { cwd: workspaceRoot });
+    } catch {}
+  }
+}
+function findAffectedMemories(stagedFiles, workspaceRoot) {
+  try {
+    const db = getDatabase(workspaceRoot);
+    const allMemories = db.prepare("SELECT uri, affected_paths FROM memories WHERE stale = 0").all();
+    const affected = [];
+    for (const m of allMemories) {
+      const paths = JSON.parse(m.affected_paths || "[]");
+      if (paths.some((mp) => stagedFiles.some((sf) => sf.startsWith(mp) || mp.startsWith(sf))))
+        affected.push(m.uri);
+    }
+    return affected;
+  } catch {
+    return [];
+  }
+}
+// src/hooks/post-commit.ts
+import { writeFileSync as writeFileSync7, existsSync as existsSync8, unlinkSync, mkdirSync as mkdirSync4, appendFileSync as appendFileSync2 } from "fs";
+import { join as join10, dirname as dirname2 } from "path";
+import { createHash } from "crypto";
+init_write();
+async function handlePostCommit(commitSha, authorEmail, workspaceRoot) {
+  const config = loadConfig(workspaceRoot);
+  const logPath = join10(workspaceRoot, ".kontex-log", "hooks.log");
+  try {
+    logHookEvent(logPath, "POST_COMMIT_START", commitSha);
+    if (!config.hooks.postCommitExtract || config.llm.provider === "none") {
+      await compileAndCommit(workspaceRoot, config);
+      return;
+    }
+    let token = null;
+    if (config.llm.provider === "github-models") {
+      token = await getToken();
+      if (!token) {
+        await compileAndCommit(workspaceRoot, config);
+        return;
+      }
+    }
+    const diff = await getCommitDiff(commitSha, workspaceRoot);
+    if (!diff.trim())
+      return;
+    const entries = loadAllEntries(workspaceRoot);
+    const existingL0 = entries.filter((e) => e.verified && !e.stale).map((e) => `- ${e.uri}: ${e.l0}`).join(`
+`);
+    const extraction = await extractKnowledge(diff, existingL0, config, token);
+    if (extraction) {
+      for (const m of extraction.new_memories) {
+        await writeMemory({ content: m.content, type: m.type, why_memorable: m.why_memorable, confidence: m.confidence, affected_paths: m.affected_paths }, workspaceRoot, config);
+      }
+      await writeSessionFile(commitSha, authorEmail, extraction, workspaceRoot);
+      if (extraction.stale_uris.length > 0) {
+        const { invalidateMemory: invalidateMemory2 } = await Promise.resolve().then(() => (init_write(), exports_write));
+        for (const uri of extraction.stale_uris)
+          await invalidateMemory2(uri, `Flagged stale by commit ${commitSha.slice(0, 7)}`, workspaceRoot);
+      }
+    }
+    await compileAndCommit(workspaceRoot, config);
+    logHookEvent(logPath, "COMPLETE", commitSha);
+  } catch (error) {
+    logHookEvent(logPath, "ERROR", String(error));
+  } finally {
+    const queuePath = join10(workspaceRoot, ".kontex-queue.json");
+    if (existsSync8(queuePath))
+      try {
+        unlinkSync(queuePath);
+      } catch {}
+  }
+}
+async function extractKnowledge(diff, existingL0, config, token) {
+  try {
+    const { createLLMModel: createLLMModel2 } = await Promise.resolve().then(() => exports_llm);
+    const { generateText } = await import("ai");
+    const truncatedDiff = diff.slice(0, 24000);
+    const prompt = `You are analyzing a git commit to extract knowledge for a persistent project memory store.
+
+Commit diff:
+${truncatedDiff}
+
+Existing memory context (L0):
+${existingL0}
+
+Extract learnings. Return JSON only:
+{"new_memories":[{"content":"...","type":"decision|pattern|gotcha|convention","why_memorable":"...","confidence":0.0-1.0,"affected_paths":["..."]}],"stale_uris":["..."]}
+
+If nothing worth persisting, return: {"new_memories":[],"stale_uris":[]}
+Be conservative.`;
+    const model = await createLLMModel2(config, token);
+    if (!model)
+      return null;
+    const result = await generateText({ model, prompt, maxTokens: 1000, temperature: 0.1 });
+    const jsonMatch = result.text.match(/\{[\s\S]*\}/);
+    return jsonMatch ? JSON.parse(jsonMatch[0]) : null;
+  } catch {
+    return null;
+  }
+}
+async function writeSessionFile(commitSha, authorEmail, extraction, workspaceRoot) {
+  const sessionsDir = join10(workspaceRoot, ".context", "memory", "sessions");
+  if (!existsSync8(sessionsDir))
+    mkdirSync4(sessionsDir, { recursive: true });
+  const date = new Date().toISOString().slice(0, 10);
+  const authorHash = createHash("md5").update(authorEmail).digest("hex").slice(0, 8);
+  const filePath = join10(sessionsDir, `${date}-${authorHash}.md`);
+  const commitBody = `
+### Commit ${commitSha.slice(0, 7)}
+
+${extraction.new_memories.map((m) => `- **${m.type}** (${m.confidence.toFixed(2)}): ${m.content}`).join(`
+`) || "No new memories."}
+`;
+  if (existsSync8(filePath)) {
+    appendFileSync2(filePath, commitBody, "utf-8");
+  } else {
+    const header = `---
+author: ${authorEmail}
+date: ${date}
+uri: memory/sessions/${date}-${authorHash}
+type: resource
+confidence: 0.7
+verified: false
+stale: false
+global: false
+affected_paths: []
+ref_count: 0
+tags: ["session"]
+---
+
+## Session: ${date}
+`;
+    writeFileSync7(filePath, header + commitBody, "utf-8");
+  }
+}
+async function getCommitDiff(sha, workspaceRoot) {
+  try {
+    const proc = Bun.spawn(["git", "show", sha, "--stat", "--patch"], { cwd: workspaceRoot, stdout: "pipe" });
+    return await new Response(proc.stdout).text();
+  } catch {
+    return "";
+  }
+}
+async function compileAndCommit(workspaceRoot, config) {
+  if (!existsSync8(join10(workspaceRoot, ".context")))
+    return;
+  await compile(workspaceRoot, config);
+  try {
+    Bun.spawnSync(["git", "add", ".context/"], { cwd: workspaceRoot });
+    const status = Bun.spawnSync(["git", "diff", "--cached", "--quiet", ".context/"], { cwd: workspaceRoot });
+    if (status.exitCode !== 0)
+      Bun.spawnSync(["git", "commit", "--no-verify", "-m", "chore(kontex): update memory [skip ci]"], { cwd: workspaceRoot });
+  } catch {}
+}
+function logHookEvent(logPath, event, message) {
+  const logDir = dirname2(logPath);
+  if (!existsSync8(logDir))
+    mkdirSync4(logDir, { recursive: true });
+  appendFileSync2(logPath, `[${new Date().toISOString()}] ${event}: ${message}
+`, "utf-8");
+}
+// src/hooks/post-merge.ts
+import { existsSync as existsSync9 } from "fs";
+import { join as join11 } from "path";
+init_db();
+init_embeddings();
+async function handlePostMerge(workspaceRoot) {
+  if (!existsSync9(join11(workspaceRoot, ".context")))
+    return;
+  const config = loadConfig(workspaceRoot);
+  await compile(workspaceRoot, config);
+  await rebuildIndex(workspaceRoot);
+}
+async function rebuildIndex(workspaceRoot) {
+  try {
+    const db = getDatabase(workspaceRoot);
+    const entries = loadAllEntries(workspaceRoot);
+    const existing = new Set(db.prepare("SELECT uri FROM memories").all().map((r) => r.uri));
+    for (const entry of entries) {
+      if (existing.has(entry.uri))
+        continue;
+      db.prepare(`INSERT OR REPLACE INTO memories (uri, content, type, l0, l1, l2, confidence, verified, stale, global, ref_count, author, affected_paths, tags, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))`).run(entry.uri, entry.content, entry.type, entry.l0, entry.l1, entry.l2, entry.confidence, entry.verified ? 1 : 0, entry.stale ? 1 : 0, entry.global ? 1 : 0, entry.ref_count, entry.author, JSON.stringify(entry.affected_paths), JSON.stringify(entry.tags));
+      try {
+        const embedding = await embed(entry.content);
+        db.prepare("INSERT OR REPLACE INTO memory_embeddings (uri, embedding) VALUES (?, ?)").run(entry.uri, Buffer.from(embedding.buffer));
+      } catch {}
+    }
+  } catch {}
+}
+// src/init.ts
+import { existsSync as existsSync11, readFileSync as readFileSync7, writeFileSync as writeFileSync8, mkdirSync as mkdirSync5, appendFileSync as appendFileSync3, chmodSync } from "fs";
+import { join as join13, resolve } from "path";
+import { homedir as homedir2 } from "os";
+init_embeddings();
+
+// src/memory/extract.ts
+init_write();
+import { readFileSync as readFileSync6, existsSync as existsSync10 } from "fs";
+import { join as join12 } from "path";
+async function runInitAI(workspaceRoot) {
+  const config = loadConfig(workspaceRoot);
+  if (config.llm.provider === "none")
+    return;
+  let token = null;
+  if (config.llm.provider === "github-models") {
+    token = await getToken();
+    if (!token) {
+      console.log("\u26A0 Missing GitHub token. Run `kontex login` first to use --ai.");
+      return;
+    }
+  }
+  console.log("  Analyzing repository structure...");
+  const tree = await generateProjectTree(workspaceRoot);
+  console.log("  Identifying core files...");
+  const hotFiles = await getHotFiles(workspaceRoot);
+  let filesContext = "";
+  for (const file of hotFiles) {
+    const fullPath = join12(workspaceRoot, file);
+    if (existsSync10(fullPath)) {
+      try {
+        const content = readFileSync6(fullPath, "utf-8");
+        filesContext += `
+--- FILE: ${file} ---
+${content.slice(0, 3000)}
+`;
+      } catch {}
+    }
+  }
+  console.log("  Extracting team conventions and practices...");
+  try {
+    const { generateText } = await import("ai");
+    const prompt = `You are an expert software architect. Analyze the provided directory structure and the contents of the most frequently modified files in this codebase.
+Identify the prevailing, undocumented architectural conventions and patterns used by this team. Look for repeated structural choices, layering principles, and standard practices that a new developer would need to mimic to write consistent code in this repository.
+Do NOT summarize what the app does. ONLY extract actionable engineering conventions.
+Return JSON only:
+{"new_memories":[{"content":"...","type":"pattern","why_memorable":"...","confidence":0.8,"affected_paths":["..."]}]}
+
+Directory Tree:
+${tree}
+
+Hot Files Context:
+${filesContext}`;
+    const { createLLMModel: createLLMModel2 } = await Promise.resolve().then(() => exports_llm);
+    const model = await createLLMModel2(config, token);
+    if (!model)
+      return;
+    const result = await generateText({ model, prompt, maxTokens: 2000, temperature: 0.1 });
+    const jsonMatch = result.text.match(/\{[\s\S]*\}/);
+    if (jsonMatch) {
+      const parsed = JSON.parse(jsonMatch[0]);
+      let writtenCount = 0;
+      for (const m of parsed.new_memories || []) {
+        const type = ["decision", "pattern", "gotcha", "convention"].includes(m.type) ? m.type : "convention";
+        const r = await writeMemory({
+          content: m.content,
+          type,
+          why_memorable: m.why_memorable || "Extracted from codebase initialization",
+          confidence: Math.min(m.confidence || 0.8, 0.84),
+          affected_paths: m.affected_paths || []
+        }, workspaceRoot, config);
+        if (r.success)
+          writtenCount++;
+      }
+      console.log(`\u2713 Extracted and saved ${writtenCount} architectural conventions to memory.`);
+    } else {
+      console.log("\u26A0 AI extraction returned no verifiable conventions.");
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.log(`\u26A0 AI extraction failed: ${message}`);
+  }
+}
+async function generateProjectTree(workspaceRoot) {
+  try {
+    const proc = Bun.spawn(["find", ".", "-not", "-path", "*/.git/*", "-not", "-path", "*/node_modules/*", "-not", "-path", "*/dist/*", "-not", "-path", "*/.context/*"], { cwd: workspaceRoot, stdout: "pipe" });
+    const text = await new Response(proc.stdout).text();
+    return text.split(`
+`).sort().slice(0, 100).join(`
+`);
+  } catch {
+    return "Tree unavailable";
+  }
+}
+async function getHotFiles(workspaceRoot) {
+  try {
+    const proc = Bun.spawn(["bash", "-c", "git log --name-only --pretty=format: | grep -v '^$' | grep -v 'package.json' | grep -v 'bun.lockb' | grep -v 'README' | sort | uniq -c | sort -nr | head -10 | awk '{print $2}'"], { cwd: workspaceRoot, stdout: "pipe" });
+    const text = await new Response(proc.stdout).text();
+    return text.split(`
+`).map((s) => s.trim()).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+// src/init.ts
+async function initProject(workspaceRoot, options = {}) {
+  const absRoot = resolve(workspaceRoot);
+  console.log(`kontex init \u2014 setting up project memory
+`);
+  if (!await isAuthenticated()) {
+    try {
+      await login();
+    } catch {
+      console.log("\u26A0 Login skipped \u2014 run `kontex login` later.\n");
+    }
+  } else {
+    console.log(`\u2713 GitHub auth: authenticated
+`);
+  }
+  const stack = scanProject(absRoot);
+  console.log(`\u2713 Detected: ${stack}`);
+  createContextScaffold(absRoot, stack, options.force);
+  const configPath = join13(absRoot, "kontex.config.json");
+  if (!existsSync11(configPath) || options.force) {
+    writeConfig(absRoot, DEFAULT_CONFIG);
+    console.log("\u2713 Created kontex.config.json");
+  } else
+    console.log("\u2713 kontex.config.json exists (skipped)");
+  if (!options.noHooks)
+    installGitHooks(absRoot);
+  addPrepareScript(absRoot);
+  console.log("  Downloading embedding model (first time only)...");
+  try {
+    await initEmbeddingModel();
+    console.log("\u2713 Embedding model ready");
+  } catch {
+    console.log("\u26A0 Embedding model deferred");
+  }
+  if (options.ai) {
+    await runInitAI(absRoot);
+  }
+  await compile(absRoot, loadConfig(absRoot));
+  console.log("\u2713 KONTEX.md compiled");
+  registerInAITools(absRoot);
+  injectAgentInstructions(absRoot);
+  updateGitignore(absRoot);
+  console.log(`
+\u2713 kontex initialized. Memory is active.
+`);
+}
+function scanProject(root) {
+  if (existsSync11(join13(root, "package.json"))) {
+    try {
+      const pkg = JSON.parse(readFileSync7(join13(root, "package.json"), "utf-8"));
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      if (deps?.next)
+        return "Next.js";
+      if (deps?.react)
+        return "React";
+      if (deps?.vue)
+        return "Vue";
+      if (deps?.express)
+        return "Express";
+      return "Node.js/Bun";
+    } catch {
+      return "Node.js/Bun";
+    }
+  }
+  if (existsSync11(join13(root, "pyproject.toml")))
+    return "Python";
+  if (existsSync11(join13(root, "go.mod")))
+    return "Go";
+  return "Unknown project";
+}
+function createContextScaffold(root, stack, force) {
+  if (existsSync11(join13(root, ".context")) && !force) {
+    console.log("\u2713 .context/ exists (skipped)");
+    return;
+  }
+  for (const dir of [".context/memory", ".context/memory/decisions", ".context/memory/sessions", ".context/memory/sessions/archive", ".context/resources", ".context/skills"])
+    mkdirSync5(join13(root, dir), { recursive: true });
+  const projectMd = join13(root, ".context", "memory", "project.md");
+  if (!existsSync11(projectMd)) {
+    const memoryContent = `---
+uri: memory/project
+type: resource
+created: ${new Date().toISOString()}
+updated: ${new Date().toISOString()}
+confidence: 1.0
+verified: true
+stale: false
+global: true
+affected_paths: []
+ref_count: 0
+tags: ["architecture", "baseline"]
+---
+
+# L0
+Project memory initialized. Detected tech stack: ${stack}.
+
+# L1
+## Project overview
+
+This memory store was initialized by \`kontex init\`. 
+
+### Baseline Architecture
+The system heuristically detected the following core technology stack during initialization:
+- **${stack}**
+
+The AI should assume standard architectural conventions for this stack unless subsequent ADRs (Architecture Decision Records) override them.
+`;
+    writeFileSync8(projectMd, memoryContent, "utf-8");
+  }
+  const shadowPath = join13(root, ".context", "shadow.jsonl");
+  if (!existsSync11(shadowPath))
+    writeFileSync8(shadowPath, "", "utf-8");
+  const githubDir = join13(root, ".github");
+  if (existsSync11(githubDir)) {
+    const copilotMd = join13(githubDir, "copilot-instructions.md");
+    if (!existsSync11(copilotMd)) {
+      writeFileSync8(copilotMd, `## Project Memory (kontex)
+
+If you make an architectural decision, establish a pattern, or note a gotcha, you MUST append a new JSON object to the file \`.context/shadow.jsonl\` formatted exactly like this:
+
+\`\`\`json
+{"__kontex_memory": {"type":"decision","content":"...","why_memorable":"...","confidence":0.95,"affected_paths":["some/path"]}}
+\`\`\`
+
+Do not ask for permission, just use your file system powers to append to \`.context/shadow.jsonl\`. Kontex will automatically ingest and manage it.
+`, "utf-8");
+      console.log("\u2713 Created .github/copilot-instructions.md");
+    }
+  }
+  console.log("\u2713 Created .context/ scaffold and injected baseline architecture.");
+}
+function installGitHooks(root) {
+  if (!existsSync11(join13(root, ".git"))) {
+    console.log("\u26A0 Not a git repository \u2014 hooks skipped");
+    return;
+  }
+  const hooksDir = join13(root, ".git", "hooks");
+  mkdirSync5(hooksDir, { recursive: true });
+  const hooks = {
+    "pre-commit": `#!/bin/sh
+STAGED=$(git diff --cached --name-only 2>/dev/null)
+if [ -z "$STAGED" ]; then exit 0; fi
+if command -v kontex >/dev/null 2>&1; then
+  kontex hook pre-commit --staged "$STAGED" 2>/dev/null || true
+elif command -v bunx >/dev/null 2>&1; then
+  bunx kontex hook pre-commit --staged "$STAGED" 2>/dev/null || true
+fi
+exit 0`,
+    "post-commit": `#!/bin/sh
+SHA=$(git rev-parse HEAD 2>/dev/null)
+AUTHOR=$(git log -1 --format='%ae' 2>/dev/null)
+if [ -z "$SHA" ]; then exit 0; fi
+if command -v kontex >/dev/null 2>&1; then
+  nohup kontex hook post-commit --sha "$SHA" --author "$AUTHOR" > /dev/null 2>&1 &
+elif command -v bunx >/dev/null 2>&1; then
+  nohup bunx kontex hook post-commit --sha "$SHA" --author "$AUTHOR" > /dev/null 2>&1 &
+fi
+exit 0`,
+    "post-merge": `#!/bin/sh
+if command -v kontex >/dev/null 2>&1; then
+  nohup kontex hook post-merge > /dev/null 2>&1 &
+elif command -v bunx >/dev/null 2>&1; then
+  nohup bunx kontex hook post-merge > /dev/null 2>&1 &
+fi
+exit 0`
+  };
+  for (const [name, content] of Object.entries(hooks)) {
+    const hookPath = join13(hooksDir, name);
+    writeFileSync8(hookPath, content + `
+`, "utf-8");
+    chmodSync(hookPath, 493);
+  }
+  console.log("\u2713 Installed git hooks");
+}
+function addPrepareScript(root) {
+  const pkgPath = join13(root, "package.json");
+  if (!existsSync11(pkgPath))
+    return;
+  try {
+    const pkg = JSON.parse(readFileSync7(pkgPath, "utf-8"));
+    if (!pkg.scripts)
+      pkg.scripts = {};
+    if (!pkg.scripts.prepare?.includes("kontex")) {
+      const existing = pkg.scripts.prepare ?? "";
+      pkg.scripts.prepare = existing ? `${existing} && kontex hooks install` : "kontex hooks install";
+      writeFileSync8(pkgPath, JSON.stringify(pkg, null, 2) + `
+`, "utf-8");
+      console.log("\u2713 Added prepare script");
+    }
+  } catch {}
+}
+function registerInAITools(root) {
+  const home = homedir2();
+  const entry = { command: "bunx", args: ["kontex", "mcp"], env: { KONTEX_WORKSPACE: root } };
+  const tools = [
+    { name: "Claude Code", configPath: join13(home, ".claude", "claude_desktop_config.json"), key: "mcpServers" },
+    { name: "Cursor", configPath: join13(root, ".cursor", "mcp.json"), key: "mcpServers" },
+    { name: "Windsurf", configPath: join13(home, ".codeium", "windsurf", "mcp_config.json"), key: "mcpServers" },
+    { name: "Zed", configPath: join13(home, ".config", "zed", "settings.json"), key: "mcpServers" }
+  ];
+  for (const tool of tools) {
+    try {
+      let config = {};
+      if (existsSync11(tool.configPath))
+        config = JSON.parse(readFileSync7(tool.configPath, "utf-8"));
+      const servers = config[tool.key] ?? {};
+      if (!servers.kontex) {
+        servers.kontex = entry;
+        config[tool.key] = servers;
+        mkdirSync5(join13(tool.configPath, ".."), { recursive: true });
+        writeFileSync8(tool.configPath, JSON.stringify(config, null, 2) + `
+`, "utf-8");
+        console.log(`\u2713 Registered in ${tool.name}`);
+      }
+    } catch {}
+  }
+}
+function injectAgentInstructions(root) {
+  const instruction = `
+# Do not remove this block! It ensures the AI reads your project memory.
+Always read \`.context/KONTEX.md\` at the start of every session. It contains the compiled project memory, conventions, and architectural decisions.
+`;
+  const targets = ["AGENTS.md", "CLAUDE.md", ".cursorrules"];
+  let injectedCount = 0;
+  for (const target of targets) {
+    const targetPath = join13(root, target);
+    if (existsSync11(targetPath)) {
+      const content = readFileSync7(targetPath, "utf-8");
+      if (!content.includes("KONTEX.md")) {
+        appendFileSync3(targetPath, instruction, "utf-8");
+        injectedCount++;
+      }
+    } else if (target === "AGENTS.md") {
+      writeFileSync8(targetPath, instruction.trimStart(), "utf-8");
+      injectedCount++;
+    }
+  }
+  if (injectedCount > 0) {
+    console.log("\u2713 Injected KONTEX.md pointers into AI agent rules");
+  }
+}
+function updateGitignore(root) {
+  const gitignorePath = join13(root, ".gitignore");
+  const content = existsSync11(gitignorePath) ? readFileSync7(gitignorePath, "utf-8") : "";
+  const missing = [".kontex-index/", ".kontex-log/", ".kontex-queue.json"].filter((e) => !content.includes(e));
+  if (missing.length > 0) {
+    appendFileSync3(gitignorePath, `
+# kontex (local)
+` + missing.join(`
+`) + `
+`, "utf-8");
+    console.log("\u2713 Updated .gitignore");
+  }
+}
+// src/hook-templates.ts
+var HOOK_TEMPLATES = {
+  "pre-commit": [
+    "#!/bin/sh",
+    "# kontex pre-commit hook \u2014 reads staged files, writes queue, runs compile.",
+    "# Never blocks the commit.",
+    "STAGED=$(git diff --cached --name-only 2>/dev/null)",
+    'if [ -z "$STAGED" ]; then exit 0; fi',
+    "if command -v bunx >/dev/null 2>&1; then",
+    '  bunx kontex hook pre-commit --staged "$STAGED" 2>/dev/null || true',
+    "elif command -v kontex >/dev/null 2>&1; then",
+    '  kontex hook pre-commit --staged "$STAGED" 2>/dev/null || true',
+    "fi",
+    "exit 0"
+  ].join(`
+`),
+  "post-commit": [
+    "#!/bin/sh",
+    "# kontex post-commit hook \u2014 spawns background LLM extraction.",
+    "SHA=$(git rev-parse HEAD 2>/dev/null)",
+    "AUTHOR=$(git log -1 --format='%ae' 2>/dev/null)",
+    'if [ -z "$SHA" ]; then exit 0; fi',
+    "if command -v bunx >/dev/null 2>&1; then",
+    '  nohup bunx kontex hook post-commit --sha "$SHA" --author "$AUTHOR" > /dev/null 2>&1 &',
+    "elif command -v kontex >/dev/null 2>&1; then",
+    '  nohup kontex hook post-commit --sha "$SHA" --author "$AUTHOR" > /dev/null 2>&1 &',
+    "fi",
+    "exit 0"
+  ].join(`
+`),
+  "post-merge": [
+    "#!/bin/sh",
+    "# kontex post-merge hook \u2014 recompiles KONTEX.md after pull/merge.",
+    "if command -v bunx >/dev/null 2>&1; then",
+    "  nohup bunx kontex hook post-merge > /dev/null 2>&1 &",
+    "elif command -v kontex >/dev/null 2>&1; then",
+    "  nohup kontex hook post-merge > /dev/null 2>&1 &",
+    "fi",
+    "exit 0"
+  ].join(`
+`)
+};
+export {
+  writeMemory,
+  writeConfig,
+  scanForSecrets,
+  runDecay,
+  logout,
+  login,
+  logDecision,
+  loadEntry,
+  loadConfig,
+  loadAllEntries,
+  isAuthenticated,
+  invalidateMemory,
+  initProject,
+  initEmbeddingModel,
+  handlePreCommit,
+  handlePostMerge,
+  handlePostCommit,
+  getToken,
+  getDatabase,
+  findMemories,
+  embed,
+  createMCPServer,
+  compile,
+  closeDatabase,
+  HOOK_TEMPLATES,
+  DEFAULT_CONFIG
+};