@membank/core 0.6.0 → 0.7.0

package/dist/index.cjs

@@ -28,6 +28,7 @@ let better_sqlite3 = require("better-sqlite3");
 better_sqlite3 = __toESM(better_sqlite3, 1);
 let sqlite_vec = require("sqlite-vec");
 sqlite_vec = __toESM(sqlite_vec, 1);
+let zod = require("zod");
 let _huggingface_transformers = require("@huggingface/transformers");
 let node_crypto = require("node:crypto");
 let node_child_process = require("node:child_process");
@@ -48,7 +49,7 @@ var DatabaseError = class extends MembankError {
 //#endregion
 //#region src/db/manager.ts
 const DEFAULT_DB_PATH = (0, node_path.join)((0, node_os.homedir)(), ".membank", "memory.db");
-const MIGRATIONS = [[1, `
+const MIGRATIONS$1 = [[1, `
 CREATE TABLE IF NOT EXISTS memories (
   id           TEXT PRIMARY KEY,
   content      TEXT NOT NULL,
@@ -143,7 +144,7 @@ var DatabaseManager = class DatabaseManager {
     `);
 		const row = this.#db.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get();
 		const currentVersion = row ? Number.parseInt(row.value, 10) : 0;
-		for (const [targetVersion, sql] of MIGRATIONS) if (currentVersion < targetVersion) {
+		for (const [targetVersion, sql] of MIGRATIONS$1) if (currentVersion < targetVersion) {
 			this.#db.exec(sql);
 			this.#db.prepare("INSERT OR REPLACE INTO meta (key, value) VALUES ('schema_version', ?)").run(String(targetVersion));
 		}
@@ -156,13 +157,89 @@ var DatabaseManager = class DatabaseManager {
 	}
 };
 //#endregion
+//#region src/schemas.ts
+const MEMORY_TYPE_VALUES = [
+	"correction",
+	"preference",
+	"decision",
+	"learning",
+	"fact"
+];
+const MemoryTypeSchema = zod.z.enum(MEMORY_TYPE_VALUES);
+const TagsJsonSchema = zod.z.array(zod.z.string());
+const ProjectSchema = zod.z.object({
+	id: zod.z.string(),
+	name: zod.z.string(),
+	scopeHash: zod.z.string(),
+	createdAt: zod.z.string(),
+	updatedAt: zod.z.string()
+});
+const MemorySchema = zod.z.object({
+	id: zod.z.string(),
+	content: zod.z.string(),
+	type: MemoryTypeSchema,
+	tags: zod.z.array(zod.z.string()),
+	projects: zod.z.array(ProjectSchema),
+	sourceHarness: zod.z.string().nullable(),
+	accessCount: zod.z.number().int().nonnegative(),
+	pinned: zod.z.boolean(),
+	needsReview: zod.z.boolean(),
+	createdAt: zod.z.string(),
+	updatedAt: zod.z.string()
+});
+const QueryOptionsSchema = zod.z.object({
+	query: zod.z.string().min(1),
+	type: MemoryTypeSchema.optional(),
+	projectHash: zod.z.string().optional(),
+	limit: zod.z.number().int().positive().optional(),
+	includePinned: zod.z.boolean().optional()
+});
+const SaveOptionsSchema = zod.z.object({
+	content: zod.z.string().min(1),
+	type: MemoryTypeSchema,
+	tags: zod.z.array(zod.z.string()).optional(),
+	projectScope: zod.z.object({
+		hash: zod.z.string(),
+		name: zod.z.string()
+	}).optional(),
+	sourceHarness: zod.z.string().optional()
+});
+const MemoryPatchSchema = zod.z.object({
+	content: zod.z.string().min(1).optional(),
+	tags: zod.z.array(zod.z.string()).optional()
+});
+const SessionContextSchema = zod.z.object({
+	stats: zod.z.record(MemoryTypeSchema, zod.z.number()),
+	pinnedGlobal: zod.z.array(MemorySchema),
+	pinnedProject: zod.z.array(MemorySchema)
+});
+const MemoryRowSchema = zod.z.object({
+	id: zod.z.string(),
+	content: zod.z.string(),
+	type: zod.z.string(),
+	tags: zod.z.string(),
+	source: zod.z.string().nullable(),
+	access_count: zod.z.number(),
+	pinned: zod.z.number(),
+	needs_review: zod.z.number(),
+	created_at: zod.z.string(),
+	updated_at: zod.z.string()
+});
+const ProjectRowSchema = zod.z.object({
+	id: zod.z.string(),
+	name: zod.z.string(),
+	scope_hash: zod.z.string(),
+	created_at: zod.z.string(),
+	updated_at: zod.z.string()
+});
+//#endregion
 //#region src/db/row-types.ts
 function rowToMemory(row, projects) {
 	return {
 		id: row.id,
 		content: row.content,
-		type: row.type,
-		tags: JSON.parse(row.tags),
+		type: MemoryTypeSchema.parse(row.type),
+		tags: TagsJsonSchema.parse(JSON.parse(row.tags)),
 		projects,
 		sourceHarness: row.source,
 		accessCount: row.access_count,
@@ -207,15 +284,6 @@ var EmbeddingService = class {
 	}
 };
 //#endregion
-//#region src/types.ts
-const MEMORY_TYPE_VALUES = [
-	"correction",
-	"preference",
-	"decision",
-	"learning",
-	"fact"
-];
-//#endregion
 //#region src/memory/repository.ts
 var MemoryRepository = class {
 	#db;
@@ -227,16 +295,16 @@ var MemoryRepository = class {
 		this.#projects = projects;
 	}
 	async save(options) {
-		const { content, type, tags = [], projectHash, sourceHarness } = options;
+		const { content, type, tags = [], projectScope, sourceHarness } = SaveOptionsSchema.parse(options);
 		const embedding = await this.#embedding.embed(content);
 		const embeddingBlob = Buffer.from(embedding.buffer);
 		let top;
-		if (projectHash !== void 0) top = this.#db.db.prepare(`SELECT m.rowid, m.*, (1 - vec_distance_cosine(e.embedding, ?)) AS similarity
+		if (projectScope !== void 0) top = this.#db.db.prepare(`SELECT m.rowid, m.*, (1 - vec_distance_cosine(e.embedding, ?)) AS similarity
            FROM memories m JOIN embeddings e ON e.rowid = m.rowid
            JOIN memory_projects mp ON mp.memory_id = m.id
            JOIN projects p ON p.id = mp.project_id
            WHERE m.type = ? AND p.scope_hash = ?
-           ORDER BY similarity DESC LIMIT 1`).get(embeddingBlob, type, projectHash);
+           ORDER BY similarity DESC LIMIT 1`).get(embeddingBlob, type, projectScope.hash);
 		else top = this.#db.db.prepare(`SELECT m.rowid, m.*, (1 - vec_distance_cosine(e.embedding, ?)) AS similarity
            FROM memories m JOIN embeddings e ON e.rowid = m.rowid
            WHERE m.type = ?
@@ -246,41 +314,42 @@ var MemoryRepository = class {
 		if (top !== void 0 && top.similarity > .92) {
 			this.#db.db.prepare(`UPDATE memories SET content = ?, updated_at = ? WHERE id = ?`).run(content, now, top.id);
 			this.#db.db.prepare(`UPDATE embeddings SET embedding = ? WHERE rowid = ?`).run(embeddingBlob, top.rowid);
-			return rowToMemory(this.#db.db.prepare(`SELECT * FROM memories WHERE id = ?`).get(top.id), this.#projects.getProjectsForMemories([top.id]).get(top.id) ?? []);
+			return rowToMemory(MemoryRowSchema.parse(this.#db.db.prepare(`SELECT * FROM memories WHERE id = ?`).get(top.id)), this.#projects.getProjectsForMemories([top.id]).get(top.id) ?? []);
 		}
 		if (top !== void 0 && top.similarity >= .75) this.#db.db.prepare(`UPDATE memories SET needs_review = 1 WHERE id = ?`).run(top.id);
 		const id = (0, node_crypto.randomUUID)();
 		this.#db.db.prepare(`INSERT INTO memories (id, content, type, tags, source, access_count, pinned, needs_review, created_at, updated_at)
          VALUES (?, ?, ?, ?, ?, 0, 0, 0, ?, ?)`).run(id, content, type, JSON.stringify(tags), sourceHarness ?? null, now, now);
 		this.#db.db.prepare(`INSERT INTO embeddings (rowid, embedding) SELECT m.rowid, ? FROM memories m WHERE m.id = ?`).run(embeddingBlob, id);
-		if (projectHash !== void 0) {
-			const project = this.#projects.upsertByHash(projectHash, `project-${projectHash.slice(0, 8)}`);
+		if (projectScope !== void 0) {
+			const project = this.#projects.upsertByHash(projectScope.hash, projectScope.name);
 			this.#projects.addAssociation(id, project.id);
 		}
-		return rowToMemory(this.#db.db.prepare(`SELECT * FROM memories WHERE id = ?`).get(id), this.#projects.getProjectsForMemories([id]).get(id) ?? []);
+		return rowToMemory(MemoryRowSchema.parse(this.#db.db.prepare(`SELECT * FROM memories WHERE id = ?`).get(id)), this.#projects.getProjectsForMemories([id]).get(id) ?? []);
 	}
 	async update(id, patch) {
+		const { content, tags } = MemoryPatchSchema.parse(patch);
 		const existing = this.#db.db.prepare(`SELECT m.rowid, m.* FROM memories m WHERE m.id = ?`).get(id);
 		if (existing === void 0) throw new Error(`Memory not found: ${id}`);
 		const now = (/* @__PURE__ */ new Date()).toISOString();
 		const sets = ["updated_at = ?"];
 		const values = [now];
-		if (patch.content !== void 0) {
+		if (content !== void 0) {
 			sets.push("content = ?");
-			values.push(patch.content);
+			values.push(content);
 		}
-		if (patch.tags !== void 0) {
+		if (tags !== void 0) {
 			sets.push("tags = ?");
-			values.push(JSON.stringify(patch.tags));
+			values.push(JSON.stringify(tags));
 		}
 		values.push(id);
 		this.#db.db.prepare(`UPDATE memories SET ${sets.join(", ")} WHERE id = ?`).run(...values);
-		if (patch.content !== void 0) {
-			const embedding = await this.#embedding.embed(patch.content);
+		if (content !== void 0) {
+			const embedding = await this.#embedding.embed(content);
 			const embeddingBlob = Buffer.from(embedding.buffer);
 			this.#db.db.prepare(`UPDATE embeddings SET embedding = ? WHERE rowid = ?`).run(embeddingBlob, existing.rowid);
 		}
-		return rowToMemory(this.#db.db.prepare(`SELECT * FROM memories WHERE id = ?`).get(id), this.#projects.getProjectsForMemories([id]).get(id) ?? []);
+		return rowToMemory(MemoryRowSchema.parse(this.#db.db.prepare(`SELECT * FROM memories WHERE id = ?`).get(id)), this.#projects.getProjectsForMemories([id]).get(id) ?? []);
 	}
 	delete(id) {
 		const row = this.#db.db.prepare(`SELECT rowid FROM memories WHERE id = ?`).get(id);
@@ -307,7 +376,10 @@ var MemoryRepository = class {
 	stats() {
 		const byType = Object.fromEntries(MEMORY_TYPE_VALUES.map((t) => [t, 0]));
 		const typeRows = this.#db.db.prepare(`SELECT type, COUNT(*) as count FROM memories GROUP BY type`).all();
-		for (const row of typeRows) if (row.type in byType) byType[row.type] = row.count;
+		for (const row of typeRows) {
+			const parsed = MemoryTypeSchema.safeParse(row.type);
+			if (parsed.success) byType[parsed.data] = row.count;
+		}
 		const totals = this.#db.db.prepare(`SELECT COUNT(*) as total, SUM(needs_review) as needsReview FROM memories`).get() ?? {
 			total: 0,
 			needsReview: 0
@@ -322,13 +394,74 @@ var MemoryRepository = class {
 		if (this.#db.db.prepare(`SELECT * FROM memories WHERE id = ?`).get(id) === void 0) throw new Error(`Memory not found: ${id}`);
 		const now = (/* @__PURE__ */ new Date()).toISOString();
 		this.#db.db.prepare(`UPDATE memories SET pinned = ?, updated_at = ? WHERE id = ?`).run(pinned ? 1 : 0, now, id);
-		return rowToMemory(this.#db.db.prepare(`SELECT * FROM memories WHERE id = ?`).get(id), this.#projects.getProjectsForMemories([id]).get(id) ?? []);
+		return rowToMemory(MemoryRowSchema.parse(this.#db.db.prepare(`SELECT * FROM memories WHERE id = ?`).get(id)), this.#projects.getProjectsForMemories([id]).get(id) ?? []);
 	}
 	incrementAccessCount(id) {
 		this.#db.db.prepare(`UPDATE memories SET access_count = access_count + 1 WHERE id = ?`).run(id);
 	}
 };
 //#endregion
+//#region src/scope/resolver.ts
+const execFileAsync = (0, node_util.promisify)(node_child_process.execFile);
+function sha256Truncated(input) {
+	return (0, node_crypto.createHash)("sha256").update(input).digest("hex").slice(0, 16);
+}
+async function resolveProject() {
+	try {
+		const { stdout } = await execFileAsync("git", [
+			"remote",
+			"get-url",
+			"origin"
+		]);
+		const url = stdout.trim();
+		if (url) {
+			const hash = sha256Truncated(url);
+			return {
+				hash,
+				name: url.split("/").pop()?.replace(/\.git$/, "") ?? hash.slice(0, 8)
+			};
+		}
+	} catch {}
+	const cwd = process.cwd();
+	const hash = sha256Truncated(cwd);
+	return {
+		hash,
+		name: cwd.split(/[/\\]/).filter(Boolean).pop() ?? hash.slice(0, 8)
+	};
+}
+async function resolveScope() {
+	try {
+		const { stdout } = await execFileAsync("git", [
+			"remote",
+			"get-url",
+			"origin"
+		]);
+		const url = stdout.trim();
+		if (url) return sha256Truncated(url);
+	} catch {}
+	return sha256Truncated(process.cwd());
+}
+//#endregion
+//#region src/migrations/index.ts
+const MIGRATIONS = [{
+	name: "scope-to-projects",
+	description: "Rename the auto-migrated project for the current directory from its generic hash-derived name to the resolved repo/directory name."
+}];
+async function runScopeToProjectsMigration(projects) {
+	const resolved = await resolveProject();
+	const project = projects.getByHash(resolved.hash);
+	if (project === void 0) return null;
+	const oldName = project.name;
+	const memoryCount = projects.countMemories(project.id);
+	projects.rename(project.id, resolved.name);
+	return {
+		migration: "scope-to-projects",
+		oldName,
+		newName: resolved.name,
+		memoryCount
+	};
+}
+//#endregion
 //#region src/project/repository.ts
 var ProjectRepository = class {
 	#db;
@@ -339,7 +472,7 @@ var ProjectRepository = class {
 		const now = (/* @__PURE__ */ new Date()).toISOString();
 		const id = (0, node_crypto.randomUUID)();
 		this.#db.db.prepare(`INSERT OR IGNORE INTO projects (id, name, scope_hash, created_at, updated_at) VALUES (?, ?, ?, ?, ?)`).run(id, name, hash, now, now);
-		return rowToProject(this.#db.db.prepare(`SELECT * FROM projects WHERE scope_hash = ?`).get(hash));
+		return rowToProject(ProjectRowSchema.parse(this.#db.db.prepare(`SELECT * FROM projects WHERE scope_hash = ?`).get(hash)));
 	}
 	rename(id, name) {
 		const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -361,6 +494,9 @@ var ProjectRepository = class {
 	removeAssociation(memoryId, projectId) {
 		this.#db.db.prepare(`DELETE FROM memory_projects WHERE memory_id = ? AND project_id = ?`).run(memoryId, projectId);
 	}
+	countMemories(projectId) {
+		return this.#db.db.prepare(`SELECT COUNT(*) AS count FROM memory_projects WHERE project_id = ?`).get(projectId)?.count ?? 0;
+	}
 	getProjectsForMemories(memoryIds) {
 		if (memoryIds.length === 0) return /* @__PURE__ */ new Map();
 		const placeholders = memoryIds.map(() => "?").join(",");
@@ -395,12 +531,13 @@ var QueryEngine = class {
 		this.#repo = repo;
 	}
 	async query(options) {
-		const { query, type, projectHash, limit = 10 } = options;
+		const { query, type, projectHash, limit = 10, includePinned } = QueryOptionsSchema.parse(options);
 		const queryEmbedding = await this.#embedding.embed(query);
 		const queryBlob = Buffer.from(queryEmbedding.buffer);
 		const whereClauses = [];
 		const params = [queryBlob];
 		let joinClause = "";
+		if (!includePinned) whereClauses.push("m.pinned = 0");
 		if (type !== void 0) {
 			whereClauses.push("m.type = ?");
 			params.push(type);
@@ -441,47 +578,6 @@ var QueryEngine = class {
 	}
 };
 //#endregion
-//#region src/scope/resolver.ts
-const execFileAsync = (0, node_util.promisify)(node_child_process.execFile);
-function sha256Truncated(input) {
-	return (0, node_crypto.createHash)("sha256").update(input).digest("hex").slice(0, 16);
-}
-async function resolveProject() {
-	try {
-		const { stdout } = await execFileAsync("git", [
-			"remote",
-			"get-url",
-			"origin"
-		]);
-		const url = stdout.trim();
-		if (url) {
-			const hash = sha256Truncated(url);
-			return {
-				hash,
-				name: url.split("/").pop()?.replace(/\.git$/, "") ?? hash.slice(0, 8)
-			};
-		}
-	} catch {}
-	const cwd = process.cwd();
-	const hash = sha256Truncated(cwd);
-	return {
-		hash,
-		name: cwd.split(/[/\\]/).filter(Boolean).pop() ?? hash.slice(0, 8)
-	};
-}
-async function resolveScope() {
-	try {
-		const { stdout } = await execFileAsync("git", [
-			"remote",
-			"get-url",
-			"origin"
-		]);
-		const url = stdout.trim();
-		if (url) return sha256Truncated(url);
-	} catch {}
-	return sha256Truncated(process.cwd());
-}
-//#endregion
 //#region src/session/builder.ts
 function listMemoryTypes() {
 	return [...MEMORY_TYPE_VALUES];
@@ -501,7 +597,10 @@ var SessionContextBuilder = class {
          WHERE p.scope_hash = ? AND m.pinned = 1`).all(projectHash).map((row) => rowToMemory(row, []));
 		const typeCounts = this.#db.db.prepare("SELECT type, COUNT(*) as count FROM memories GROUP BY type").all();
 		const stats = Object.fromEntries(MEMORY_TYPE_VALUES.map((t) => [t, 0]));
-		for (const row of typeCounts) if (stats[row.type] !== void 0) stats[row.type] = row.count;
+		for (const row of typeCounts) {
+			const parsed = MemoryTypeSchema.safeParse(row.type);
+			if (parsed.success) stats[parsed.data] = row.count;
+		}
 		return {
 			stats,
 			pinnedGlobal,
@@ -514,12 +613,25 @@ exports.DatabaseError = DatabaseError;
 exports.DatabaseManager = DatabaseManager;
 exports.EmbeddingService = EmbeddingService;
 exports.MEMORY_TYPE_VALUES = MEMORY_TYPE_VALUES;
+exports.MIGRATIONS = MIGRATIONS;
 exports.MembankError = MembankError;
+exports.MemoryPatchSchema = MemoryPatchSchema;
 exports.MemoryRepository = MemoryRepository;
+exports.MemoryRowSchema = MemoryRowSchema;
+exports.MemorySchema = MemorySchema;
+exports.MemoryTypeSchema = MemoryTypeSchema;
 exports.ProjectRepository = ProjectRepository;
+exports.ProjectRowSchema = ProjectRowSchema;
+exports.ProjectSchema = ProjectSchema;
 exports.QueryEngine = QueryEngine;
+exports.QueryOptionsSchema = QueryOptionsSchema;
+exports.SaveOptionsSchema = SaveOptionsSchema;
 exports.SessionContextBuilder = SessionContextBuilder;
+exports.SessionContextSchema = SessionContextSchema;
+exports.TagsJsonSchema = TagsJsonSchema;
 exports.listMemoryTypes = listMemoryTypes;
 exports.resolveProject = resolveProject;
 exports.resolveScope = resolveScope;
 exports.rowToMemory = rowToMemory;
+exports.rowToProject = rowToProject;
+exports.runScopeToProjectsMigration = runScopeToProjectsMigration;

package/dist/index.d.cts

@@ -1,4 +1,5 @@
 import BetterSqlite3 from "better-sqlite3";
+import { z } from "zod";
 
 //#region src/db/errors.d.ts
 declare class MembankError extends Error {
@@ -21,62 +22,172 @@ declare class DatabaseManager {
   close(): void;
 }
 //#endregion
-//#region src/types.d.ts
-type MemoryType = "correction" | "preference" | "decision" | "learning" | "fact";
+//#region src/schemas.d.ts
 declare const MEMORY_TYPE_VALUES: readonly ["correction", "preference", "decision", "learning", "fact"];
-interface Project {
-  id: string;
-  name: string;
-  scopeHash: string;
-  createdAt: string;
-  updatedAt: string;
-}
-interface Memory {
-  id: string;
-  content: string;
-  type: MemoryType;
-  tags: string[];
-  projects: Project[];
-  sourceHarness: string | null;
-  accessCount: number;
-  pinned: boolean;
-  needsReview: boolean;
-  createdAt: string;
-  updatedAt: string;
-}
-interface QueryOptions {
-  query: string;
-  type?: MemoryType;
-  projectHash?: string;
-  limit?: number;
-}
-interface SaveOptions {
-  content: string;
-  type: MemoryType;
-  tags?: string[];
-  projectHash?: string;
-  sourceHarness?: string;
-}
-interface SessionContext {
-  stats: Record<MemoryType, number>;
-  pinnedGlobal: Memory[];
-  pinnedProject: Memory[];
-}
+declare const MemoryTypeSchema: z.ZodEnum<{
+  correction: "correction";
+  preference: "preference";
+  decision: "decision";
+  learning: "learning";
+  fact: "fact";
+}>;
+type MemoryType = z.infer<typeof MemoryTypeSchema>;
+declare const TagsJsonSchema: z.ZodArray<z.ZodString>;
+declare const ProjectSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  scopeHash: z.ZodString;
+  createdAt: z.ZodString;
+  updatedAt: z.ZodString;
+}, z.core.$strip>;
+type Project = z.infer<typeof ProjectSchema>;
+declare const MemorySchema: z.ZodObject<{
+  id: z.ZodString;
+  content: z.ZodString;
+  type: z.ZodEnum<{
+    correction: "correction";
+    preference: "preference";
+    decision: "decision";
+    learning: "learning";
+    fact: "fact";
+  }>;
+  tags: z.ZodArray<z.ZodString>;
+  projects: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    scopeHash: z.ZodString;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+  }, z.core.$strip>>;
+  sourceHarness: z.ZodNullable<z.ZodString>;
+  accessCount: z.ZodNumber;
+  pinned: z.ZodBoolean;
+  needsReview: z.ZodBoolean;
+  createdAt: z.ZodString;
+  updatedAt: z.ZodString;
+}, z.core.$strip>;
+type Memory = z.infer<typeof MemorySchema>;
+declare const QueryOptionsSchema: z.ZodObject<{
+  query: z.ZodString;
+  type: z.ZodOptional<z.ZodEnum<{
+    correction: "correction";
+    preference: "preference";
+    decision: "decision";
+    learning: "learning";
+    fact: "fact";
+  }>>;
+  projectHash: z.ZodOptional<z.ZodString>;
+  limit: z.ZodOptional<z.ZodNumber>;
+  includePinned: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type QueryOptions = z.infer<typeof QueryOptionsSchema>;
+declare const SaveOptionsSchema: z.ZodObject<{
+  content: z.ZodString;
+  type: z.ZodEnum<{
+    correction: "correction";
+    preference: "preference";
+    decision: "decision";
+    learning: "learning";
+    fact: "fact";
+  }>;
+  tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  projectScope: z.ZodOptional<z.ZodObject<{
+    hash: z.ZodString;
+    name: z.ZodString;
+  }, z.core.$strip>>;
+  sourceHarness: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type SaveOptions = z.infer<typeof SaveOptionsSchema>;
+declare const MemoryPatchSchema: z.ZodObject<{
+  content: z.ZodOptional<z.ZodString>;
+  tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type MemoryPatch = z.infer<typeof MemoryPatchSchema>;
+declare const SessionContextSchema: z.ZodObject<{
+  stats: z.ZodRecord<z.ZodEnum<{
+    correction: "correction";
+    preference: "preference";
+    decision: "decision";
+    learning: "learning";
+    fact: "fact";
+  }>, z.ZodNumber>;
+  pinnedGlobal: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    content: z.ZodString;
+    type: z.ZodEnum<{
+      correction: "correction";
+      preference: "preference";
+      decision: "decision";
+      learning: "learning";
+      fact: "fact";
+    }>;
+    tags: z.ZodArray<z.ZodString>;
+    projects: z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+      scopeHash: z.ZodString;
+      createdAt: z.ZodString;
+      updatedAt: z.ZodString;
+    }, z.core.$strip>>;
+    sourceHarness: z.ZodNullable<z.ZodString>;
+    accessCount: z.ZodNumber;
+    pinned: z.ZodBoolean;
+    needsReview: z.ZodBoolean;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+  }, z.core.$strip>>;
+  pinnedProject: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    content: z.ZodString;
+    type: z.ZodEnum<{
+      correction: "correction";
+      preference: "preference";
+      decision: "decision";
+      learning: "learning";
+      fact: "fact";
+    }>;
+    tags: z.ZodArray<z.ZodString>;
+    projects: z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+      scopeHash: z.ZodString;
+      createdAt: z.ZodString;
+      updatedAt: z.ZodString;
+    }, z.core.$strip>>;
+    sourceHarness: z.ZodNullable<z.ZodString>;
+    accessCount: z.ZodNumber;
+    pinned: z.ZodBoolean;
+    needsReview: z.ZodBoolean;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type SessionContext = z.infer<typeof SessionContextSchema>;
+declare const MemoryRowSchema: z.ZodObject<{
+  id: z.ZodString;
+  content: z.ZodString;
+  type: z.ZodString;
+  tags: z.ZodString;
+  source: z.ZodNullable<z.ZodString>;
+  access_count: z.ZodNumber;
+  pinned: z.ZodNumber;
+  needs_review: z.ZodNumber;
+  created_at: z.ZodString;
+  updated_at: z.ZodString;
+}, z.core.$strip>;
+type MemoryRow = z.infer<typeof MemoryRowSchema>;
+declare const ProjectRowSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  scope_hash: z.ZodString;
+  created_at: z.ZodString;
+  updated_at: z.ZodString;
+}, z.core.$strip>;
+type ProjectRow = z.infer<typeof ProjectRowSchema>;
 //#endregion
 //#region src/db/row-types.d.ts
-interface MemoryRow {
-  id: string;
-  content: string;
-  type: string;
-  tags: string;
-  source: string | null;
-  access_count: number;
-  pinned: number;
-  needs_review: number;
-  created_at: string;
-  updated_at: string;
-}
 declare function rowToMemory(row: MemoryRow, projects: Project[]): Memory;
+declare function rowToProject(row: ProjectRow): Project;
 //#endregion
 //#region src/embedding/service.d.ts
 type ProgressCallback = (progress: {
@@ -102,6 +213,7 @@ declare class ProjectRepository {
   getByHash(hash: string): Project | undefined;
   addAssociation(memoryId: string, projectId: string): void;
   removeAssociation(memoryId: string, projectId: string): void;
+  countMemories(projectId: string): number;
   getProjectsForMemories(memoryIds: string[]): Map<string, Project[]>;
 }
 //#endregion
@@ -110,10 +222,7 @@ declare class MemoryRepository {
   #private;
   constructor(db: DatabaseManager, embeddingService: EmbeddingService, projects: ProjectRepository);
   save(options: SaveOptions): Promise<Memory>;
-  update(id: string, patch: {
-    content?: string;
-    tags?: string[];
-  }): Promise<Memory>;
+  update(id: string, patch: MemoryPatch): Promise<Memory>;
   delete(id: string): Promise<void>;
   list(opts?: {
     type?: MemoryType;
@@ -128,6 +237,20 @@ declare class MemoryRepository {
   incrementAccessCount(id: string): void;
 }
 //#endregion
+//#region src/migrations/index.d.ts
+interface MigrationMeta {
+  name: string;
+  description: string;
+}
+interface ScopeToProjectsResult {
+  migration: "scope-to-projects";
+  oldName: string;
+  newName: string;
+  memoryCount: number;
+}
+declare const MIGRATIONS: MigrationMeta[];
+declare function runScopeToProjectsMigration(projects: ProjectRepository): Promise<ScopeToProjectsResult | null>;
+//#endregion
 //#region src/query/engine.d.ts
 declare class QueryEngine {
   #private;
@@ -152,5 +275,5 @@ declare class SessionContextBuilder {
   getSessionContext(projectHash: string): SessionContext;
 }
 //#endregion
-export { DatabaseError, DatabaseManager, EmbeddingService, MEMORY_TYPE_VALUES, MembankError, Memory, MemoryRepository, type MemoryRow, MemoryType, ProgressCallback, Project, ProjectRepository, QueryEngine, QueryOptions, SaveOptions, SessionContext, SessionContextBuilder, listMemoryTypes, resolveProject, resolveScope, rowToMemory };
+export { DatabaseError, DatabaseManager, EmbeddingService, MEMORY_TYPE_VALUES, MIGRATIONS, MembankError, Memory, MemoryPatch, MemoryPatchSchema, MemoryRepository, MemoryRow, MemoryRowSchema, MemorySchema, MemoryType, MemoryTypeSchema, MigrationMeta, ProgressCallback, Project, ProjectRepository, ProjectRow, ProjectRowSchema, ProjectSchema, QueryEngine, QueryOptions, QueryOptionsSchema, SaveOptions, SaveOptionsSchema, ScopeToProjectsResult, SessionContext, SessionContextBuilder, SessionContextSchema, TagsJsonSchema, listMemoryTypes, resolveProject, resolveScope, rowToMemory, rowToProject, runScopeToProjectsMigration };
 //# sourceMappingURL=index.d.cts.map