@snoai/memory 0.0.0-stage → 1.0.0

package/dist/unplaced-candidate-migration-CbQHzcEM.js

@@ -0,0 +1,940 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { DEFAULT_IMPORTANCE } from "./internal/config/index.js";
+import { A as FIXED_MEMORY_ACTIVE_TASK_REVISIONS, B as FIXED_MEMORY_EXTRACTION_TIMESTAMPS, C as FIXED_IDX_MEMORY_MEMORIES_PROJECT_FACT_KEY_ACTIVE, D as FIXED_MEMORY_ACTIVE_TASK_INSTANCES, E as FIXED_MEMORY_ACTIVE_TASK_EVIDENCE, F as FIXED_MEMORY_CHUNKS_AU, G as FIXED_MEMORY_PROFILE_RECOVERY_ENTRIES, H as FIXED_MEMORY_MEMORIES_FACT_ID_INSERT_GUARD, I as FIXED_MEMORY_CHUNKS_FTS, J as FIXED_MEMORY_PROVIDER_PROJECT_MAPPINGS, K as FIXED_MEMORY_PROVIDER_AGENT_MAPPINGS, L as FIXED_MEMORY_CHUNKS_MEMORY_ID_IDX, M as FIXED_MEMORY_CHUNKS, N as FIXED_MEMORY_CHUNKS_AD, O as FIXED_MEMORY_ACTIVE_TASK_MIGRATION_EVIDENCE, P as FIXED_MEMORY_CHUNKS_AI, R as FIXED_MEMORY_CHUNKS_MEM_FACET_IDX, S as FIXED_IDX_MEMORY_MEMORIES_PROJECT_CONTENT_HASH, T as FIXED_MEMORY, U as FIXED_MEMORY_MEMORIES_FACT_ID_UPDATE_GUARD, V as FIXED_MEMORY_MEMORIES, W as FIXED_MEMORY_MIGRATION_MARKERS, _ as FIXED_IDX_MEMORY_MEMORIES_CATEGORY, a as FIXED_EXTERNAL_VALUE_54, b as FIXED_IDX_MEMORY_MEMORIES_LANE_PROJECT, bt as FIXED_VEC_MEMORY_CHUNKS, c as FIXED_EXTERNAL_VALUE_57, et as FIXED_MEMORY_TASK_LIFECYCLE_COMMANDS, g as FIXED_IDX_MEMORY_ACTIVE_TASK_INSTANCES_PROJECTION, h as FIXED_IDX_MEMORY_ACTIVE_TASK_EVIDENCE_INSTANCE, i as FIXED_EXTERNAL_VALUE_53, j as FIXED_MEMORY_ACTIVE_TASK_TRANSITIONS, k as FIXED_MEMORY_ACTIVE_TASK_MIGRATION_MANIFESTS, l as FIXED_EXTERNAL_VALUE_58, m as FIXED_IDX_MEMORY_ACTIVE_TASK_CURRENT_REVISION, n as FIXED_EXTERNAL_VALUE_51, o as FIXED_EXTERNAL_VALUE_55, p as FIXED_IDX_MEMORY, q as FIXED_MEMORY_PROVIDER_PROJECT_AGENTS, r as FIXED_EXTERNAL_VALUE_52, s as FIXED_EXTERNAL_VALUE_56, t as FIXED_EXTERNAL_VALUE_49, tt as FIXED_MEMORY_UNPLACED_CANDIDATES, u as FIXED_EXTERNAL_VALUE_62, v as FIXED_IDX_MEMORY_MEMORIES_CONTENT_HASH, w as FIXED_IDX_MEMORY_MEMORIES_PROJECT_TIMESTAMP, x as FIXED_IDX_MEMORY_MEMORIES_PROJECT, xt as PERSISTED_CANDIDATE_HASH_V1, y as FIXED_IDX_MEMORY_MEMORIES_FACT_ID, yt as FIXED_VEC_MEMORY, z as FIXED_MEMORY_CHUNKS_MEM_IDX } from "./signed-registry-constants-yq3DlG3B.js";
+import { StorageError } from "./internal/engine/shared/errors.js";
+import { stableHash } from "./internal/engine/shared/utils.js";
+import { createLogger } from "@snoai/utils/logger";
+import { dirname, join, resolve } from "node:path";
+import { randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { arch, platform } from "node:os";
+import { index, integer, primaryKey, real, sqliteTable, text } from "drizzle-orm/sqlite-core";
+import { arch as arch$1, platform as platform$1 } from "node:process";
+import { getLoadablePath } from "sqlite-vec";
+//#region src/store/entity-name-key-migration.ts
+/** @file entity-name-key-migration.ts
+* @purpose Re-keys entity names so several names can identify one entity.
+* @boundary Idempotent SQLite table rebuild only; no identity judgment.
+*/
+function isEntityNameKeyMigrationResult(value) {
+	if (typeof value !== "object" || value === null || !("status" in value)) return false;
+	return value.status === "migrated" || value.status === "noop";
+}
+const CREATE_ENTITY_TABLE_SQL = `
+CREATE TABLE nodix_memory_entities_cutover (
+	project_id TEXT NOT NULL,
+	entity_id TEXT NOT NULL,
+	display_name TEXT NOT NULL,
+	normalized_name TEXT NOT NULL,
+	created_at INTEGER NOT NULL,
+	PRIMARY KEY(project_id, normalized_name)
+) WITHOUT ROWID;
+`;
+const CREATE_ENTITY_INDEXES_SQL = `
+CREATE INDEX IF NOT EXISTS nodix_idx_memory_entities_display_name
+ON nodix_memory_entities(project_id, display_name);
+CREATE INDEX IF NOT EXISTS nodix_idx_memory_entities_entity_id
+ON nodix_memory_entities(project_id, entity_id);
+`;
+function migrationApplied(database) {
+	const columns = database.prepare("PRAGMA table_info(nodix_memory_entities)").all();
+	if (columns.length === 0) throw new StorageError("entity name key migration requires nodix_memory_entities");
+	const primaryKey = columns.filter((column) => column.pk > 0).sort((left, right) => left.pk - right.pk).map((column) => column.name);
+	return primaryKey[0] === "project_id" && primaryKey[1] === "normalized_name";
+}
+function applyEntityNameKeyMigration(database) {
+	if (migrationApplied(database)) {
+		database.exec(CREATE_ENTITY_INDEXES_SQL);
+		return { status: "noop" };
+	}
+	database.exec("PRAGMA foreign_keys = OFF");
+	try {
+		const result = database.transaction(() => {
+			if (migrationApplied(database)) return { status: "noop" };
+			database.exec(CREATE_ENTITY_TABLE_SQL);
+			database.exec(`
+				INSERT INTO nodix_memory_entities_cutover(
+					project_id, entity_id, display_name, normalized_name, created_at
+				)
+				SELECT project_id, entity_id, display_name, normalized_name, created_at
+				FROM nodix_memory_entities;
+			`);
+			database.exec("DROP TABLE nodix_memory_entities");
+			database.exec("ALTER TABLE nodix_memory_entities_cutover RENAME TO nodix_memory_entities");
+			database.exec(CREATE_ENTITY_INDEXES_SQL);
+			return { status: "migrated" };
+		}).immediate();
+		if (!isEntityNameKeyMigrationResult(result)) throw new StorageError("entity name key migration returned an invalid result");
+		return result;
+	} finally {
+		database.exec("PRAGMA foreign_keys = ON");
+	}
+}
+//#endregion
+//#region src/store/schema.ts
+/** @file schema.ts
+* @purpose Defines SQLite tables, indexes, and typed schema contracts for plugin storage.
+* @boundary Drizzle schema, migrations, and store query assumptions.
+* @see connection.ts, store.ts, memory-entry-projector.ts.
+*/
+var schema_exports = /* @__PURE__ */ __exportAll({
+	memoryEvents: () => memoryEvents,
+	memoryTelemetryIncidents: () => memoryTelemetryIncidents,
+	memoryTelemetrySyncState: () => memoryTelemetrySyncState,
+	memoryUsageOutbox: () => memoryUsageOutbox,
+	nodixAtomicExtractionLedger: () => nodixAtomicExtractionLedger,
+	nodixMemories: () => nodixMemories,
+	nodixMemoryEntities: () => nodixMemoryEntities,
+	nodixMemoryExtractionTimestamps: () => nodixMemoryExtractionTimestamps,
+	nodixMemoryRelations: () => nodixMemoryRelations,
+	nodixMemorySuppressions: () => nodixMemorySuppressions,
+	nodixProfileRecoveryEntries: () => nodixProfileRecoveryEntries,
+	nodixProviderAgentMappings: () => nodixProviderAgentMappings,
+	nodixProviderProjectAgents: () => nodixProviderProjectAgents,
+	nodixProviderProjectMappings: () => nodixProviderProjectMappings,
+	nodixTodoMigrationReceipts: () => nodixTodoMigrationReceipts,
+	nodixTodos: () => nodixTodos,
+	nodixUnplacedMemoryCandidates: () => nodixUnplacedMemoryCandidates
+});
+const nodixMemories = sqliteTable("nodix_memories", {
+	id: text("id").primaryKey(),
+	text: text("text").notNull(),
+	category: text("category").notNull(),
+	projectId: text("project_id").notNull(),
+	importance: real("importance").notNull().default(DEFAULT_IMPORTANCE),
+	timestamp: integer("timestamp").notNull(),
+	timezone: text("timezone").notNull(),
+	metadata: text("metadata").default("{}"),
+	contentHash: text("content_hash").notNull(),
+	factId: text("fact_id"),
+	derivedFrom: text("derived_from"),
+	consolidationEpochId: text("consolidation_epoch_id"),
+	confidenceSource: text("confidence_source"),
+	lane: text("lane", { enum: [
+		"active",
+		"parked",
+		"quarantined"
+	] }).notNull().default("active"),
+	rawCandidateJson: text("raw_candidate_json"),
+	dispositionReason: text("disposition_reason"),
+	dispositionedAtMs: integer("dispositioned_at_ms"),
+	subject: text("subject"),
+	attribute: text("attribute"),
+	validFrom: integer("valid_from"),
+	validUntil: integer("valid_until"),
+	maturity: text("maturity"),
+	source: text("source"),
+	extractorVersion: text("extractor_version")
+});
+const nodixMemoryExtractionTimestamps = sqliteTable("nodix_memory_extraction_timestamps", {
+	projectId: text("project_id").notNull(),
+	replayKey: text("replay_key").notNull(),
+	resolvedAtMs: integer("resolved_at_ms").notNull(),
+	timeSource: text("time_source", { enum: [
+		"event_at",
+		"session_time",
+		"first_resolution"
+	] })
+});
+const nodixMemoryRelations = sqliteTable("nodix_memory_relations", {
+	sourceCardId: text("source_card_id").notNull().references(() => nodixMemories.id, { onDelete: "cascade" }),
+	subject: text("subject").notNull(),
+	predicate: text("predicate", { enum: [
+		"IS_A",
+		"WORKS_ON",
+		"NEEDS",
+		"PREFERS",
+		"FORBIDS",
+		"USES",
+		"DEPENDS_ON",
+		"CAUSED",
+		"FIXED_BY",
+		"DECIDED",
+		"SUPERSEDES",
+		"GOVERNED_BY",
+		"OWNED_BY",
+		"MEMBER_OF",
+		"LOCATED_AT",
+		"HAS_SKILL",
+		"INTERESTED_IN",
+		"HAS_ACCOUNT",
+		"HAS_OCCUPATION",
+		"HAS_METRIC",
+		"WORKS_AT",
+		"ATTENDED",
+		"MENTIONS"
+	] }).notNull(),
+	object: text("object").notNull(),
+	createdAt: integer("created_at").notNull()
+});
+const nodixMemorySuppressions = sqliteTable("nodix_memory_suppressions", {
+	projectId: text("project_id").notNull(),
+	subject: text("subject"),
+	attribute: text("attribute"),
+	contentHash: text("content_hash"),
+	createdAt: integer("created_at").notNull()
+});
+const nodixTodos = sqliteTable("nodix_todos", {
+	projectId: text("project_id").notNull(),
+	activeTaskId: text("active_task_id").notNull(),
+	description: text("description").notNull(),
+	status: text("status", { enum: [
+		"open",
+		"done",
+		"removed"
+	] }).notNull(),
+	openedAt: integer("opened_at").notNull(),
+	transitionedAt: integer("transitioned_at").notNull(),
+	closedAt: integer("closed_at"),
+	closeReason: text("close_reason"),
+	sourceSession: text("source_session").notNull(),
+	extractionPath: text("extraction_path").notNull()
+}, (table) => [primaryKey({ columns: [table.projectId, table.activeTaskId] })]);
+const nodixTodoMigrationReceipts = sqliteTable("nodix_todo_migration_receipts", {
+	migrationId: text("migration_id").primaryKey(),
+	beforeCount: integer("before_count").notNull(),
+	afterCount: integer("after_count").notNull(),
+	migratedAt: integer("migrated_at").notNull()
+});
+const nodixMemoryEntities = sqliteTable("nodix_memory_entities", {
+	projectId: text("project_id").notNull(),
+	entityId: text("entity_id").notNull(),
+	displayName: text("display_name").notNull(),
+	normalizedName: text("normalized_name").notNull(),
+	createdAt: integer("created_at").notNull()
+}, (table) => [
+	primaryKey({ columns: [table.projectId, table.normalizedName] }),
+	index("nodix_idx_memory_entities_display_name").on(table.projectId, table.displayName),
+	index("nodix_idx_memory_entities_entity_id").on(table.projectId, table.entityId)
+]);
+const nodixAtomicExtractionLedger = sqliteTable("nodix_atomic_extraction_ledger", {
+	conversationId: text("conversation_id").notNull(),
+	chunkHash: text("chunk_hash").notNull(),
+	pipelineVersion: text("pipeline_version").notNull(),
+	state: text("state", { enum: [
+		"open",
+		"calls_recorded",
+		"complete",
+		"pending_reprocess"
+	] }).notNull(),
+	rawChunk: text("raw_chunk").notNull(),
+	routingSnapshotId: text("routing_snapshot_id").notNull(),
+	runParametersJson: text("run_parameters_json").notNull(),
+	reprocessReason: text("reprocess_reason", { enum: [
+		"input-overflow",
+		"truncation-exhaustion",
+		"parse-exhaustion"
+	] }),
+	reprocessAttemptCount: integer("reprocess_attempt_count").notNull().default(0),
+	failedReply: text("failed_reply"),
+	createdAt: integer("created_at").notNull(),
+	updatedAt: integer("updated_at").notNull()
+}, (table) => [primaryKey({ columns: [
+	table.conversationId,
+	table.chunkHash,
+	table.pipelineVersion
+] })]);
+const nodixProviderProjectMappings = sqliteTable("nodix_provider_project_mappings", {
+	userId: text("user_id").notNull(),
+	externalSystem: text("external_system").notNull(),
+	externalProjectKey: text("external_project_key").notNull(),
+	projectId: text("project_id").notNull().unique(),
+	createdAtMs: integer("created_at_ms").notNull()
+});
+const nodixProviderAgentMappings = sqliteTable("nodix_provider_agent_mappings", {
+	userId: text("user_id").notNull(),
+	externalSystem: text("external_system").notNull(),
+	externalAgentKey: text("external_agent_key").notNull(),
+	agentId: text("agent_id").notNull().unique(),
+	createdAtMs: integer("created_at_ms").notNull()
+});
+const nodixProviderProjectAgents = sqliteTable("nodix_provider_project_agents", {
+	userId: text("user_id").notNull(),
+	projectId: text("project_id").notNull(),
+	agentId: text("agent_id").notNull(),
+	createdAtMs: integer("created_at_ms").notNull()
+});
+const memoryEvents = sqliteTable("nodix_memory_events", {
+	id: integer("id").primaryKey({ autoIncrement: true }),
+	eventType: text("event_type").notNull(),
+	factId: text("fact_id"),
+	memoryKind: text("memory_kind"),
+	timestampMs: integer("timestamp_ms").notNull(),
+	sessionUuid: text("session_uuid"),
+	turnId: text("turn_id"),
+	agentId: text("agent_id").notNull(),
+	projectId: text("project_id"),
+	tenantId: text("tenant_id"),
+	sourceEventId: integer("source_event_id"),
+	derivedFrom: text("derived_from"),
+	consolidationEpochId: text("consolidation_epoch_id"),
+	contentHash: text("content_hash"),
+	receiptHmac: text("receipt_hmac"),
+	keyVersion: integer("key_version"),
+	retrievalRank: integer("retrieval_rank"),
+	retrievalScore: real("retrieval_score"),
+	queryTenantId: text("query_tenant_id"),
+	resultTenantId: text("result_tenant_id"),
+	metadataJson: text("metadata_json")
+});
+const memoryUsageOutbox = sqliteTable("nodix_memory_usage_outbox", {
+	id: integer("id").primaryKey({ autoIncrement: true }),
+	eventType: text("event_type").notNull(),
+	payloadJson: text("payload_json").notNull(),
+	acceptedAtMs: integer("accepted_at_ms").notNull(),
+	status: text("status").notNull(),
+	attemptCount: integer("attempt_count").notNull().default(0),
+	lastError: text("last_error"),
+	nextAttemptMs: integer("next_attempt_ms")
+});
+const memoryTelemetryIncidents = sqliteTable("nodix_memory_telemetry_incidents", {
+	id: integer("id").primaryKey({ autoIncrement: true }),
+	incidentType: text("incident_type").notNull(),
+	severity: text("severity").notNull(),
+	message: text("message").notNull(),
+	payloadJson: text("payload_json"),
+	createdAtMs: integer("created_at_ms").notNull()
+});
+const memoryTelemetrySyncState = sqliteTable("nodix_memory_telemetry_sync_state", {
+	sink: text("sink").primaryKey(),
+	lastEventId: integer("last_event_id").notNull().default(0),
+	updatedAtMs: integer("updated_at_ms").notNull()
+});
+/**
+* Write attempts the extraction path could not place. A rejected candidate is
+* preserved here with the raw model output that produced it, so a failed write
+* costs retrievability and never the content. Rows here are NOT memories: no
+* retrieval path reads this table.
+*/
+const nodixUnplacedMemoryCandidates = sqliteTable("nodix_unplaced_memory_candidates", {
+	id: text("id").primaryKey(),
+	projectId: text("project_id").notNull(),
+	category: text("category").notNull(),
+	text: text("text").notNull(),
+	rawCandidateJson: text("raw_candidate_json").notNull(),
+	dispositionReason: text("disposition_reason").notNull(),
+	dispositionedAtMs: integer("dispositioned_at_ms").notNull(),
+	sessionKey: text("session_key"),
+	dedupeHash: text("dedupe_hash").notNull()
+});
+const nodixProfileRecoveryEntries = sqliteTable("nodix_profile_recovery_entries", {
+	entryId: text("entry_id").primaryKey(),
+	mutationAttemptId: text("mutation_attempt_id").notNull(),
+	removedRowId: text("removed_row_id").notNull().references(() => nodixMemories.id, { onDelete: "cascade" }),
+	projectId: text("project_id").notNull(),
+	profileFactId: text("profile_fact_id").notNull(),
+	sectionName: text("section_name").notNull(),
+	removedValue: text("removed_value").notNull(),
+	removedAtMs: integer("removed_at_ms").notNull()
+});
+//#endregion
+//#region src/store/legacy-database-namespace-migration.ts
+const TABLE_RENAMES = [
+	{
+		legacy: FIXED_MEMORY_MEMORIES,
+		current: "nodix_memories"
+	},
+	{
+		legacy: FIXED_MEMORY_CHUNKS,
+		current: "nodix_memory_chunks"
+	},
+	{
+		legacy: FIXED_MEMORY_EXTRACTION_TIMESTAMPS,
+		current: "nodix_memory_extraction_timestamps"
+	},
+	{
+		legacy: FIXED_MEMORY_PROVIDER_PROJECT_MAPPINGS,
+		current: "nodix_provider_project_mappings"
+	},
+	{
+		legacy: FIXED_MEMORY_PROVIDER_AGENT_MAPPINGS,
+		current: "nodix_provider_agent_mappings"
+	},
+	{
+		legacy: FIXED_MEMORY_PROVIDER_PROJECT_AGENTS,
+		current: "nodix_provider_project_agents"
+	},
+	{
+		legacy: FIXED_MEMORY_TASK_LIFECYCLE_COMMANDS,
+		current: "nodix_task_lifecycle_commands"
+	},
+	{
+		legacy: FIXED_MEMORY_ACTIVE_TASK_INSTANCES,
+		current: "nodix_active_task_instances"
+	},
+	{
+		legacy: FIXED_MEMORY_ACTIVE_TASK_REVISIONS,
+		current: "nodix_active_task_revisions"
+	},
+	{
+		legacy: FIXED_MEMORY_ACTIVE_TASK_TRANSITIONS,
+		current: "nodix_active_task_transitions"
+	},
+	{
+		legacy: FIXED_MEMORY_ACTIVE_TASK_EVIDENCE,
+		current: "nodix_active_task_evidence"
+	},
+	{
+		legacy: FIXED_MEMORY_ACTIVE_TASK_MIGRATION_EVIDENCE,
+		current: "nodix_active_task_migration_evidence"
+	},
+	{
+		legacy: FIXED_MEMORY_ACTIVE_TASK_MIGRATION_MANIFESTS,
+		current: "nodix_active_task_migration_manifests"
+	},
+	{
+		legacy: FIXED_MEMORY_UNPLACED_CANDIDATES,
+		current: "nodix_unplaced_memory_candidates"
+	},
+	{
+		legacy: FIXED_MEMORY_PROFILE_RECOVERY_ENTRIES,
+		current: "nodix_profile_recovery_entries"
+	},
+	{
+		legacy: FIXED_MEMORY_MIGRATION_MARKERS,
+		current: "nodix_memory_migration_markers"
+	},
+	{
+		legacy: "memory_events",
+		current: "nodix_memory_events"
+	},
+	{
+		legacy: "memory_usage_outbox",
+		current: "nodix_memory_usage_outbox"
+	},
+	{
+		legacy: "memory_telemetry_incidents",
+		current: "nodix_memory_telemetry_incidents"
+	},
+	{
+		legacy: "memory_telemetry_sync_state",
+		current: "nodix_memory_telemetry_sync_state"
+	},
+	{
+		legacy: "rem_relation_ledger",
+		current: "nodix_rem_relation_ledger"
+	},
+	{
+		legacy: "rem_row_claims",
+		current: "nodix_rem_row_claims"
+	},
+	{
+		legacy: "rem_scan_generations",
+		current: "nodix_rem_scan_generations"
+	},
+	{
+		legacy: "rem_scan_pairs",
+		current: "nodix_rem_scan_pairs"
+	},
+	{
+		legacy: "rem_scan_invocations",
+		current: "nodix_rem_scan_invocations"
+	},
+	{
+		legacy: "rem_pair_stage_budgets",
+		current: "nodix_rem_pair_stage_budgets"
+	},
+	{
+		legacy: "rem_pair_claims",
+		current: "nodix_rem_pair_claims"
+	},
+	{
+		legacy: "rem_journal",
+		current: "nodix_rem_journal"
+	},
+	{
+		legacy: "rem_recovery_history",
+		current: "nodix_rem_recovery_history"
+	},
+	{
+		legacy: "rem_memory_facets",
+		current: "nodix_rem_memory_facets"
+	},
+	{
+		legacy: "rem_facet_recovery",
+		current: "nodix_rem_facet_recovery"
+	},
+	{
+		legacy: "rem_write_verdicts",
+		current: "nodix_rem_write_verdicts"
+	},
+	{
+		legacy: "rem_write_attempts",
+		current: "nodix_rem_write_attempts"
+	},
+	{
+		legacy: "rem_census_rows",
+		current: "nodix_rem_census_rows"
+	},
+	{
+		legacy: "rem_generation_transitions",
+		current: "nodix_rem_generation_transitions"
+	},
+	{
+		legacy: "rem_batch_summaries",
+		current: "nodix_rem_batch_summaries"
+	},
+	{
+		legacy: "rem_verdict_observations",
+		current: "nodix_rem_verdict_observations"
+	}
+];
+const INDEX_RENAMES = [
+	{
+		legacy: FIXED_IDX_MEMORY_MEMORIES_PROJECT_CONTENT_HASH,
+		current: "nodix_idx_memories_project_content_hash"
+	},
+	{
+		legacy: FIXED_IDX_MEMORY_MEMORIES_PROJECT,
+		current: "nodix_idx_memories_project"
+	},
+	{
+		legacy: FIXED_IDX_MEMORY_MEMORIES_CATEGORY,
+		current: "nodix_idx_memories_category"
+	},
+	{
+		legacy: FIXED_IDX_MEMORY_MEMORIES_PROJECT_TIMESTAMP,
+		current: "nodix_idx_memories_project_timestamp"
+	},
+	{
+		legacy: FIXED_IDX_MEMORY_MEMORIES_CONTENT_HASH,
+		current: "nodix_idx_memories_content_hash"
+	},
+	{
+		legacy: FIXED_IDX_MEMORY_MEMORIES_FACT_ID,
+		current: "nodix_idx_memories_fact_id"
+	},
+	{
+		legacy: "idx_mcm_reflection_items",
+		current: "nodix_idx_memories_reflection_items"
+	},
+	{
+		legacy: "idx_mcm_idempotency_key",
+		current: "nodix_idx_memories_idempotency_key"
+	},
+	{
+		legacy: FIXED_IDX_MEMORY_MEMORIES_LANE_PROJECT,
+		current: "nodix_idx_memories_lane_project"
+	},
+	{
+		legacy: FIXED_IDX_MEMORY_MEMORIES_PROJECT_FACT_KEY_ACTIVE,
+		current: "nodix_idx_memories_project_fact_key_active"
+	},
+	{
+		legacy: FIXED_MEMORY_CHUNKS_MEM_IDX,
+		current: "nodix_idx_memory_chunks_memory"
+	},
+	{
+		legacy: FIXED_MEMORY_CHUNKS_MEMORY_ID_IDX,
+		current: "nodix_idx_memory_chunks_memory_id"
+	},
+	{
+		legacy: FIXED_MEMORY_CHUNKS_MEM_FACET_IDX,
+		current: "nodix_idx_memory_chunks_memory_facet"
+	},
+	{
+		legacy: FIXED_IDX_MEMORY_ACTIVE_TASK_CURRENT_REVISION,
+		current: "nodix_idx_active_task_current_revision"
+	},
+	{
+		legacy: FIXED_IDX_MEMORY_ACTIVE_TASK_INSTANCES_PROJECTION,
+		current: "nodix_idx_active_task_instances_projection"
+	},
+	{
+		legacy: FIXED_IDX_MEMORY_ACTIVE_TASK_EVIDENCE_INSTANCE,
+		current: "nodix_idx_active_task_evidence_instance"
+	},
+	{
+		legacy: "idx_unplaced_project_reason",
+		current: "nodix_idx_unplaced_project_reason"
+	},
+	{
+		legacy: "idx_unplaced_dedupe",
+		current: "nodix_idx_unplaced_dedupe"
+	},
+	{
+		legacy: "idx_profile_recovery_lineage",
+		current: "nodix_idx_profile_recovery_lineage"
+	},
+	{
+		legacy: "idx_profile_recovery_attempt",
+		current: "nodix_idx_profile_recovery_attempt"
+	},
+	{
+		legacy: "idx_me_fact",
+		current: "nodix_idx_memory_events_fact"
+	},
+	{
+		legacy: "idx_me_type",
+		current: "nodix_idx_memory_events_type"
+	},
+	{
+		legacy: "idx_me_epoch",
+		current: "nodix_idx_memory_events_epoch"
+	},
+	{
+		legacy: "idx_me_session",
+		current: "nodix_idx_memory_events_session"
+	},
+	{
+		legacy: "idx_me_tenant",
+		current: "nodix_idx_memory_events_tenant"
+	},
+	{
+		legacy: "idx_me_kind",
+		current: "nodix_idx_memory_events_kind"
+	},
+	{
+		legacy: "idx_me_project",
+		current: "nodix_idx_memory_events_project"
+	},
+	{
+		legacy: "idx_me_turn",
+		current: "nodix_idx_memory_events_turn"
+	},
+	{
+		legacy: "idx_me_usage_retention",
+		current: "nodix_idx_memory_events_usage_retention"
+	},
+	{
+		legacy: "idx_muo_status_next",
+		current: "nodix_idx_memory_usage_outbox_status_next"
+	},
+	{
+		legacy: "idx_mti_created",
+		current: "nodix_idx_memory_telemetry_incidents_created"
+	}
+];
+const LEGACY_TRIGGER_NAMES = [
+	FIXED_MEMORY_CHUNKS_AI,
+	FIXED_MEMORY_CHUNKS_AD,
+	FIXED_MEMORY_CHUNKS_AU,
+	FIXED_MEMORY_MEMORIES_FACT_ID_INSERT_GUARD,
+	FIXED_MEMORY_MEMORIES_FACT_ID_UPDATE_GUARD
+];
+const LEGACY_MEMORY_GUARD_TRIGGER_NAMES = [FIXED_MEMORY_MEMORIES_FACT_ID_INSERT_GUARD, FIXED_MEMORY_MEMORIES_FACT_ID_UPDATE_GUARD];
+const KNOWN_LEGACY_OBJECT_NAMES = /* @__PURE__ */ new Set([
+	...TABLE_RENAMES.map(({ legacy }) => legacy),
+	...INDEX_RENAMES.map(({ legacy }) => legacy),
+	...LEGACY_TRIGGER_NAMES,
+	FIXED_VEC_MEMORY_CHUNKS
+]);
+const LEGACY_OBJECT_PREFIXES = [
+	FIXED_MEMORY,
+	FIXED_VEC_MEMORY,
+	FIXED_IDX_MEMORY
+];
+function migrateLegacyDatabaseNamespace(database, configuredVectorDim) {
+	const hasLegacySchema = tableExists(database, FIXED_MEMORY_MEMORIES);
+	const hasCurrentSchema = tableExists(database, "nodix_memories");
+	if (hasLegacySchema && hasCurrentSchema) throw new Error(FIXED_EXTERNAL_VALUE_49);
+	if (!hasLegacySchema) {
+		assertLegacyObjectsRemoved(database);
+		return hasCurrentSchema ? "current" : "empty";
+	}
+	assertLegacyBoundarySupported(database);
+	if (configuredVectorDim !== void 0) assertLegacyVectorDimensionSupported(database, configuredVectorDim);
+	const hadLegacyChunkSearch = tableExists(database, FIXED_MEMORY_CHUNKS_FTS);
+	const hadLegacyMemoryGuards = LEGACY_MEMORY_GUARD_TRIGGER_NAMES.some((name) => readSchemaSql(database, "trigger", name) !== void 0);
+	database.transaction(() => {
+		const rowCounts = readLegacyRowCounts(database);
+		const vectorCount = readTableRowCount(database, FIXED_VEC_MEMORY_CHUNKS);
+		dropLegacyTriggers(database);
+		dropLegacyFts(database);
+		renameTables(database);
+		migrateLegacyVectors(database);
+		renameIndexes(database);
+		if (hadLegacyChunkSearch) {
+			createCurrentFts(database);
+			createChunkTriggers(database);
+		}
+		if (hadLegacyMemoryGuards) createMemoryGuardTriggers(database);
+		assertRowCounts(database, rowCounts);
+		assertTableRowCount(database, "nodix_memory_chunk_vectors", vectorCount);
+		assertLegacyObjectsRemoved(database);
+	}).immediate();
+	return "migrated";
+}
+function assertLegacyBoundarySupported(database) {
+	const rows = database.prepare(FIXED_EXTERNAL_VALUE_51).all();
+	const columnNames = new Set(rows.map(({ name }) => name).filter((name) => !!name));
+	const legacyBoundaryColumn = [
+		"s",
+		"c",
+		"o",
+		"p",
+		"e"
+	].join("");
+	if (columnNames.has(legacyBoundaryColumn) && !columnNames.has("project_id")) throw new Error("legacy boundary schema is unsupported for provider v1");
+}
+function assertLegacyVectorDimensionSupported(database, configuredVectorDim) {
+	const legacySql = readSchemaSql(database, "table", FIXED_VEC_MEMORY_CHUNKS);
+	if (legacySql === void 0) return;
+	const dimensionToken = legacySql.match(/embedding\s+float\[(\d+)\]/i)?.[1];
+	if (dimensionToken === void 0) throw new Error(FIXED_EXTERNAL_VALUE_52);
+	const dimension = Number.parseInt(dimensionToken, 10);
+	if ((readTableRowCount(database, "vec_mem_claw_chunks") ?? 0) > 0 && dimension !== configuredVectorDim) throw new Error(`${FIXED_EXTERNAL_VALUE_53}${configuredVectorDim}, found dim ${dimension}); database left unchanged; wipe or re-import vectors before continuing`);
+}
+function readLegacyRowCounts(database) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const { legacy, current } of TABLE_RENAMES) {
+		if (!tableExists(database, legacy)) continue;
+		const row = database.prepare(`SELECT COUNT(*) AS count FROM ${quoteIdentifier(legacy)}`).get();
+		counts.set(current, Number(row.count));
+	}
+	return counts;
+}
+function readTableRowCount(database, tableName) {
+	if (!tableExists(database, tableName)) return void 0;
+	const row = database.prepare(`SELECT COUNT(*) AS count FROM ${quoteIdentifier(tableName)}`).get();
+	return Number(row.count);
+}
+function dropLegacyTriggers(database) {
+	for (const name of LEGACY_TRIGGER_NAMES) database.exec(`DROP TRIGGER IF EXISTS ${quoteIdentifier(name)}`);
+}
+function dropLegacyFts(database) {
+	if (tableExists(database, "mem_claw_chunks_fts")) database.exec(FIXED_EXTERNAL_VALUE_54);
+}
+function renameTables(database) {
+	for (const { legacy, current } of TABLE_RENAMES) {
+		const legacyExists = tableExists(database, legacy);
+		const currentExists = tableExists(database, current);
+		if (legacyExists && currentExists) throw new Error(`database contains both ${legacy} and ${current}`);
+		if (legacyExists) database.exec(`ALTER TABLE ${quoteIdentifier(legacy)} RENAME TO ${quoteIdentifier(current)}`);
+	}
+}
+function migrateLegacyVectors(database) {
+	const legacySql = readSchemaSql(database, "table", FIXED_VEC_MEMORY_CHUNKS);
+	if (legacySql === void 0) return;
+	if (tableExists(database, "nodix_memory_chunk_vectors")) throw new Error(FIXED_EXTERNAL_VALUE_55);
+	const dimension = legacySql.match(/embedding\s+float\[(\d+)\]/i)?.[1];
+	if (dimension === void 0) throw new Error(FIXED_EXTERNAL_VALUE_52);
+	const copyVectors = /partition\s+key/i.test(legacySql) ? FIXED_EXTERNAL_VALUE_56 : `${FIXED_EXTERNAL_VALUE_57}`;
+	database.exec(`
+		CREATE VIRTUAL TABLE nodix_memory_chunk_vectors USING vec0(
+			id TEXT PRIMARY KEY,
+			project_id TEXT PARTITION KEY,
+			embedding float[${dimension}]
+		);
+		${copyVectors}${FIXED_EXTERNAL_VALUE_58}`);
+}
+function renameIndexes(database) {
+	for (const { legacy, current } of INDEX_RENAMES) {
+		const legacySql = readSchemaSql(database, "index", legacy);
+		if (legacySql === void 0) continue;
+		if (readSchemaSql(database, "index", current) !== void 0) throw new Error(`database contains both index ${legacy} and ${current}`);
+		const onClause = legacySql.match(/\sON\s[\s\S]+$/i)?.[0];
+		if (onClause === void 0) throw new Error(`cannot parse index definition for ${legacy}`);
+		const unique = /^CREATE\s+UNIQUE\s+INDEX/i.test(legacySql) ? "UNIQUE " : "";
+		database.exec(`CREATE ${unique}INDEX ${quoteIdentifier(current)}${onClause}`);
+		database.exec(`DROP INDEX ${quoteIdentifier(legacy)}`);
+	}
+}
+function createCurrentFts(database) {
+	if (!tableExists(database, "nodix_memory_chunks")) return;
+	database.exec(`
+		CREATE VIRTUAL TABLE nodix_memory_chunks_fts USING fts5(
+			dense_payload,
+			content='nodix_memory_chunks',
+			content_rowid='rowid',
+			tokenize='simple 0'
+		);
+		INSERT INTO nodix_memory_chunks_fts(nodix_memory_chunks_fts) VALUES('rebuild');
+	`);
+}
+function createChunkTriggers(database) {
+	database.exec(`
+		CREATE TRIGGER nodix_memory_chunks_ai AFTER INSERT ON nodix_memory_chunks BEGIN
+			INSERT INTO nodix_memory_chunks_fts(rowid, dense_payload)
+			VALUES (new.rowid, new.dense_payload);
+		END;
+		CREATE TRIGGER nodix_memory_chunks_ad AFTER DELETE ON nodix_memory_chunks BEGIN
+			INSERT INTO nodix_memory_chunks_fts(nodix_memory_chunks_fts, rowid, dense_payload)
+			VALUES ('delete', old.rowid, old.dense_payload);
+		END;
+		CREATE TRIGGER nodix_memory_chunks_au AFTER UPDATE ON nodix_memory_chunks BEGIN
+			INSERT INTO nodix_memory_chunks_fts(nodix_memory_chunks_fts, rowid, dense_payload)
+			VALUES ('delete', old.rowid, old.dense_payload);
+			INSERT INTO nodix_memory_chunks_fts(rowid, dense_payload)
+			VALUES (new.rowid, new.dense_payload);
+		END;
+	`);
+}
+function createMemoryGuardTriggers(database) {
+	database.exec(`
+		CREATE TRIGGER nodix_memories_fact_id_insert_guard
+		BEFORE INSERT ON nodix_memories WHEN NEW.fact_id IS NULL
+		BEGIN SELECT RAISE(ABORT, 'nodix_memories.fact_id is required'); END;
+		CREATE TRIGGER nodix_memories_fact_id_update_guard
+		BEFORE UPDATE ON nodix_memories WHEN NEW.fact_id IS NULL
+		BEGIN SELECT RAISE(ABORT, 'nodix_memories.fact_id is required'); END;
+	`);
+}
+function assertRowCounts(database, expected) {
+	for (const [tableName, expectedCount] of expected) {
+		const row = database.prepare(`SELECT COUNT(*) AS count FROM ${quoteIdentifier(tableName)}`).get();
+		if (Number(row.count) !== expectedCount) throw new Error(`row count changed for ${tableName}: ${expectedCount} -> ${String(row.count)}`);
+	}
+}
+function assertTableRowCount(database, tableName, expectedCount) {
+	if (expectedCount === void 0) return;
+	const actualCount = readTableRowCount(database, tableName);
+	if (actualCount !== expectedCount) throw new Error(`row count changed for ${tableName}: ${expectedCount} -> ${String(actualCount)}`);
+}
+function assertLegacyObjectsRemoved(database) {
+	const legacyNames = database.prepare("SELECT name FROM sqlite_master WHERE name NOT LIKE 'sqlite_%' ORDER BY name").all().map(({ name }) => name).filter((name) => name !== void 0 && (KNOWN_LEGACY_OBJECT_NAMES.has(name) || LEGACY_OBJECT_PREFIXES.some((prefix) => name.startsWith(prefix))));
+	if (legacyNames.length > 0) throw new Error(`legacy database objects remain: ${legacyNames.join(", ")}`);
+}
+function tableExists(database, name) {
+	return readSchemaSql(database, "table", name) !== void 0;
+}
+function readSchemaSql(database, type, name) {
+	return database.prepare("SELECT sql FROM sqlite_master WHERE type = ? AND name = ?").get(type, name)?.sql ?? void 0;
+}
+function quoteIdentifier(identifier) {
+	return `"${identifier.replaceAll("\"", "\"\"")}"`;
+}
+//#endregion
+//#region src/store/simple-tokenizer-path.ts
+/** @file simple-tokenizer-path.ts
+* @purpose Resolve the bundled `simple-tokenizer` SQLite extension binary +
+*          jieba dictionary path for the current platform.
+* @boundary Path resolution only; loading happens in `connection.ts`.
+*
+* Layout produced by `scripts/download-simple-tokenizer.ts`:
+*
+*   <plugin>/sqlite-extensions/<platform>/libsimple.{so,dylib}
+*   <plugin>/sqlite-extensions/<platform>/dict/...
+*
+* `<platform>` is one of: `linux-x64`, `linux-arm64`, `darwin-arm64`,
+* `darwin-x64`. Other platforms throw a typed error so deploys fail fast
+* instead of silently falling back to the unicode61 tokenizer.
+*
+* Both source-tree (`src/storage/simple-tokenizer-path.ts`) and bundled
+* (`lib/index.js`) call sites must resolve correctly. The bundled output lives
+* at `<plugin>/lib/index.js`, so the candidates list probes both
+* relative locations — same pattern as `MIGRATIONS_DIR` in `connection.ts`.
+*/
+const HERE$1 = dirname(fileURLToPath(import.meta.url));
+const PLATFORM_KEY$1 = `${platform()}-${arch()}`;
+const PLATFORM_BINARY = {
+	"linux-x64": "libsimple.so",
+	"linux-arm64": "libsimple.so",
+	"darwin-arm64": "libsimple.dylib",
+	"darwin-x64": "libsimple.dylib"
+};
+/**
+* Resolve the on-disk paths the loader should pass to
+* `db.loadExtension(...)` and `SELECT jieba_dict(...)`. Returns an absolute
+* path under the plugin's `sqlite-extensions/<platform>/` directory.
+*
+* Throws if the platform is unsupported or the binary directory is missing
+* (postinstall didn't run, rsync excluded the directory, etc.). The error
+* names what to install/fetch so a fresh dev box doesn't need archaeology.
+*/
+function resolveSimpleTokenizerPath() {
+	const binary = PLATFORM_BINARY[PLATFORM_KEY$1];
+	if (!binary) throw new Error(`simple-tokenizer: unsupported platform "${PLATFORM_KEY$1}". Supported: ${Object.keys(PLATFORM_BINARY).join(", ")}. Build from upstream wangfenjin/simple if you need another target.`);
+	const candidates = [
+		join(HERE$1, "..", "..", "sqlite-extensions", PLATFORM_KEY$1),
+		join(HERE$1, "..", "sqlite-extensions", PLATFORM_KEY$1),
+		join(HERE$1, "..", "..", "..", "sqlite-extensions", PLATFORM_KEY$1)
+	];
+	for (const root of candidates) {
+		const extensionPath = resolve(root, binary);
+		const dictPath = resolve(root, "dict");
+		if (existsSync(extensionPath) && existsSync(dictPath)) return {
+			platform: PLATFORM_KEY$1,
+			extensionPath,
+			dictPath
+		};
+	}
+	throw new Error(`simple-tokenizer binary missing for ${PLATFORM_KEY$1}. Looked under: ${candidates.join(", ")}. Run \`node scripts/download-simple-tokenizer.mjs\` from the plugin directory, or rsync the \`sqlite-extensions/\` folder onto this host.`);
+}
+//#endregion
+//#region src/store/sqlite-vec-path.ts
+/** @file sqlite-vec-path.ts
+* @purpose Resolves and loads the symbol-isolated sqlite-vec extension shipped with sno-station-mem.
+* @boundary Path selection only; Linux x64 and arm64 must use the bundled binary.
+*/
+const HERE = dirname(fileURLToPath(import.meta.url));
+const PLATFORM_KEY = `${platform$1}-${arch$1}`;
+const BUNDLED_PLATFORMS = /* @__PURE__ */ new Set(["linux-x64", "linux-arm64"]);
+function resolveSqliteVecPath() {
+	if (!BUNDLED_PLATFORMS.has(PLATFORM_KEY)) return resolve(getLoadablePath());
+	const candidates = [
+		join(HERE, "..", "..", "sqlite-extensions", PLATFORM_KEY, "vec0.so"),
+		join(HERE, "..", "sqlite-extensions", PLATFORM_KEY, "vec0.so"),
+		join(HERE, "..", "..", "..", "sqlite-extensions", PLATFORM_KEY, "vec0.so")
+	];
+	for (const candidate of candidates) {
+		const extensionPath = resolve(candidate);
+		if (existsSync(extensionPath)) return extensionPath;
+	}
+	throw new Error(`Symbol-isolated sqlite-vec binary missing for ${PLATFORM_KEY}. Looked under: ${candidates.join(", ")}. Run scripts/build-sqlite-vec.sh from the plugin directory.`);
+}
+function loadSqliteVecExtension(database) {
+	database.loadExtension(resolveSqliteVecPath());
+}
+//#endregion
+//#region src/store/unplaced-candidate-migration.ts
+/** @file unplaced-candidate-migration.ts
+* @purpose One-time data move: relocate every non-active memory row into
+*   `nodix_unplaced_memory_candidates`. Runs after the drizzle DDL migration and is
+*   idempotent, so an interrupted move simply completes on the next boot.
+* @boundary Reads and writes only those two tables through the caller's handle.
+*/
+const log = createLogger("unplaced-candidate-migration");
+/**
+* Legacy rows are keyed on their own row id, not on the live writer's basis.
+* Two legacy rows can carry byte-identical payloads and reasons and still be
+* distinct occurrences, and many of them have no session key to tell apart — so
+* the only identity that provably cannot collapse two of them is the id they
+* already have. The cost is that a migrated failure and a later identical live
+* failure both persist; that is a duplicate, and duplicates are the safe
+* direction.
+*/
+function legacyDedupeHash(legacyRowId) {
+	return stableHash(JSON.stringify([PERSISTED_CANDIDATE_HASH_V1, legacyRowId]));
+}
+/**
+* Relocate non-active rows. The no-loss property is structural rather than
+* asserted: a row is deleted only after its own insert has succeeded inside the
+* same transaction, so it can never be removed without having been copied, and
+* any failure rolls the whole move back. A row missing the fields a replay needs
+* aborts the move rather than being moved lossily or deleted.
+*/
+function migrateUnplacedCandidates(sqlite) {
+	const rows = sqlite.prepare("SELECT id, project_id AS projectId, category, text, raw_candidate_json AS rawCandidateJson, disposition_reason AS dispositionReason, dispositioned_at_ms AS dispositionedAtMs, json_extract(metadata, '$.source_session') AS sessionKey FROM nodix_memories WHERE lane <> 'active'").all();
+	if (rows.length === 0) return 0;
+	const incomplete = rows.filter((row) => !row.rawCandidateJson || !row.dispositionReason || row.dispositionedAtMs === null || !Number.isFinite(row.dispositionedAtMs));
+	if (incomplete.length > 0) throw new Error(`unplaced-candidate migration aborted: ${incomplete.length} non-active row(s) lack the fields a replay needs; ids: ${incomplete.slice(0, 5).map((row) => row.id).join(", ")}`);
+	const insert = sqlite.prepare("INSERT OR IGNORE INTO nodix_unplaced_memory_candidates (id, project_id, category, text, raw_candidate_json, disposition_reason, dispositioned_at_ms, session_key, dedupe_hash) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)");
+	const exists = sqlite.prepare("SELECT 1 AS present FROM nodix_unplaced_memory_candidates WHERE project_id = ? AND dedupe_hash = ? LIMIT 1");
+	const removeChunks = sqlite.prepare("DELETE FROM nodix_memory_chunks WHERE memory_id = ?");
+	const remove = sqlite.prepare("DELETE FROM nodix_memories WHERE id = ?");
+	const moved = sqlite.transaction(() => {
+		let moved = 0;
+		for (const row of rows) {
+			const reason = String(row.dispositionReason);
+			const raw = String(row.rawCandidateJson);
+			const hash = legacyDedupeHash(row.id);
+			insert.run(randomUUID(), row.projectId, row.category, row.text, raw, reason, Number(row.dispositionedAtMs), row.sessionKey, hash);
+			if (!exists.get(row.projectId, hash)) throw new Error(`unplaced-candidate migration aborted: ${row.id} was not preserved before delete`);
+			removeChunks.run(row.id);
+			remove.run(row.id);
+			moved += 1;
+		}
+		return moved;
+	})();
+	log.warn("relocated non-active memory rows into the unplaced-candidate table", { moved }, {
+		event_name: FIXED_EXTERNAL_VALUE_62,
+		file: "packages/memory/src/store/unplaced-candidate-migration.ts",
+		function: "migrateUnplacedCandidates",
+		site_id: "unplaced-candidate-migration.migrateUnplacedCandidates.c87865ef90"
+	});
+	return moved;
+}
+//#endregion
+export { schema_exports as a, migrateLegacyDatabaseNamespace as i, loadSqliteVecExtension as n, applyEntityNameKeyMigration as o, resolveSimpleTokenizerPath as r, migrateUnplacedCandidates as t };