@kodrunhq/opencode-autopilot 1.15.2 → 1.16.0

package/src/kernel/schema.ts

@@ -0,0 +1,122 @@
+export const KERNEL_SCHEMA_VERSION = 1;
+
+export const KERNEL_SCHEMA_STATEMENTS: readonly string[] = Object.freeze([
+	`CREATE TABLE IF NOT EXISTS pipeline_runs (
+		project_id TEXT NOT NULL,
+		run_id TEXT PRIMARY KEY,
+		schema_version INTEGER NOT NULL,
+		status TEXT NOT NULL,
+		current_phase TEXT,
+		idea TEXT NOT NULL,
+		state_revision INTEGER NOT NULL,
+		started_at TEXT NOT NULL,
+		last_updated_at TEXT NOT NULL,
+		failure_phase TEXT,
+		failure_agent TEXT,
+		failure_message TEXT,
+		last_successful_phase TEXT,
+		state_json TEXT NOT NULL,
+		FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
+	)`,
+	`CREATE INDEX IF NOT EXISTS idx_pipeline_runs_project_updated_at ON pipeline_runs(project_id, last_updated_at DESC, run_id DESC)`,
+	`CREATE TABLE IF NOT EXISTS run_phases (
+		run_id TEXT NOT NULL,
+		phase_name TEXT NOT NULL,
+		status TEXT NOT NULL,
+		completed_at TEXT,
+		confidence TEXT,
+		PRIMARY KEY (run_id, phase_name),
+		FOREIGN KEY (run_id) REFERENCES pipeline_runs(run_id) ON DELETE CASCADE
+	)`,
+	`CREATE TABLE IF NOT EXISTS run_tasks (
+		run_id TEXT NOT NULL,
+		task_id INTEGER NOT NULL,
+		title TEXT NOT NULL,
+		status TEXT NOT NULL,
+		wave INTEGER NOT NULL,
+		depends_on_json TEXT NOT NULL,
+		attempt INTEGER NOT NULL,
+		strike INTEGER NOT NULL,
+		PRIMARY KEY (run_id, task_id),
+		FOREIGN KEY (run_id) REFERENCES pipeline_runs(run_id) ON DELETE CASCADE
+	)`,
+	`CREATE TABLE IF NOT EXISTS run_pending_dispatches (
+		run_id TEXT NOT NULL,
+		dispatch_id TEXT NOT NULL,
+		phase TEXT NOT NULL,
+		agent TEXT NOT NULL,
+		issued_at TEXT NOT NULL,
+		result_kind TEXT NOT NULL,
+		task_id INTEGER,
+		PRIMARY KEY (run_id, dispatch_id),
+		FOREIGN KEY (run_id) REFERENCES pipeline_runs(run_id) ON DELETE CASCADE
+	)`,
+	`CREATE TABLE IF NOT EXISTS run_processed_results (
+		run_id TEXT NOT NULL,
+		result_id TEXT NOT NULL,
+		PRIMARY KEY (run_id, result_id),
+		FOREIGN KEY (run_id) REFERENCES pipeline_runs(run_id) ON DELETE CASCADE
+	)`,
+	`CREATE TABLE IF NOT EXISTS active_review_state (
+		project_id TEXT PRIMARY KEY,
+		stage INTEGER NOT NULL,
+		scope TEXT NOT NULL,
+		started_at TEXT NOT NULL,
+		saved_at TEXT NOT NULL,
+		state_json TEXT NOT NULL,
+		FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
+	)`,
+	`CREATE TABLE IF NOT EXISTS project_review_memory (
+		project_id TEXT PRIMARY KEY,
+		schema_version INTEGER NOT NULL,
+		last_reviewed_at TEXT,
+		state_json TEXT NOT NULL,
+		FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
+	)`,
+	`CREATE TABLE IF NOT EXISTS project_lesson_memory (
+		project_id TEXT PRIMARY KEY,
+		schema_version INTEGER NOT NULL,
+		last_updated_at TEXT,
+		state_json TEXT NOT NULL,
+		FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
+	)`,
+	`CREATE TABLE IF NOT EXISTS project_lessons (
+		lesson_id INTEGER PRIMARY KEY AUTOINCREMENT,
+		project_id TEXT NOT NULL,
+		content TEXT NOT NULL,
+		domain TEXT NOT NULL,
+		extracted_at TEXT NOT NULL,
+		source_phase TEXT NOT NULL,
+		last_updated_at TEXT,
+		FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE,
+		UNIQUE(project_id, extracted_at, domain, source_phase, content)
+	)`,
+	`CREATE INDEX IF NOT EXISTS idx_project_lessons_project_extracted_at ON project_lessons(project_id, extracted_at DESC, lesson_id DESC)`,
+	`CREATE INDEX IF NOT EXISTS idx_project_lessons_domain ON project_lessons(project_id, domain, extracted_at DESC, lesson_id DESC)`,
+	`CREATE TABLE IF NOT EXISTS forensic_events (
+		event_id INTEGER PRIMARY KEY AUTOINCREMENT,
+		project_id TEXT NOT NULL,
+		schema_version INTEGER NOT NULL,
+		timestamp TEXT NOT NULL,
+		project_root TEXT NOT NULL,
+		domain TEXT NOT NULL,
+		run_id TEXT,
+		session_id TEXT,
+		parent_session_id TEXT,
+		phase TEXT,
+		dispatch_id TEXT,
+		task_id INTEGER,
+		agent TEXT,
+		type TEXT NOT NULL,
+		code TEXT,
+		message TEXT,
+		payload_json TEXT NOT NULL,
+		FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
+	)`,
+	`CREATE INDEX IF NOT EXISTS idx_forensic_events_timestamp ON forensic_events(timestamp, event_id)`,
+	`CREATE INDEX IF NOT EXISTS idx_forensic_events_project ON forensic_events(project_id, timestamp, event_id)`,
+	`CREATE INDEX IF NOT EXISTS idx_forensic_events_session ON forensic_events(session_id, timestamp, event_id)`,
+	`CREATE INDEX IF NOT EXISTS idx_forensic_events_run ON forensic_events(run_id, timestamp, event_id)`,
+	`CREATE INDEX IF NOT EXISTS idx_forensic_events_dispatch ON forensic_events(dispatch_id, timestamp, event_id)`,
+	`CREATE INDEX IF NOT EXISTS idx_forensic_events_type ON forensic_events(type, timestamp, event_id)`,
+]);

package/src/kernel/types.ts

@@ -0,0 +1,66 @@
+import type { ForensicEvent } from "../observability/forensic-types";
+import type { LessonMemory } from "../orchestrator/lesson-types";
+import type { PipelineState } from "../orchestrator/types";
+import type { ReviewMemory, ReviewState } from "../review/types";
+
+export const KERNEL_STATE_CONFLICT_CODE = "E_STATE_CONFLICT";
+
+export interface PipelineRunRow {
+	readonly project_id: string;
+	readonly run_id: string;
+	readonly schema_version: number;
+	readonly status: PipelineState["status"];
+	readonly current_phase: string | null;
+	readonly idea: string;
+	readonly state_revision: number;
+	readonly started_at: string;
+	readonly last_updated_at: string;
+	readonly failure_phase: string | null;
+	readonly failure_agent: string | null;
+	readonly failure_message: string | null;
+	readonly last_successful_phase: string | null;
+	readonly state_json: string;
+}
+
+export interface ActiveReviewStateRow {
+	readonly project_id: string;
+	readonly stage: ReviewState["stage"];
+	readonly scope: string;
+	readonly started_at: string;
+	readonly saved_at: string;
+	readonly state_json: string;
+}
+
+export interface ProjectReviewMemoryRow {
+	readonly project_id: string;
+	readonly schema_version: number;
+	readonly last_reviewed_at: string | null;
+	readonly state_json: string;
+}
+
+export interface ProjectLessonMemoryRow {
+	readonly project_id: string;
+	readonly schema_version: number;
+	readonly last_updated_at: string | null;
+	readonly state_json: string;
+}
+
+export interface ForensicEventRow {
+	readonly event_id: number;
+	readonly project_id: string;
+	readonly schema_version: number;
+	readonly timestamp: string;
+	readonly project_root: string;
+	readonly domain: ForensicEvent["domain"];
+	readonly run_id: string | null;
+	readonly session_id: string | null;
+	readonly parent_session_id: string | null;
+	readonly phase: string | null;
+	readonly dispatch_id: string | null;
+	readonly task_id: number | null;
+	readonly agent: string | null;
+	readonly type: ForensicEvent["type"];
+	readonly code: string | null;
+	readonly message: string | null;
+	readonly payload_json: string;
+}

package/src/memory/capture.ts

@@ -1,34 +1,38 @@
 /**
- * Event capture handler for memory observations.
+ * Memory capture handlers.
  *
- * Subscribes to OpenCode session events and extracts memory-worthy
- * observations from decision, error, and phase_transition events.
- * Noisy events (tool_complete, context_warning, session_start/end)
- * are filtered out per Research Pitfall 4.
- *
- * Factory pattern matches createObservabilityEventHandler in
- * src/observability/event-handlers.ts.
+ * Event capture remains a supporting path for project incidents and decisions.
+ * Explicit user preference capture happens on the chat.message hook where the
+ * actual outbound user-authored text parts are available.
  *
  * @module
  */
 
 import type { Database } from "bun:sqlite";
 import { basename } from "node:path";
+import { resolveProjectIdentity } from "../projects/resolve";
 import { pruneStaleObservations } from "./decay";
-import { computeProjectKey } from "./project-key";
-import { insertObservation, upsertProject } from "./repository";
+import { insertObservation, upsertPreferenceRecord, upsertProject } from "./repository";
 import type { ObservationType } from "./types";
 
 /**
- * Dependencies for the memory capture handler.
+ * Dependencies for the memory capture handlers.
  */
 export interface MemoryCaptureDeps {
 	readonly getDb: () => Database;
 	readonly projectRoot: string;
 }
 
+interface PreferenceCandidate {
+	readonly key: string;
+	readonly value: string;
+	readonly scope: "global" | "project";
+	readonly confidence: number;
+	readonly statement: string;
+}
+
 /**
- * Events that produce memory observations.
+ * Events that produce supporting observations.
  */
 const CAPTURE_EVENT_TYPES = new Set([
 	"session.created",
@@ -38,6 +42,33 @@ const CAPTURE_EVENT_TYPES = new Set([
 	"app.phase_transition",
 ]);
 
+const PROJECT_SCOPE_HINTS = [
+	"in this repo",
+	"for this repo",
+	"in this project",
+	"for this project",
+	"in this codebase",
+	"for this codebase",
+	"here ",
+	"this repo ",
+	"this project ",
+] as const;
+
+const EXPLICIT_PREFERENCE_PATTERNS = [
+	{
+		regex: /\b(?:please|do|always|generally)\s+(?:use|prefer|keep|run|avoid)\s+(.+?)(?:[.!?]|$)/i,
+		buildValue: (match: RegExpMatchArray) => match[1]?.trim() ?? "",
+	},
+	{
+		regex: /\b(?:i|we)\s+(?:prefer|want|need|like)\s+(.+?)(?:[.!?]|$)/i,
+		buildValue: (match: RegExpMatchArray) => match[1]?.trim() ?? "",
+	},
+	{
+		regex: /\b(?:don't|do not|never)\s+(.+?)(?:[.!?]|$)/i,
+		buildValue: (match: RegExpMatchArray) => `avoid ${match[1]?.trim() ?? ""}`,
+	},
+] as const;
+
 /**
  * Extracts a session ID from event properties.
  * Supports properties.sessionID, properties.info.id, properties.info.sessionID.
@@ -52,6 +83,107 @@ function extractSessionId(properties: Record<string, unknown>): string | undefin
 	return undefined;
 }
 
+function normalizePreferenceKey(value: string): string {
+	const normalized = value
+		.toLowerCase()
+		.replace(/[^a-z0-9]+/g, " ")
+		.trim()
+		.split(/\s+/)
+		.slice(0, 6)
+		.join(".");
+	return normalized.length > 0 ? normalized : "user.preference";
+}
+
+function normalizePreferenceValue(value: string): string {
+	return value
+		.replace(/\s+/g, " ")
+		.trim()
+		.replace(/[.!?]+$/, "");
+}
+
+function inferPreferenceScope(text: string): "global" | "project" {
+	const lowerText = text.toLowerCase();
+	return PROJECT_SCOPE_HINTS.some((hint) => lowerText.includes(hint)) ? "project" : "global";
+}
+
+function extractTextPartContent(part: unknown): string | null {
+	if (part === null || typeof part !== "object") {
+		return null;
+	}
+
+	const record = part as Record<string, unknown>;
+	if (record.type !== "text") {
+		return null;
+	}
+
+	if (typeof record.text === "string" && record.text.trim().length > 0) {
+		return record.text;
+	}
+	if (typeof record.content === "string" && record.content.trim().length > 0) {
+		return record.content;
+	}
+
+	return null;
+}
+
+function extractExplicitPreferenceCandidates(
+	parts: readonly unknown[],
+): readonly PreferenceCandidate[] {
+	const joinedText = parts
+		.map(extractTextPartContent)
+		.filter((value): value is string => value !== null)
+		.join("\n")
+		.trim();
+	if (joinedText.length === 0) {
+		return Object.freeze([]);
+	}
+
+	const candidates: PreferenceCandidate[] = [];
+	const scope = inferPreferenceScope(joinedText);
+	const lines = joinedText
+		.split(/\n+/)
+		.flatMap((line) => line.split(/(?<=[.!?])\s+/))
+		.map((line) => line.trim())
+		.filter((line) => line.length > 0 && line.length <= 500);
+
+	for (const line of lines) {
+		for (const pattern of EXPLICIT_PREFERENCE_PATTERNS) {
+			const match = line.match(pattern.regex);
+			if (!match) {
+				continue;
+			}
+
+			const value = normalizePreferenceValue(pattern.buildValue(match));
+			if (value.length < 6) {
+				continue;
+			}
+
+			candidates.push(
+				Object.freeze({
+					key: normalizePreferenceKey(value),
+					value,
+					scope,
+					confidence: 0.9,
+					statement: line,
+				}),
+			);
+			break;
+		}
+	}
+
+	const seen = new Set<string>();
+	return Object.freeze(
+		candidates.filter((candidate) => {
+			const uniqueness = `${candidate.scope}:${candidate.key}:${candidate.value}`;
+			if (seen.has(uniqueness)) {
+				return false;
+			}
+			seen.add(uniqueness);
+			return true;
+		}),
+	);
+}
+
 /**
  * Safely truncate a string to maxLen characters.
  */
@@ -60,12 +192,7 @@ function truncate(s: string, maxLen: number): string {
 }
 
 /**
- * Creates a memory capture handler that subscribes to OpenCode events.
- *
- * Returns an async function matching the event handler signature:
- * `(input: { event: { type: string; [key: string]: unknown } }) => Promise<void>`
- *
- * Pure observer: never modifies the event or session output.
+ * Creates an event capture handler matching the plugin event hook signature.
  */
 export function createMemoryCaptureHandler(deps: MemoryCaptureDeps) {
 	let currentSessionId: string | null = null;
@@ -110,7 +237,6 @@ export function createMemoryCaptureHandler(deps: MemoryCaptureDeps) {
 				? (rawProps as Record<string, unknown>)
 				: {};
 
-		// Skip noisy events early
 		if (!CAPTURE_EVENT_TYPES.has(event.type)) return;
 
 		switch (event.type) {
@@ -121,7 +247,10 @@ export function createMemoryCaptureHandler(deps: MemoryCaptureDeps) {
 				if (!info.id) return;
 
 				currentSessionId = info.id;
-				currentProjectKey = computeProjectKey(deps.projectRoot);
+				const resolvedProject = await resolveProjectIdentity(deps.projectRoot, {
+					db: deps.getDb(),
+				});
+				currentProjectKey = resolvedProject.id;
 				const projectName = basename(deps.projectRoot);
 
 				try {
@@ -130,6 +259,7 @@ export function createMemoryCaptureHandler(deps: MemoryCaptureDeps) {
 							id: currentProjectKey,
 							path: deps.projectRoot,
 							name: projectName,
+							firstSeenAt: resolvedProject.firstSeenAt,
 							lastUpdated: now(),
 						},
 						deps.getDb(),
@@ -144,12 +274,9 @@ export function createMemoryCaptureHandler(deps: MemoryCaptureDeps) {
 				const projectKey = currentProjectKey;
 				const db = deps.getDb();
 
-				// Reset state
 				currentSessionId = null;
 				currentProjectKey = null;
 
-				// Defer pruning to avoid blocking the session.deleted handler.
-				// Best-effort: will not run if the process exits before this microtask drains.
 				if (projectKey) {
 					queueMicrotask(() => {
 						try {
@@ -197,9 +324,8 @@ export function createMemoryCaptureHandler(deps: MemoryCaptureDeps) {
 					typeof properties.fromPhase === "string" ? properties.fromPhase : "unknown";
 				const toPhase = typeof properties.toPhase === "string" ? properties.toPhase : "unknown";
 				const content = `Phase transition: ${fromPhase} -> ${toPhase}`;
-				const summary = content;
 
-				safeInsert("pattern", content, summary, 0.6);
+				safeInsert("pattern", content, content, 0.6);
 				return;
 			}
 
@@ -208,3 +334,73 @@ export function createMemoryCaptureHandler(deps: MemoryCaptureDeps) {
 		}
 	};
 }
+
+/**
+ * Creates a chat.message capture handler that records explicit user preferences.
+ */
+export function createMemoryChatMessageHandler(deps: MemoryCaptureDeps) {
+	return async (
+		input: { readonly sessionID: string },
+		output: { readonly parts: unknown[] },
+	): Promise<void> => {
+		try {
+			const candidates = extractExplicitPreferenceCandidates(output.parts);
+			if (candidates.length === 0) {
+				return;
+			}
+
+			const resolvedProject = await resolveProjectIdentity(deps.projectRoot, {
+				db: deps.getDb(),
+			});
+			const projectName = basename(deps.projectRoot);
+			const timestamp = new Date().toISOString();
+
+			upsertProject(
+				{
+					id: resolvedProject.id,
+					path: deps.projectRoot,
+					name: projectName,
+					firstSeenAt: resolvedProject.firstSeenAt,
+					lastUpdated: timestamp,
+				},
+				deps.getDb(),
+			);
+
+			for (const candidate of candidates) {
+				upsertPreferenceRecord(
+					{
+						key: candidate.key,
+						value: candidate.value,
+						scope: candidate.scope,
+						projectId: candidate.scope === "project" ? resolvedProject.id : null,
+						status: "confirmed",
+						confidence: candidate.confidence,
+						sourceSession: input.sessionID,
+						createdAt: timestamp,
+						lastUpdated: timestamp,
+						evidence: [
+							{
+								sessionId: input.sessionID,
+								statement: candidate.statement,
+								confidence: candidate.confidence,
+								confirmed: true,
+								createdAt: timestamp,
+							},
+						],
+					},
+					deps.getDb(),
+				);
+			}
+		} catch (err) {
+			console.warn("[opencode-autopilot] explicit preference capture failed:", err);
+		}
+	};
+}
+
+export const memoryCaptureInternals = Object.freeze({
+	extractExplicitPreferenceCandidates,
+	extractTextPartContent,
+	inferPreferenceScope,
+	normalizePreferenceKey,
+	normalizePreferenceValue,
+});

package/src/memory/database.ts

@@ -1,8 +1,8 @@
 import { Database } from "bun:sqlite";
 import { mkdirSync } from "node:fs";
-import { join } from "node:path";
-import { getGlobalConfigDir } from "../utils/paths";
-import { DB_FILE, MEMORY_DIR } from "./constants";
+import { dirname } from "node:path";
+import { runProjectRegistryMigrations } from "../projects/database";
+import { getAutopilotDbPath } from "../utils/paths";
 
 let db: Database | null = null;
 
@@ -11,12 +11,7 @@ let db: Database | null = null;
  * Idempotent via IF NOT EXISTS.
  */
 export function initMemoryDb(database: Database): void {
-	database.run(`CREATE TABLE IF NOT EXISTS projects (
-		id TEXT PRIMARY KEY,
-		path TEXT NOT NULL UNIQUE,
-		name TEXT NOT NULL,
-		last_updated TEXT NOT NULL
-	)`);
+	runProjectRegistryMigrations(database);
 
 	database.run(`CREATE TABLE IF NOT EXISTS observations (
 		id INTEGER PRIMARY KEY,
@@ -42,6 +37,73 @@ export function initMemoryDb(database: Database): void {
 		last_updated TEXT NOT NULL
 	)`);
 
+	database.run(`CREATE TABLE IF NOT EXISTS preference_records (
+		id TEXT PRIMARY KEY,
+		key TEXT NOT NULL,
+		value TEXT NOT NULL,
+		scope TEXT NOT NULL CHECK(scope IN ('global', 'project')),
+		project_id TEXT,
+		status TEXT NOT NULL CHECK(status IN ('candidate', 'confirmed', 'rejected')) DEFAULT 'confirmed',
+		confidence REAL NOT NULL DEFAULT 0.5,
+		source_session TEXT,
+		created_at TEXT NOT NULL,
+		last_updated TEXT NOT NULL,
+		FOREIGN KEY (project_id) REFERENCES projects(id),
+		UNIQUE(key, scope, project_id)
+	)`);
+
+	database.run(`CREATE INDEX IF NOT EXISTS idx_preference_records_scope_updated
+		ON preference_records(scope, last_updated DESC, key ASC)`);
+	database.run(`CREATE INDEX IF NOT EXISTS idx_preference_records_project_updated
+		ON preference_records(project_id, last_updated DESC, key ASC)`);
+
+	database.run(`CREATE TABLE IF NOT EXISTS preference_evidence (
+		id TEXT PRIMARY KEY,
+		preference_id TEXT NOT NULL,
+		session_id TEXT,
+		run_id TEXT,
+		statement TEXT NOT NULL,
+		statement_hash TEXT NOT NULL,
+		confidence REAL NOT NULL DEFAULT 0.5,
+		confirmed INTEGER NOT NULL DEFAULT 0,
+		created_at TEXT NOT NULL,
+		FOREIGN KEY (preference_id) REFERENCES preference_records(id) ON DELETE CASCADE,
+		UNIQUE(preference_id, statement_hash)
+	)`);
+
+	database.run(`CREATE INDEX IF NOT EXISTS idx_preference_evidence_preference_created
+		ON preference_evidence(preference_id, created_at DESC, id DESC)`);
+
+	database.run(`INSERT INTO preference_records (
+		id,
+		key,
+		value,
+		scope,
+		project_id,
+		status,
+		confidence,
+		source_session,
+		created_at,
+		last_updated
+	)
+	SELECT
+		p.id,
+		p.key,
+		p.value,
+		'global',
+		NULL,
+		'confirmed',
+		p.confidence,
+		p.source_session,
+		p.created_at,
+		p.last_updated
+	FROM preferences p
+	WHERE NOT EXISTS (
+		SELECT 1
+		FROM preference_records pr
+		WHERE pr.id = p.id
+	)`);
+
 	database.run(`CREATE VIRTUAL TABLE IF NOT EXISTS observations_fts USING fts5(
 		content, summary,
 		content=observations,
@@ -79,9 +141,9 @@ export function getMemoryDb(dbPath?: string): Database {
 	const resolvedPath =
 		dbPath ??
 		(() => {
-			const memoryDir = join(getGlobalConfigDir(), MEMORY_DIR);
-			mkdirSync(memoryDir, { recursive: true });
-			return join(memoryDir, DB_FILE);
+			const runtimeDbPath = getAutopilotDbPath();
+			mkdirSync(dirname(runtimeDbPath), { recursive: true });
+			return runtimeDbPath;
 		})();
 
 	db = new Database(resolvedPath);

package/src/memory/index.ts

@@ -1,4 +1,9 @@
-export { createMemoryCaptureHandler, type MemoryCaptureDeps } from "./capture";
+export {
+	createMemoryCaptureHandler,
+	createMemoryChatMessageHandler,
+	type MemoryCaptureDeps,
+	memoryCaptureInternals,
+} from "./capture";
 export * from "./constants";
 export { closeMemoryDb, getMemoryDb, initMemoryDb } from "./database";
 export { computeRelevanceScore, pruneStaleObservations } from "./decay";
@@ -6,13 +11,24 @@ export { createMemoryInjector, type MemoryInjectorConfig } from "./injector";
 export { computeProjectKey } from "./project-key";
 export {
 	deleteObservation,
+	deletePreferenceRecord,
+	deletePreferencesByKey,
 	getAllPreferences,
+	getConfirmedPreferencesForProject,
 	getObservationsByProject,
+	getPreferenceRecordById,
 	getProjectByPath,
+	getRecentFailureObservations,
 	insertObservation,
+	listPreferenceEvidence,
+	listPreferenceRecords,
+	listRelevantLessons,
+	prunePreferenceEvidence,
+	prunePreferences,
 	searchObservations,
 	updateAccessCount,
 	upsertPreference,
+	upsertPreferenceRecord,
 	upsertProject,
 } from "./repository";
 export {

package/src/memory/project-key.ts

@@ -1,5 +1,11 @@
 import { createHash } from "node:crypto";
 
+/**
+ * Legacy path-hash project key.
+ *
+ * Kept only for migration compatibility while the runtime moves to the
+ * project registry / stable project identity model.
+ */
 export function computeProjectKey(projectPath: string): string {
 	return createHash("sha256").update(projectPath).digest("hex");
 }