@ulpi/cli 0.1.0

package/dist/chunk-6JCMYYBT.js

@@ -0,0 +1,1546 @@
+import {
+  createEmbedder
+} from "./chunk-DBMUNBNB.js";
+import {
+  readEvents
+} from "./chunk-YM2HV4IA.js";
+import {
+  ClassificationResultSchema,
+  MemoryConfigSchema
+} from "./chunk-74WVVWJ4.js";
+import {
+  getMemoryBranch,
+  memoryConfigFile,
+  memoryEntriesDir,
+  memoryHistoryDir,
+  memoryLanceDir,
+  memoryStatsFile,
+  memoryWatermarksDir,
+  projectMemoryDir
+} from "./chunk-7LXY5UVC.js";
+
+// ../../packages/memory-engine/dist/index.js
+import * as fs from "fs";
+import * as path from "path";
+import * as fs2 from "fs";
+import * as path2 from "path";
+import { createHash } from "crypto";
+import { connect } from "@lancedb/lancedb";
+import * as fs3 from "fs";
+import * as path3 from "path";
+import { execFileSync, spawn } from "child_process";
+import * as fs4 from "fs";
+import * as os from "os";
+import * as path4 from "path";
+import * as fs5 from "fs";
+import * as os2 from "os";
+import * as path5 from "path";
+import { createHash as createHash2 } from "crypto";
+import * as fs7 from "fs";
+import * as path7 from "path";
+import * as fs6 from "fs";
+import * as path6 from "path";
+import * as fs8 from "fs";
+import * as path8 from "path";
+import { execFileSync as execFileSync2 } from "child_process";
+import * as fs9 from "fs";
+import * as os3 from "os";
+import * as path9 from "path";
+var DEFAULT_MEMORY_CONFIG = MemoryConfigSchema.parse({});
+function loadMemoryConfig(projectDir) {
+  const configPath = memoryConfigFile(projectDir);
+  if (!fs.existsSync(configPath)) {
+    return DEFAULT_MEMORY_CONFIG;
+  }
+  try {
+    const raw = fs.readFileSync(configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return MemoryConfigSchema.parse(parsed);
+  } catch {
+    return DEFAULT_MEMORY_CONFIG;
+  }
+}
+function saveMemoryConfig(projectDir, config) {
+  const configPath = memoryConfigFile(projectDir);
+  const dir = path.dirname(configPath);
+  fs.mkdirSync(dir, { recursive: true });
+  const tmpPath = configPath + ".tmp";
+  fs.writeFileSync(tmpPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  fs.renameSync(tmpPath, configPath);
+}
+function isMemoryEnabled(projectDir) {
+  const config = loadMemoryConfig(projectDir);
+  return config.enabled;
+}
+function generateMemoryId(type, content) {
+  return createHash("sha256").update(`${type}:${content}`).digest("hex").slice(0, 32);
+}
+function walkDirSize(dir) {
+  if (!fs2.existsSync(dir)) return 0;
+  let total = 0;
+  const entries = fs2.readdirSync(dir);
+  for (const entry of entries) {
+    const fullPath = path2.join(dir, entry);
+    try {
+      const stat = fs2.statSync(fullPath);
+      if (stat.isDirectory()) {
+        total += walkDirSize(fullPath);
+      } else {
+        total += stat.size;
+      }
+    } catch {
+    }
+  }
+  return total;
+}
+var MemoryVectorStore = class {
+  db = null;
+  table = null;
+  indexDir;
+  constructor(projectDir) {
+    this.indexDir = memoryLanceDir(projectDir);
+  }
+  async initialize() {
+    fs2.mkdirSync(this.indexDir, { recursive: true });
+    this.db = await connect(this.indexDir);
+    const tables = await this.db.tableNames();
+    if (tables.includes("memories")) {
+      this.table = await this.db.openTable("memories");
+    }
+  }
+  async upsertItems(items) {
+    if (items.length === 0) return;
+    const records = items.map((item) => ({
+      id: item.id,
+      vector: item.vector,
+      type: item.metadata.type,
+      importance: item.metadata.importance,
+      snippet: item.metadata.snippet,
+      createdAt: item.metadata.createdAt,
+      tags: item.metadata.tags
+    }));
+    if (!this.table) {
+      this.table = await this.db.createTable("memories", records);
+    } else {
+      await this.table.mergeInsert("id").whenMatchedUpdateAll().whenNotMatchedInsertAll().execute(records);
+    }
+  }
+  async removeItems(ids) {
+    if (!this.table || ids.length === 0) return;
+    const quoted = ids.map((id) => `'${id.replace(/'/g, "''")}'`).join(", ");
+    await this.table.delete(`id IN (${quoted})`);
+  }
+  async query(vector, topK = 10) {
+    if (!this.table) return [];
+    const results = await this.table.vectorSearch(vector).distanceType("cosine").limit(topK).toArray();
+    return results.map((r) => ({
+      id: r.id,
+      type: r.type,
+      score: 1 - (r._distance ?? 0),
+      snippet: r.snippet,
+      importance: r.importance
+    }));
+  }
+  async getItemCount() {
+    if (!this.table) return 0;
+    return this.table.countRows();
+  }
+  getIndexSizeBytes() {
+    return walkDirSize(this.indexDir);
+  }
+};
+function saveEntry(projectDir, entry) {
+  const dir = memoryEntriesDir(projectDir);
+  fs2.mkdirSync(dir, { recursive: true });
+  const filePath = path2.join(dir, `${entry.id}.json`);
+  const tmpPath = filePath + ".tmp";
+  fs2.writeFileSync(tmpPath, JSON.stringify(entry, null, 2) + "\n", "utf-8");
+  fs2.renameSync(tmpPath, filePath);
+}
+function loadEntry(projectDir, id) {
+  const filePath = path2.join(memoryEntriesDir(projectDir), `${id}.json`);
+  if (!fs2.existsSync(filePath)) return null;
+  try {
+    return JSON.parse(fs2.readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function removeEntry(projectDir, id) {
+  const filePath = path2.join(memoryEntriesDir(projectDir), `${id}.json`);
+  try {
+    fs2.unlinkSync(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function listEntries(projectDir) {
+  const dir = memoryEntriesDir(projectDir);
+  if (!fs2.existsSync(dir)) return [];
+  const entries = [];
+  const files = fs2.readdirSync(dir).filter((f) => f.endsWith(".json"));
+  for (const file of files) {
+    try {
+      const raw = fs2.readFileSync(path2.join(dir, file), "utf-8");
+      entries.push(JSON.parse(raw));
+    } catch {
+    }
+  }
+  return entries;
+}
+function updateEntry(projectDir, id, updates) {
+  const entry = loadEntry(projectDir, id);
+  if (!entry) return null;
+  const updated = { ...entry, ...updates, id: entry.id };
+  saveEntry(projectDir, updated);
+  return updated;
+}
+var DEFAULT_PATTERNS = [
+  // API keys
+  /(?:api[_-]?key|apikey|secret[_-]?key)\s*[:=]\s*["']?[A-Za-z0-9_\-]{20,}["']?/gi,
+  // Bearer tokens
+  /Bearer\s+[A-Za-z0-9_\-.]{20,}/g,
+  // AWS keys
+  /AKIA[A-Z0-9]{16}/g,
+  // Generic secrets in env format
+  /(?:PASSWORD|SECRET|TOKEN|PRIVATE_KEY)\s*=\s*\S+/gi,
+  // Base64 encoded long values that look like secrets
+  /(?:eyJ[A-Za-z0-9_-]{50,})/g
+];
+function redactContent(text, userPatterns = []) {
+  let result = text;
+  for (const pattern of DEFAULT_PATTERNS) {
+    result = result.replace(pattern, "[REDACTED]");
+  }
+  for (const patternStr of userPatterns) {
+    try {
+      const pattern = new RegExp(patternStr, "gi");
+      result = result.replace(pattern, "[REDACTED]");
+    } catch {
+    }
+  }
+  return result;
+}
+var MAX_TRANSCRIPT_SIZE = 10485760;
+function sessionCaptureDir(projectDir, sessionId) {
+  return path3.join(memoryHistoryDir(projectDir), `sess_${sessionId}`);
+}
+function appendMemoryEvent(sessionId, event, projectDir) {
+  const dir = sessionCaptureDir(projectDir, sessionId);
+  fs3.mkdirSync(dir, { recursive: true });
+  const logPath = path3.join(dir, "events.jsonl");
+  fs3.appendFileSync(logPath, JSON.stringify(event) + "\n", "utf-8");
+}
+function toClassificationEvent(ev) {
+  return {
+    ts: ev.ts,
+    event: ev.event,
+    hookEvent: ev.hookEvent,
+    toolName: ev.toolName,
+    filePath: ev.filePath,
+    command: ev.command,
+    message: ev.message
+  };
+}
+function finalizeCapture(sessionId, state, projectDir) {
+  const config = loadMemoryConfig(projectDir);
+  const dir = sessionCaptureDir(projectDir, sessionId);
+  fs3.mkdirSync(dir, { recursive: true });
+  const redactPatterns = config.redactPatterns;
+  if (config.captureMode === "end_of_session") {
+    bulkCaptureFromSessionLog(sessionId, projectDir, redactPatterns);
+  }
+  let transcriptCaptured = false;
+  if (state.transcriptPath) {
+    transcriptCaptured = copyTranscript(
+      state.transcriptPath,
+      path3.join(dir, "transcript.jsonl"),
+      redactPatterns
+    );
+  }
+  const meta = {
+    sessionId,
+    projectDir,
+    startedAt: state.startedAt,
+    endedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    branch: state.branch,
+    sessionName: state.sessionName,
+    filesRead: state.filesRead.length,
+    filesWritten: state.filesWritten.length,
+    commandsRun: state.commandsRun.length,
+    transcriptCaptured,
+    capturedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const metaPath = path3.join(dir, "meta.json");
+  fs3.writeFileSync(metaPath, JSON.stringify(meta, null, 2) + "\n", "utf-8");
+}
+function bulkCaptureFromSessionLog(sessionId, projectDir, redactPatterns) {
+  const events = readEvents(sessionId, projectDir);
+  if (events.length === 0) return;
+  const dir = sessionCaptureDir(projectDir, sessionId);
+  const logPath = path3.join(dir, "events.jsonl");
+  const lines = events.map((ev) => {
+    const ce = toClassificationEvent(ev);
+    if (ce.command && redactPatterns.length > 0) {
+      ce.command = redactContent(ce.command, redactPatterns);
+    }
+    if (ce.message && redactPatterns.length > 0) {
+      ce.message = redactContent(ce.message, redactPatterns);
+    }
+    return JSON.stringify(ce);
+  });
+  fs3.writeFileSync(logPath, lines.join("\n") + "\n", "utf-8");
+}
+function copyTranscript(sourcePath, destPath, redactPatterns) {
+  try {
+    const stat = fs3.statSync(sourcePath);
+    if (stat.size > MAX_TRANSCRIPT_SIZE) {
+      const fd = fs3.openSync(sourcePath, "r");
+      const buffer = Buffer.alloc(MAX_TRANSCRIPT_SIZE);
+      fs3.readSync(fd, buffer, 0, MAX_TRANSCRIPT_SIZE, 0);
+      fs3.closeSync(fd);
+      let content = buffer.toString("utf-8");
+      if (redactPatterns.length > 0) {
+        content = redactContent(content, redactPatterns);
+      }
+      fs3.writeFileSync(destPath, content, "utf-8");
+    } else {
+      let content = fs3.readFileSync(sourcePath, "utf-8");
+      if (redactPatterns.length > 0) {
+        content = redactContent(content, redactPatterns);
+      }
+      fs3.writeFileSync(destPath, content, "utf-8");
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isSessionCaptured(projectDir, sessionId) {
+  const metaPath = path3.join(sessionCaptureDir(projectDir, sessionId), "meta.json");
+  return fs3.existsSync(metaPath);
+}
+function listCapturedSessions(projectDir) {
+  const dir = memoryHistoryDir(projectDir);
+  if (!fs3.existsSync(dir)) return [];
+  const sessions = [];
+  const dirs = fs3.readdirSync(dir).filter((d) => d.startsWith("sess_"));
+  for (const d of dirs) {
+    const metaPath = path3.join(dir, d, "meta.json");
+    try {
+      const raw = fs3.readFileSync(metaPath, "utf-8");
+      sessions.push(JSON.parse(raw));
+    } catch {
+    }
+  }
+  return sessions.sort((a, b) => a.capturedAt.localeCompare(b.capturedAt));
+}
+function readCapturedEvents(projectDir, sessionId) {
+  const logPath = path3.join(sessionCaptureDir(projectDir, sessionId), "events.jsonl");
+  try {
+    const raw = fs3.readFileSync(logPath, "utf-8");
+    const events = [];
+    for (const line of raw.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        events.push(JSON.parse(trimmed));
+      } catch {
+      }
+    }
+    return events;
+  } catch {
+    return [];
+  }
+}
+function readCapturedTranscript(projectDir, sessionId, maxChars = 1e4) {
+  const transcriptPath = path3.join(
+    sessionCaptureDir(projectDir, sessionId),
+    "transcript.jsonl"
+  );
+  try {
+    const content = fs3.readFileSync(transcriptPath, "utf-8");
+    return content.length > maxChars ? content.slice(0, maxChars) : content;
+  } catch {
+    return null;
+  }
+}
+function resolveClaudePath() {
+  try {
+    const result = execFileSync("which", ["claude"], { stdio: "pipe", timeout: 3e3 }).toString().trim();
+    if (result) return result;
+  } catch {
+  }
+  const home = os.homedir();
+  const candidates = [
+    path4.join(home, ".local", "bin", "claude"),
+    path4.join(home, ".claude", "bin", "claude"),
+    "/usr/local/bin/claude"
+  ];
+  for (const p of candidates) {
+    try {
+      if (fs4.existsSync(p)) return p;
+    } catch {
+    }
+  }
+  return null;
+}
+var cachedClaudePath;
+function getClaudePath() {
+  if (cachedClaudePath === void 0) {
+    cachedClaudePath = resolveClaudePath();
+  }
+  return cachedClaudePath;
+}
+var TRIVIAL_COMMANDS = /* @__PURE__ */ new Set([
+  "ls",
+  "pwd",
+  "echo",
+  "cat",
+  "head",
+  "tail",
+  "which",
+  "cd",
+  "whoami",
+  "date",
+  "wc"
+]);
+function filterSignificantEvents(events) {
+  return events.filter((ev) => {
+    if (ev.event === "tool_blocked" || ev.event === "permission_denied" || ev.event === "postcondition_failed") {
+      return true;
+    }
+    if (ev.event === "tool_used" && ev.toolName === "Read") {
+      return false;
+    }
+    if (ev.toolName === "Bash" && ev.command) {
+      const cmd = ev.command.trim().split(/\s+/)[0];
+      if (TRIVIAL_COMMANDS.has(cmd)) return false;
+    }
+    return true;
+  });
+}
+function buildClassificationWindows(sessionId, projectDir, events, config) {
+  if (events.length === 0) return [];
+  const windowSize = config.classifier.windowSize;
+  const step = windowSize;
+  const windows = [];
+  for (let i = 0; i < events.length; i += step) {
+    const windowEvents = events.slice(i, i + windowSize);
+    if (windowEvents.length === 0) break;
+    let transcriptExcerpt;
+    if (i === 0 && config.classifier.includeTranscript) {
+      transcriptExcerpt = readCapturedTranscript(
+        projectDir,
+        sessionId,
+        config.classifier.maxTranscriptChars
+      ) ?? void 0;
+    }
+    windows.push({
+      sessionId,
+      projectDir,
+      events: windowEvents,
+      transcriptExcerpt,
+      startTs: windowEvents[0].ts,
+      endTs: windowEvents[windowEvents.length - 1].ts
+    });
+  }
+  return windows;
+}
+var CLASSIFIER_SCHEMA = JSON.stringify({
+  type: "object",
+  properties: {
+    memories: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          type: {
+            type: "string",
+            enum: ["DECISION", "PATTERN", "BUG_ROOT_CAUSE", "PREFERENCE", "CONSTRAINT", "CONTEXT", "LESSON", "RELATIONSHIP"]
+          },
+          summary: { type: "string", description: "Concise memory text (max 2000 chars)" },
+          detail: { type: "string", description: "Additional context (optional)" },
+          importance: { type: "string", enum: ["critical", "high", "medium", "low"] },
+          tags: { type: "array", items: { type: "string" }, description: "Categorization tags" },
+          relatedFiles: { type: "array", items: { type: "string" }, description: "Related file paths" }
+        },
+        required: ["type", "summary", "importance"]
+      }
+    }
+  },
+  required: ["memories"]
+});
+function buildPromptPreamble(maxMemories) {
+  return [
+    "You are extracting structured memories from an AI coding agent's session.",
+    'A "memory" is knowledge worth retaining for future sessions.',
+    "",
+    `Extract 0-${maxMemories} memories from the following session events.`,
+    "Only extract genuinely useful, specific information. Skip generic observations.",
+    "",
+    "Memory types:",
+    "- DECISION: Architecture/design decisions with rationale",
+    "- PATTERN: Code patterns adopted or enforced in this project",
+    "- BUG_ROOT_CAUSE: Root causes of bugs (not symptoms)",
+    "- PREFERENCE: User preferences for code style, tools, workflow",
+    "- CONSTRAINT: Project constraints (performance budgets, compatibility)",
+    "- CONTEXT: Domain knowledge, terminology, relationships between concepts",
+    "- LESSON: Lessons learned from mistakes or difficulties",
+    "- RELATIONSHIP: How components/modules/files relate to each other",
+    ""
+  ];
+}
+function formatEventsSection(events) {
+  const lines = ["## Session Events"];
+  for (const ev of events) {
+    const parts = [ev.ts, ev.event, ev.hookEvent];
+    if (ev.toolName) parts.push(`tool=${ev.toolName}`);
+    if (ev.filePath) parts.push(`file=${ev.filePath}`);
+    if (ev.command) parts.push(`cmd=${ev.command.slice(0, 200)}`);
+    if (ev.message) parts.push(`msg=${ev.message.slice(0, 200)}`);
+    lines.push(parts.join(" | "));
+  }
+  lines.push("");
+  return lines;
+}
+function buildPromptGuidelines() {
+  return [
+    "## Guidelines",
+    '- Be specific: "User prefers const over let" not "User has coding preferences"',
+    "- Include file paths when relevant",
+    "- Set importance based on how impactful the memory is",
+    '- Use tags to categorize (e.g., ["typescript", "testing", "auth"])',
+    "- Skip routine operations (file reads, standard commands)",
+    "- Focus on decisions, learnings, and project-specific knowledge",
+    "",
+    "Fill in the structured output."
+  ];
+}
+function buildClassificationPrompt(window) {
+  const sections = [
+    ...buildPromptPreamble(10),
+    ...formatEventsSection(window.events)
+  ];
+  if (window.transcriptExcerpt) {
+    sections.push("## Transcript Excerpt");
+    sections.push(window.transcriptExcerpt);
+    sections.push("");
+  }
+  sections.push(...buildPromptGuidelines());
+  return sections.join("\n");
+}
+function buildSingleClassificationPrompt(events, transcriptExcerpt) {
+  const sections = [
+    ...buildPromptPreamble(20),
+    ...formatEventsSection(events)
+  ];
+  if (transcriptExcerpt) {
+    sections.push("## Transcript Excerpt");
+    sections.push(transcriptExcerpt);
+    sections.push("");
+  }
+  sections.push(...buildPromptGuidelines());
+  return sections.join("\n");
+}
+function invokeClassifier(prompt, model, timeout) {
+  const claudePath = getClaudePath();
+  if (!claudePath) {
+    throw new Error("Claude CLI not found \u2014 cannot classify memories");
+  }
+  return new Promise((resolve2, reject) => {
+    const proc = spawn(claudePath, [
+      "--print",
+      "--model",
+      model,
+      "--output-format",
+      "json",
+      "--json-schema",
+      CLASSIFIER_SCHEMA,
+      "--permission-mode",
+      "bypassPermissions"
+    ], {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.stdin.write(prompt);
+    proc.stdin.end();
+    const timer = setTimeout(() => {
+      proc.kill("SIGTERM");
+      reject(new Error("Classification timed out"));
+    }, timeout);
+    proc.on("close", (code) => {
+      clearTimeout(timer);
+      if (code !== 0) {
+        reject(new Error(`claude CLI exited with code ${code}: ${stderr.slice(0, 500)}`));
+      } else {
+        try {
+          resolve2(parseClassifierOutput(stdout));
+        } catch (err) {
+          reject(err);
+        }
+      }
+    });
+    proc.on("error", (err) => {
+      clearTimeout(timer);
+      reject(new Error(`Failed to run claude CLI: ${err.message}`));
+    });
+  });
+}
+function classifyWindow(window, model, timeout) {
+  const prompt = buildClassificationPrompt(window);
+  return invokeClassifier(prompt, model, timeout);
+}
+function classifySinglePrompt(events, transcriptExcerpt, model, timeout) {
+  const prompt = buildSingleClassificationPrompt(events, transcriptExcerpt);
+  return invokeClassifier(prompt, model, timeout);
+}
+function parseClassifierOutput(response) {
+  try {
+    const envelope = JSON.parse(response.trim());
+    if (envelope.structured_output && typeof envelope.structured_output === "object") {
+      return ClassificationResultSchema.parse(envelope.structured_output);
+    }
+    if (typeof envelope.result === "string" && envelope.result.trim().startsWith("{")) {
+      return ClassificationResultSchema.parse(JSON.parse(envelope.result));
+    }
+    if (Array.isArray(envelope.memories)) {
+      return ClassificationResultSchema.parse(envelope);
+    }
+  } catch {
+  }
+  const jsonMatch = response.match(/```json\s*\n?([\s\S]*?)\n?\s*```/);
+  if (jsonMatch) {
+    try {
+      return ClassificationResultSchema.parse(JSON.parse(jsonMatch[1]));
+    } catch {
+    }
+  }
+  try {
+    return ClassificationResultSchema.parse(JSON.parse(response.trim()));
+  } catch {
+  }
+  return { memories: [] };
+}
+async function deduplicateMemories(projectDir, candidates, embeddings, store, threshold) {
+  const result = {
+    unique: [],
+    duplicates: [],
+    reinforced: []
+  };
+  for (let i = 0; i < candidates.length; i++) {
+    const candidate = candidates[i];
+    const vector = embeddings[i];
+    const hits = await store.query(vector, 1);
+    if (hits.length > 0 && hits[0].score >= threshold) {
+      const existingId = hits[0].id;
+      result.duplicates.push({
+        candidate,
+        existingId,
+        similarity: hits[0].score
+      });
+      updateEntry(projectDir, existingId, {
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        accessCount: (loadAccessCount(projectDir, existingId) ?? 0) + 1
+      });
+      result.reinforced.push(existingId);
+    } else {
+      result.unique.push(candidate);
+    }
+  }
+  return result;
+}
+function loadAccessCount(projectDir, id) {
+  const entries = listEntries(projectDir);
+  const entry = entries.find((e) => e.id === id);
+  return entry?.accessCount ?? null;
+}
+var DEFAULT_IMPORTANCE_WEIGHTS = {
+  critical: 1,
+  high: 0.8,
+  medium: 0.6,
+  low: 0.4
+};
+function computeDecayFactor(importance, createdAt) {
+  if (importance === "critical") return 1;
+  const ageMs = Date.now() - new Date(createdAt).getTime();
+  const ageDays = ageMs / (1e3 * 60 * 60 * 24);
+  const halfLife = {
+    high: 180,
+    // 6 months
+    medium: 90,
+    // 3 months
+    low: 30
+    // 1 month
+  };
+  const hl = halfLife[importance] ?? 90;
+  const decay = Math.pow(0.5, ageDays / hl);
+  return Math.max(0.1, decay);
+}
+function applyRanking(results, config) {
+  const weights = config?.importanceWeights ?? DEFAULT_IMPORTANCE_WEIGHTS;
+  const boostPerHit = config?.accessBoostPerHit ?? 0.05;
+  const boostCap = config?.accessBoostCap ?? 0.2;
+  for (const result of results) {
+    const entry = result.entry;
+    const importance = entry.importance;
+    const importanceWeight = weights[importance] ?? 0.6;
+    const decayFactor = computeDecayFactor(importance, entry.createdAt);
+    const accessBoost = Math.min(entry.accessCount * boostPerHit, boostCap);
+    result.finalScore = result.score * importanceWeight * decayFactor * (1 + accessBoost);
+  }
+  results.sort((a, b) => b.finalScore - a.finalScore);
+  return results;
+}
+var STALE_TIMEOUT_MS = 6e4;
+var ACQUIRE_TIMEOUT_MS = 1e4;
+var POLL_INTERVAL_MS = 500;
+function sanitizeSlug(projectDir) {
+  const hash = createHash2("sha256").update(path5.resolve(projectDir)).digest("hex").slice(0, 16);
+  const name = path5.basename(projectDir).replace(/[^a-z0-9-]/gi, "-").toLowerCase();
+  return `${name}-${hash}`;
+}
+function lockFilePath(projectDir) {
+  const slug = sanitizeSlug(projectDir);
+  return path5.join(os2.tmpdir(), `ulpi-memory-${slug}.lock`);
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isLockStale(lockPath) {
+  try {
+    const content = fs5.readFileSync(lockPath, "utf-8");
+    const data = JSON.parse(content);
+    if (!isProcessAlive(data.pid)) return true;
+    const lockTime = new Date(data.timestamp).getTime();
+    if (Date.now() - lockTime > STALE_TIMEOUT_MS) return true;
+    return false;
+  } catch {
+    return true;
+  }
+}
+function acquireMemoryLock(projectDir) {
+  const lockPath = lockFilePath(projectDir);
+  const startTime = Date.now();
+  while (true) {
+    if (fs5.existsSync(lockPath)) {
+      if (isLockStale(lockPath)) {
+        try {
+          fs5.unlinkSync(lockPath);
+        } catch {
+        }
+      } else {
+        if (Date.now() - startTime > ACQUIRE_TIMEOUT_MS) {
+          throw new Error("Timeout acquiring memory lock");
+        }
+        const waitUntil = Date.now() + POLL_INTERVAL_MS;
+        while (Date.now() < waitUntil) {
+        }
+        continue;
+      }
+    }
+    const lockData = {
+      pid: process.pid,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    try {
+      fs5.writeFileSync(lockPath, JSON.stringify(lockData), { flag: "wx" });
+      return;
+    } catch {
+      if (Date.now() - startTime > ACQUIRE_TIMEOUT_MS) {
+        throw new Error("Timeout acquiring memory lock");
+      }
+      const waitUntil = Date.now() + POLL_INTERVAL_MS;
+      while (Date.now() < waitUntil) {
+      }
+    }
+  }
+}
+function releaseMemoryLock(projectDir) {
+  const lockPath = lockFilePath(projectDir);
+  try {
+    const content = fs5.readFileSync(lockPath, "utf-8");
+    const data = JSON.parse(content);
+    if (data.pid === process.pid) {
+      fs5.unlinkSync(lockPath);
+    }
+  } catch {
+  }
+}
+function isMemoryLocked(projectDir) {
+  const lockPath = lockFilePath(projectDir);
+  if (!fs5.existsSync(lockPath)) return false;
+  return !isLockStale(lockPath);
+}
+async function searchMemory(projectDir, options) {
+  const startMs = Date.now();
+  const config = loadMemoryConfig(projectDir);
+  const limit = options.limit ?? 10;
+  const embedder = await createEmbedder(config.embedding);
+  const [queryVector] = await embedder.embed([options.query]);
+  acquireMemoryLock(projectDir);
+  let results;
+  let trimmed;
+  try {
+    const store = new MemoryVectorStore(projectDir);
+    await store.initialize();
+    const candidateCount = Math.min(limit * 3, 150);
+    const vectorResults = await store.query(queryVector, candidateCount);
+    results = [];
+    for (const vr of vectorResults) {
+      const entry = loadEntry(projectDir, vr.id);
+      if (!entry) continue;
+      if (entry.supersededBy && !options.includeSuperseded) continue;
+      if (options.types && options.types.length > 0) {
+        if (!options.types.includes(entry.type)) continue;
+      }
+      if (options.importance && options.importance.length > 0) {
+        if (!options.importance.includes(entry.importance)) continue;
+      }
+      if (options.tags && options.tags.length > 0) {
+        const hasTag = options.tags.some((t) => entry.tags.includes(t));
+        if (!hasTag) continue;
+      }
+      if (options.since && entry.createdAt < options.since) continue;
+      results.push({
+        entry,
+        score: vr.score,
+        finalScore: vr.score
+        // Will be updated by ranking
+      });
+    }
+    applyRanking(results, config.ranking);
+    trimmed = results.slice(0, limit);
+    for (const result of trimmed) {
+      try {
+        updateEntry(projectDir, result.entry.id, {
+          accessCount: result.entry.accessCount + 1,
+          lastAccessedAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      } catch {
+      }
+    }
+  } finally {
+    releaseMemoryLock(projectDir);
+  }
+  return {
+    query: options.query,
+    durationMs: Date.now() - startMs,
+    results: trimmed
+  };
+}
+function getTopMemories(projectDir, limit) {
+  const config = loadMemoryConfig(projectDir);
+  const maxResults = limit ?? config.surfaceLimit;
+  const entries = listEntries(projectDir).filter((e) => !e.supersededBy);
+  if (entries.length === 0) return [];
+  const scored = entries.map((entry) => {
+    let score = 0;
+    const importanceScores = {
+      critical: 1,
+      high: 0.8,
+      medium: 0.5,
+      low: 0.2
+    };
+    score += importanceScores[entry.importance] ?? 0.5;
+    if (entry.lastAccessedAt) {
+      const daysSinceAccess = (Date.now() - new Date(entry.lastAccessedAt).getTime()) / (1e3 * 60 * 60 * 24);
+      if (daysSinceAccess < 7) score += 0.3;
+      else if (daysSinceAccess < 30) score += 0.1;
+    }
+    score += Math.min(entry.accessCount * 0.02, 0.2);
+    return { entry, score };
+  });
+  scored.sort((a, b) => b.score - a.score);
+  return scored.slice(0, maxResults).map((s) => s.entry);
+}
+function formatMemoriesForAgent(memories) {
+  if (memories.length === 0) return "";
+  const lines = [];
+  const width = 56;
+  lines.push(`\u256D${"\u2500".repeat(3)} Agent Memory ${"\u2500".repeat(width - 17)}\u256E`);
+  lines.push(`\u2502 ${memories.length} memories loaded for this codebase${" ".repeat(width - 37 - String(memories.length).length)}\u2502`);
+  lines.push(`\u251C${"\u2500".repeat(width)}\u2524`);
+  for (const mem of memories) {
+    const typeLabel = mem.type.replace(/_/g, " ");
+    const summary = mem.summary.length > width - typeLabel.length - 5 ? mem.summary.slice(0, width - typeLabel.length - 8) + "..." : mem.summary;
+    const line = `${typeLabel}: ${summary}`;
+    const padded = line.length > width - 4 ? line.slice(0, width - 4) : line + " ".repeat(width - 4 - line.length);
+    lines.push(`\u2502 ${padded} \u2502`);
+  }
+  lines.push(`\u2570${"\u2500".repeat(width)}\u256F`);
+  return lines.join("\n");
+}
+function watermarkPath(projectDir, sessionId) {
+  return path6.join(memoryWatermarksDir(projectDir), `${sessionId}.json`);
+}
+function loadWatermark(projectDir, sessionId) {
+  const filePath = watermarkPath(projectDir, sessionId);
+  if (!fs6.existsSync(filePath)) return null;
+  try {
+    return JSON.parse(fs6.readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function saveWatermark(projectDir, watermark) {
+  const dir = memoryWatermarksDir(projectDir);
+  fs6.mkdirSync(dir, { recursive: true });
+  const filePath = watermarkPath(projectDir, watermark.sessionId);
+  const tmpPath = filePath + ".tmp";
+  fs6.writeFileSync(tmpPath, JSON.stringify(watermark, null, 2) + "\n", "utf-8");
+  fs6.renameSync(tmpPath, filePath);
+}
+function listWatermarks(projectDir) {
+  const dir = memoryWatermarksDir(projectDir);
+  if (!fs6.existsSync(dir)) return [];
+  const watermarks = [];
+  const files = fs6.readdirSync(dir).filter((f) => f.endsWith(".json"));
+  for (const file of files) {
+    try {
+      const raw = fs6.readFileSync(path6.join(dir, file), "utf-8");
+      watermarks.push(JSON.parse(raw));
+    } catch {
+    }
+  }
+  return watermarks;
+}
+function isMemoryInitialized(projectDir) {
+  return fs7.existsSync(projectMemoryDir(projectDir));
+}
+async function getMemoryStats(projectDir) {
+  if (!isMemoryInitialized(projectDir)) {
+    return {
+      totalMemories: 0,
+      memoriesByType: {},
+      memoriesByImportance: {},
+      totalAccesses: 0,
+      sessionsCaptured: 0,
+      sessionsClassified: 0,
+      indexSizeBytes: 0,
+      lastClassifiedAt: null,
+      lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      initialized: false
+    };
+  }
+  const entries = listEntries(projectDir);
+  const sessions = listCapturedSessions(projectDir);
+  const watermarks = listWatermarks(projectDir);
+  const byType = {};
+  const byImportance = {};
+  let totalAccesses = 0;
+  for (const entry of entries) {
+    byType[entry.type] = (byType[entry.type] ?? 0) + 1;
+    byImportance[entry.importance] = (byImportance[entry.importance] ?? 0) + 1;
+    totalAccesses += entry.accessCount;
+  }
+  const store = new MemoryVectorStore(projectDir);
+  const indexSizeBytes = store.getIndexSizeBytes();
+  const classified = watermarks.filter((w) => w.status === "complete");
+  let lastClassifiedAt = null;
+  for (const w of classified) {
+    if (!lastClassifiedAt || w.updatedAt > lastClassifiedAt) {
+      lastClassifiedAt = w.updatedAt;
+    }
+  }
+  return {
+    totalMemories: entries.length,
+    memoriesByType: byType,
+    memoriesByImportance: byImportance,
+    totalAccesses,
+    sessionsCaptured: sessions.length,
+    sessionsClassified: classified.length,
+    indexSizeBytes,
+    lastClassifiedAt,
+    lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    initialized: true
+  };
+}
+function writeMemoryStats(projectDir, stats) {
+  const statsPath = memoryStatsFile(projectDir);
+  const tmpPath = statsPath + ".tmp";
+  fs7.mkdirSync(path7.dirname(statsPath), { recursive: true });
+  fs7.writeFileSync(tmpPath, JSON.stringify(stats, null, 2) + "\n", "utf-8");
+  fs7.renameSync(tmpPath, statsPath);
+}
+function loadSessionMeta(projectDir, sessionId) {
+  const metaPath = path8.join(sessionCaptureDir(projectDir, sessionId), "meta.json");
+  try {
+    return JSON.parse(fs8.readFileSync(metaPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function isSessionSignificant(meta, filteredEvents, minEvents) {
+  const hasWrites = meta ? meta.filesWritten > 0 : true;
+  const hasEnoughEvents = filteredEvents.length >= minEvents;
+  const hasErrorEvents = filteredEvents.some(
+    (ev) => ev.event === "tool_blocked" || ev.event === "permission_denied" || ev.event === "postcondition_failed"
+  );
+  return hasWrites || hasEnoughEvents || hasErrorEvents;
+}
+async function classifySession(projectDir, sessionId, onProgress) {
+  const startMs = Date.now();
+  const config = loadMemoryConfig(projectDir);
+  onProgress?.({
+    phase: "reading",
+    current: 0,
+    total: 0,
+    message: "Reading and filtering events..."
+  });
+  const allEvents = readCapturedEvents(projectDir, sessionId);
+  if (allEvents.length === 0) {
+    return {
+      sessionId,
+      windowsProcessed: 0,
+      memoriesExtracted: 0,
+      memoriesStored: 0,
+      durationMs: Date.now() - startMs
+    };
+  }
+  const watermark = loadWatermark(projectDir, sessionId);
+  const startIdx = watermark?.lastProcessedEventIndex ?? 0;
+  if (startIdx >= allEvents.length) {
+    return {
+      sessionId,
+      windowsProcessed: 0,
+      memoriesExtracted: 0,
+      memoriesStored: 0,
+      durationMs: Date.now() - startMs
+    };
+  }
+  const unprocessedEvents = allEvents.slice(startIdx);
+  const filteredEvents = config.classifier.filterNoiseEvents ? filterSignificantEvents(unprocessedEvents) : unprocessedEvents;
+  const meta = loadSessionMeta(projectDir, sessionId);
+  if (!isSessionSignificant(meta, filteredEvents, config.classifier.minSignificantEvents)) {
+    saveWatermark(projectDir, {
+      sessionId,
+      lastProcessedEventIndex: allEvents.length,
+      lastProcessedTs: allEvents[allEvents.length - 1].ts,
+      status: "complete",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return {
+      sessionId,
+      windowsProcessed: 0,
+      memoriesExtracted: 0,
+      memoriesStored: 0,
+      durationMs: Date.now() - startMs
+    };
+  }
+  const allMemories = [];
+  let windowsProcessed = 0;
+  if (filteredEvents.length <= config.classifier.maxSinglePromptEvents) {
+    onProgress?.({
+      phase: "classifying",
+      current: 1,
+      total: 1,
+      message: `Classifying ${filteredEvents.length} events in single prompt...`
+    });
+    let transcriptExcerpt;
+    if (config.classifier.includeTranscript) {
+      transcriptExcerpt = readCapturedTranscript(
+        projectDir,
+        sessionId,
+        config.classifier.maxTranscriptChars
+      ) ?? void 0;
+    }
+    try {
+      const result = await classifySinglePrompt(
+        filteredEvents,
+        transcriptExcerpt,
+        config.classifier.model,
+        config.classifier.timeout
+      );
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      for (const mem of result.memories) {
+        allMemories.push(toMemoryEntry(mem, sessionId, now));
+      }
+    } catch {
+    }
+    windowsProcessed = 1;
+  } else {
+    const windows = buildClassificationWindows(
+      sessionId,
+      projectDir,
+      filteredEvents,
+      config
+    );
+    if (windows.length === 0) {
+      saveWatermark(projectDir, {
+        sessionId,
+        lastProcessedEventIndex: allEvents.length,
+        lastProcessedTs: allEvents[allEvents.length - 1].ts,
+        status: "complete",
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      return {
+        sessionId,
+        windowsProcessed: 0,
+        memoriesExtracted: 0,
+        memoriesStored: 0,
+        durationMs: Date.now() - startMs
+      };
+    }
+    let windowIdx = 0;
+    for (const window of windows) {
+      windowIdx++;
+      onProgress?.({
+        phase: "classifying",
+        current: windowIdx,
+        total: windows.length,
+        message: `Classifying window ${windowIdx}/${windows.length}...`
+      });
+      try {
+        const result = await classifyWindow(
+          window,
+          config.classifier.model,
+          config.classifier.timeout
+        );
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        for (const mem of result.memories) {
+          allMemories.push(toMemoryEntry(mem, sessionId, now));
+        }
+      } catch {
+        continue;
+      }
+    }
+    windowsProcessed = windows.length;
+  }
+  const lastEvent = allEvents[allEvents.length - 1];
+  if (allMemories.length === 0) {
+    saveWatermark(projectDir, {
+      sessionId,
+      lastProcessedEventIndex: allEvents.length,
+      lastProcessedTs: lastEvent.ts,
+      status: "complete",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return {
+      sessionId,
+      windowsProcessed,
+      memoriesExtracted: 0,
+      memoriesStored: 0,
+      durationMs: Date.now() - startMs
+    };
+  }
+  onProgress?.({
+    phase: "embedding",
+    current: 0,
+    total: allMemories.length,
+    message: `Embedding ${allMemories.length} memories...`
+  });
+  const embedder = await createEmbedder(config.embedding);
+  const texts = allMemories.map((m) => m.summary);
+  const embeddings = await embedWithBatch(embedder, texts);
+  onProgress?.({
+    phase: "storing",
+    current: 0,
+    total: allMemories.length,
+    message: "Deduplicating and storing..."
+  });
+  acquireMemoryLock(projectDir);
+  try {
+    const store = new MemoryVectorStore(projectDir);
+    await store.initialize();
+    const dedupResult = await deduplicateMemories(
+      projectDir,
+      allMemories,
+      embeddings,
+      store,
+      config.retention.deduplicationThreshold
+    );
+    if (dedupResult.unique.length > 0) {
+      const vectorItems = [];
+      for (let i = 0; i < allMemories.length; i++) {
+        const mem = allMemories[i];
+        if (!dedupResult.unique.includes(mem)) continue;
+        saveEntry(projectDir, mem);
+        vectorItems.push({
+          id: mem.id,
+          vector: embeddings[i],
+          metadata: {
+            id: mem.id,
+            type: mem.type,
+            importance: mem.importance,
+            snippet: mem.summary.slice(0, 200),
+            createdAt: mem.createdAt,
+            tags: mem.tags.join(",")
+          }
+        });
+      }
+      await store.upsertItems(vectorItems);
+    }
+    saveWatermark(projectDir, {
+      sessionId,
+      lastProcessedEventIndex: allEvents.length,
+      lastProcessedTs: lastEvent.ts,
+      status: "complete",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    onProgress?.({
+      phase: "finalizing",
+      current: dedupResult.unique.length,
+      total: allMemories.length,
+      message: `Stored ${dedupResult.unique.length} new memories (${dedupResult.duplicates.length} duplicates)`
+    });
+    return {
+      sessionId,
+      windowsProcessed,
+      memoriesExtracted: allMemories.length,
+      memoriesStored: dedupResult.unique.length,
+      durationMs: Date.now() - startMs
+    };
+  } finally {
+    releaseMemoryLock(projectDir);
+  }
+}
+function toMemoryEntry(mem, sessionId, now) {
+  return {
+    id: generateMemoryId(mem.type, mem.summary),
+    type: mem.type,
+    summary: mem.summary,
+    detail: mem.detail ?? null,
+    importance: mem.importance,
+    tags: mem.tags,
+    relatedFiles: mem.relatedFiles,
+    source: {
+      type: "classifier",
+      sessionId
+    },
+    createdAt: now,
+    updatedAt: now,
+    accessCount: 0
+  };
+}
+async function reindexMemories(projectDir, onProgress) {
+  const startMs = Date.now();
+  const config = loadMemoryConfig(projectDir);
+  const entries = listEntries(projectDir);
+  if (entries.length === 0) {
+    return { reindexed: 0, durationMs: Date.now() - startMs };
+  }
+  onProgress?.({
+    phase: "embedding",
+    current: 0,
+    total: entries.length,
+    message: `Re-embedding ${entries.length} memories...`
+  });
+  const embedder = await createEmbedder(config.embedding);
+  const texts = entries.map((m) => m.summary);
+  const embeddings = await embedWithBatch(embedder, texts);
+  onProgress?.({
+    phase: "storing",
+    current: 0,
+    total: entries.length,
+    message: "Rebuilding vector index..."
+  });
+  acquireMemoryLock(projectDir);
+  try {
+    const lancePath = memoryLanceDir(projectDir);
+    if (fs8.existsSync(lancePath)) {
+      fs8.rmSync(lancePath, { recursive: true });
+    }
+    const store = new MemoryVectorStore(projectDir);
+    await store.initialize();
+    const vectorItems = entries.map((entry, i) => ({
+      id: entry.id,
+      vector: embeddings[i],
+      metadata: {
+        id: entry.id,
+        type: entry.type,
+        importance: entry.importance,
+        snippet: entry.summary.slice(0, 200),
+        createdAt: entry.createdAt,
+        tags: entry.tags.join(",")
+      }
+    }));
+    await store.upsertItems(vectorItems);
+    onProgress?.({
+      phase: "finalizing",
+      current: entries.length,
+      total: entries.length,
+      message: `Re-indexed ${entries.length} memories`
+    });
+    return { reindexed: entries.length, durationMs: Date.now() - startMs };
+  } finally {
+    releaseMemoryLock(projectDir);
+  }
+}
+async function embedWithBatch(embedder, texts) {
+  if (texts.length === 0) return [];
+  if (embedder.supportsBatch && embedder.submitBatch && embedder.pollBatch) {
+    const batchId = await embedder.submitBatch(texts);
+    const POLL_MS = 2e3;
+    while (true) {
+      const status = await embedder.pollBatch(batchId);
+      if (status.status === "completed" && status.results) {
+        return status.results;
+      }
+      if (status.status === "failed") {
+        throw new Error(`Batch embedding failed (batch ${batchId})`);
+      }
+      await new Promise((resolve2) => setTimeout(resolve2, POLL_MS));
+    }
+  }
+  return embedder.embed(texts);
+}
+async function rememberMemory(projectDir, entry) {
+  const config = loadMemoryConfig(projectDir);
+  const embedder = await createEmbedder(config.embedding);
+  const [vector] = await embedder.embed([entry.summary]);
+  acquireMemoryLock(projectDir);
+  try {
+    const store = new MemoryVectorStore(projectDir);
+    await store.initialize();
+    saveEntry(projectDir, entry);
+    await store.upsertItems([{
+      id: entry.id,
+      vector,
+      metadata: {
+        id: entry.id,
+        type: entry.type,
+        importance: entry.importance,
+        snippet: entry.summary.slice(0, 200),
+        createdAt: entry.createdAt,
+        tags: entry.tags.join(",")
+      }
+    }]);
+  } finally {
+    releaseMemoryLock(projectDir);
+  }
+}
+function memoryBranchExists(projectDir) {
+  const branch = getMemoryBranch();
+  try {
+    execFileSync2("git", ["rev-parse", "--verify", `refs/heads/${branch}`], {
+      cwd: projectDir,
+      stdio: "pipe",
+      timeout: 5e3
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function initMemoryBranch(projectDir) {
+  const branch = getMemoryBranch();
+  if (memoryBranchExists(projectDir)) return;
+  const tmpDir = fs9.mkdtempSync(path9.join(os3.tmpdir(), "ulpi-memory-"));
+  try {
+    execFileSync2("git", ["worktree", "add", "--detach", tmpDir], {
+      cwd: projectDir,
+      stdio: "pipe",
+      timeout: 1e4
+    });
+    execFileSync2("git", ["checkout", "--orphan", branch], {
+      cwd: tmpDir,
+      stdio: "pipe",
+      timeout: 5e3
+    });
+    execFileSync2("git", ["rm", "-rf", "--cached", "."], {
+      cwd: tmpDir,
+      stdio: "pipe",
+      timeout: 5e3
+    });
+    fs9.writeFileSync(
+      path9.join(tmpDir, "README.md"),
+      "# ULPI Agent Memory\n\nThis branch stores agent memory data.\n"
+    );
+    execFileSync2("git", ["add", "README.md"], {
+      cwd: tmpDir,
+      stdio: "pipe",
+      timeout: 5e3
+    });
+    execFileSync2("git", ["commit", "-m", "init: agent memory branch"], {
+      cwd: tmpDir,
+      stdio: "pipe",
+      timeout: 1e4
+    });
+  } finally {
+    try {
+      execFileSync2("git", ["worktree", "remove", "--force", tmpDir], {
+        cwd: projectDir,
+        stdio: "pipe",
+        timeout: 1e4
+      });
+    } catch {
+      try {
+        fs9.rmSync(tmpDir, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  }
+}
+function exportMemories(projectDir) {
+  const branch = getMemoryBranch();
+  if (!memoryBranchExists(projectDir)) {
+    initMemoryBranch(projectDir);
+  }
+  const entries = listEntries(projectDir);
+  const config = loadMemoryConfig(projectDir);
+  const exportData = {
+    version: 1,
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    projectDir,
+    memories: entries,
+    config
+  };
+  const tmpDir = fs9.mkdtempSync(path9.join(os3.tmpdir(), "ulpi-memory-export-"));
+  try {
+    execFileSync2("git", ["worktree", "add", tmpDir, branch], {
+      cwd: projectDir,
+      stdio: "pipe",
+      timeout: 1e4
+    });
+    fs9.writeFileSync(
+      path9.join(tmpDir, "memories.json"),
+      JSON.stringify(exportData, null, 2) + "\n"
+    );
+    execFileSync2("git", ["add", "memories.json"], {
+      cwd: tmpDir,
+      stdio: "pipe",
+      timeout: 5e3
+    });
+    try {
+      execFileSync2("git", ["diff", "--cached", "--quiet"], {
+        cwd: tmpDir,
+        stdio: "pipe",
+        timeout: 5e3
+      });
+      const sha2 = execFileSync2("git", ["rev-parse", "HEAD"], {
+        cwd: tmpDir,
+        encoding: "utf-8",
+        timeout: 5e3
+      }).trim();
+      return { branchName: branch, commitSha: sha2, memoriesExported: entries.length };
+    } catch {
+    }
+    execFileSync2("git", [
+      "commit",
+      "-m",
+      `memory: export ${entries.length} memories`
+    ], {
+      cwd: tmpDir,
+      stdio: "pipe",
+      timeout: 1e4
+    });
+    const sha = execFileSync2("git", ["rev-parse", "HEAD"], {
+      cwd: tmpDir,
+      encoding: "utf-8",
+      timeout: 5e3
+    }).trim();
+    return { branchName: branch, commitSha: sha, memoriesExported: entries.length };
+  } finally {
+    try {
+      execFileSync2("git", ["worktree", "remove", "--force", tmpDir], {
+        cwd: projectDir,
+        stdio: "pipe",
+        timeout: 1e4
+      });
+    } catch {
+      try {
+        fs9.rmSync(tmpDir, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  }
+}
+function importMemories(projectDir) {
+  const branch = getMemoryBranch();
+  if (!memoryBranchExists(projectDir)) {
+    return { success: false, memoriesImported: 0, message: "Memory branch does not exist" };
+  }
+  try {
+    const raw = execFileSync2(
+      "git",
+      ["show", `${branch}:memories.json`],
+      { cwd: projectDir, encoding: "utf-8", timeout: 1e4 }
+    );
+    const exportData = JSON.parse(raw);
+    if (!exportData.memories || !Array.isArray(exportData.memories)) {
+      return { success: false, memoriesImported: 0, message: "Invalid export data" };
+    }
+    const entriesDir = memoryEntriesDir(projectDir);
+    fs9.mkdirSync(entriesDir, { recursive: true });
+    let imported = 0;
+    for (const entry of exportData.memories) {
+      const filePath = path9.join(entriesDir, `${entry.id}.json`);
+      if (!fs9.existsSync(filePath)) {
+        fs9.writeFileSync(filePath, JSON.stringify(entry, null, 2) + "\n", "utf-8");
+        imported++;
+      }
+    }
+    return {
+      success: true,
+      memoriesImported: imported,
+      message: `Imported ${imported} new memories (${exportData.memories.length - imported} already exist)`
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { success: false, memoriesImported: 0, message };
+  }
+}
+
+export {
+  DEFAULT_MEMORY_CONFIG,
+  loadMemoryConfig,
+  saveMemoryConfig,
+  isMemoryEnabled,
+  generateMemoryId,
+  MemoryVectorStore,
+  saveEntry,
+  loadEntry,
+  removeEntry,
+  listEntries,
+  updateEntry,
+  redactContent,
+  appendMemoryEvent,
+  toClassificationEvent,
+  finalizeCapture,
+  isSessionCaptured,
+  listCapturedSessions,
+  readCapturedEvents,
+  readCapturedTranscript,
+  filterSignificantEvents,
+  buildClassificationWindows,
+  buildClassificationPrompt,
+  buildSingleClassificationPrompt,
+  classifyWindow,
+  classifySinglePrompt,
+  parseClassifierOutput,
+  deduplicateMemories,
+  applyRanking,
+  acquireMemoryLock,
+  releaseMemoryLock,
+  isMemoryLocked,
+  searchMemory,
+  getTopMemories,
+  formatMemoriesForAgent,
+  loadWatermark,
+  saveWatermark,
+  listWatermarks,
+  isMemoryInitialized,
+  getMemoryStats,
+  writeMemoryStats,
+  classifySession,
+  reindexMemories,
+  rememberMemory,
+  memoryBranchExists,
+  initMemoryBranch,
+  exportMemories,
+  importMemories
+};