@snoai/memory 0.0.0-stage → 1.0.1

package/dist/utils-Ctb9aevJ.d.ts

@@ -0,0 +1,34 @@
+//#region src/engine/shared/utils.d.ts
+/**
+ * Clamps integer options into the configured range before they reach storage or ranking code.
+ */
+declare function clampInt(value: number, min: number, max: number): number;
+/** Clamps score-like values to the 0..1 range while honoring a caller-provided fallback. */
+declare function clamp01(value: number, fallback?: number): number;
+/** Redacts markup-sensitive characters before memory text is embedded in prompt context. */
+declare function sanitizeForContext(text: string, maxChars?: number, newlineReplacement?: string): string;
+/** Escapes SQLite FTS operators so user queries cannot break MATCH syntax. */
+declare function sanitizeFtsQuery(rawQuery: string): string;
+/** Builds a conjunctive FTS predicate from validated structured aggregation terms. */
+declare function sanitizeFtsConjunctiveQuery(terms: readonly string[]): string;
+/** Serializes Float32 vectors into little-endian bytes for SQLite vector storage. */
+declare function f32ToBytes(f32: Float32Array): Uint8Array;
+/** Rehydrates SQLite vector bytes into Float32 values and rejects malformed payloads. */
+declare function bytesToF32(bytes: Uint8Array): Float32Array;
+/** Produces the stable content hash used for deduplication and idempotent writes. */
+declare function stableHash(text: string): string;
+/**
+ * Return a short, secret-redacted, whitespace-collapsed preview of `text` for
+ * debug audit logs when explicitly enabled. Off-by-default
+ * and passes the text through `redactSecrets` first because previews persist
+ * in audit.jsonl on disk. Enable for bench investigations only.
+ */
+declare function debugContentPreview(text: string | undefined, enabled: boolean, maxChars?: number): string | undefined;
+/**
+ * Read the tail of a text file (up to `maxBytes`).
+ * Returns the file content from the tail. If the file is smaller than `maxBytes`,
+ * returns the entire file. The first partial line is dropped (it was likely truncated).
+ */
+declare function readFileTail(filePath: string, maxBytes?: number): Promise<string>;
+//#endregion
+export { f32ToBytes as a, sanitizeFtsConjunctiveQuery as c, debugContentPreview as i, sanitizeFtsQuery as l, clamp01 as n, readFileTail as o, clampInt as r, sanitizeForContext as s, bytesToF32 as t, stableHash as u };

package/drizzle/0000_initial.sql

@@ -0,0 +1,10 @@
+CREATE TABLE IF NOT EXISTS nodix_memories (
+  id TEXT PRIMARY KEY,
+  text TEXT NOT NULL,
+  category TEXT NOT NULL,
+  project_id TEXT NOT NULL,
+  importance REAL NOT NULL DEFAULT 0.7,
+  timestamp INTEGER NOT NULL,
+  metadata TEXT DEFAULT '{}',
+  content_hash TEXT NOT NULL
+);

package/drizzle/0001_virtual_tables.sql

@@ -0,0 +1,34 @@
+CREATE VIRTUAL TABLE IF NOT EXISTS nodix_memories_fts
+USING fts5(
+  text,
+  content='nodix_memories',
+  content_rowid='rowid',
+  tokenize='porter unicode61'
+);
+--> statement-breakpoint
+CREATE TRIGGER IF NOT EXISTS nodix_memories_ai
+AFTER INSERT ON nodix_memories BEGIN
+  INSERT INTO nodix_memories_fts(rowid, text)
+  VALUES (new.rowid, new.text);
+END;
+--> statement-breakpoint
+CREATE TRIGGER IF NOT EXISTS nodix_memories_ad
+AFTER DELETE ON nodix_memories BEGIN
+  INSERT INTO nodix_memories_fts(nodix_memories_fts, rowid, text)
+  VALUES ('delete', old.rowid, old.text);
+END;
+--> statement-breakpoint
+CREATE TRIGGER IF NOT EXISTS nodix_memories_au
+AFTER UPDATE ON nodix_memories BEGIN
+  INSERT INTO nodix_memories_fts(nodix_memories_fts, rowid, text)
+  VALUES ('delete', old.rowid, old.text);
+  INSERT INTO nodix_memories_fts(rowid, text)
+  VALUES (new.rowid, new.text);
+END;
+--> statement-breakpoint
+CREATE VIRTUAL TABLE IF NOT EXISTS nodix_memory_vectors
+USING vec0(
+  id TEXT PRIMARY KEY,
+  -- Keep this aligned with VECTOR_DIMENSION_DEFAULT (1024).
+  embedding float[1024]
+);

package/drizzle/0002_add_indexes.sql

@@ -0,0 +1,11 @@
+CREATE UNIQUE INDEX IF NOT EXISTS nodix_idx_memories_project_content_hash
+ON nodix_memories (project_id, content_hash);
+--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS nodix_idx_memories_project
+ON nodix_memories (project_id);
+--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS nodix_idx_memories_category
+ON nodix_memories (category);
+--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS nodix_idx_memories_project_timestamp
+ON nodix_memories (project_id, timestamp DESC);

package/drizzle/0003_content_hash_lookup_index.sql

@@ -0,0 +1,2 @@
+CREATE INDEX IF NOT EXISTS nodix_idx_memories_content_hash
+ON nodix_memories (content_hash);

package/drizzle/0004_chunk_swap.sql

@@ -0,0 +1,60 @@
+-- Hand-rolled migration; do NOT run `npm run db:generate` against this file.
+CREATE TABLE IF NOT EXISTS nodix_memory_chunks (
+  chunk_id TEXT PRIMARY KEY,
+  memory_id TEXT NOT NULL,
+  chunk_index INTEGER NOT NULL,
+  chunk_text TEXT NOT NULL,
+  dense_payload TEXT NOT NULL,
+  summary TEXT,
+  entities TEXT,
+  tags TEXT,
+  source TEXT,
+  start_offset INTEGER NOT NULL,
+  end_offset INTEGER NOT NULL,
+  token_count INTEGER NOT NULL,
+  content_type TEXT NOT NULL CHECK (content_type IN ('conversation', 'prose', 'code')),
+  chunking_version TEXT NOT NULL,
+  embedder_provider TEXT NOT NULL,
+  embedder_model TEXT NOT NULL,
+  embedder_dim INTEGER NOT NULL,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
+  FOREIGN KEY (memory_id) REFERENCES nodix_memories(id) ON DELETE CASCADE
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX IF NOT EXISTS nodix_idx_memory_chunks_memory ON nodix_memory_chunks(memory_id, chunk_index);
+--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS nodix_idx_memory_chunks_memory_id ON nodix_memory_chunks(memory_id);
+--> statement-breakpoint
+CREATE VIRTUAL TABLE IF NOT EXISTS nodix_memory_chunk_vectors USING vec0(
+  id TEXT PRIMARY KEY,
+  -- Placeholder dim; runtime ensureChunkVecTable recreates at the configured dim.
+  embedding float[1024]
+);
+--> statement-breakpoint
+CREATE VIRTUAL TABLE IF NOT EXISTS nodix_memory_chunks_fts USING fts5(
+  dense_payload,
+  content='nodix_memory_chunks',
+  content_rowid='rowid',
+  tokenize='porter unicode61'
+);
+--> statement-breakpoint
+CREATE TRIGGER IF NOT EXISTS 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;
+--> statement-breakpoint
+CREATE TRIGGER IF NOT EXISTS 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;
+--> statement-breakpoint
+CREATE TRIGGER IF NOT EXISTS 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;

package/drizzle/0005_drop_legacy_vec_fts.sql

@@ -0,0 +1,10 @@
+-- Drop parent-level FTS/vector objects superseded by 0004_chunk_swap.
+DROP TRIGGER IF EXISTS nodix_memories_ai;
+--> statement-breakpoint
+DROP TRIGGER IF EXISTS nodix_memories_ad;
+--> statement-breakpoint
+DROP TRIGGER IF EXISTS nodix_memories_au;
+--> statement-breakpoint
+DROP TABLE IF EXISTS nodix_memories_fts;
+--> statement-breakpoint
+DROP TABLE IF EXISTS nodix_memory_vectors;

package/drizzle/0006_fts_simple.sql

@@ -0,0 +1,45 @@
+-- Hand-rolled migration; do NOT run `npm run db:generate` against this file.
+-- Swap nodix_memory_chunks_fts tokenizer from `porter unicode61` (char-level on CJK)
+-- to `simple 0` (jieba word-level via wangfenjin/simple extension).
+-- Schema, triggers, and downstream MATCH queries stay identical — only the
+-- tokenize= clause changes.
+DROP TRIGGER IF EXISTS nodix_memory_chunks_ai;
+--> statement-breakpoint
+DROP TRIGGER IF EXISTS nodix_memory_chunks_ad;
+--> statement-breakpoint
+DROP TRIGGER IF EXISTS nodix_memory_chunks_au;
+--> statement-breakpoint
+DROP TABLE IF EXISTS nodix_memory_chunks_fts;
+--> statement-breakpoint
+CREATE VIRTUAL TABLE nodix_memory_chunks_fts USING fts5(
+  dense_payload,
+  content='nodix_memory_chunks',
+  content_rowid='rowid',
+  tokenize='simple 0'
+);
+--> statement-breakpoint
+CREATE TRIGGER IF NOT EXISTS 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;
+--> statement-breakpoint
+CREATE TRIGGER IF NOT EXISTS 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;
+--> statement-breakpoint
+CREATE TRIGGER IF NOT EXISTS 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;
+--> statement-breakpoint
+-- Rebuild is synchronous; run this migration during a maintenance window for
+-- large existing databases rather than during latency-sensitive startup.
+INSERT INTO nodix_memory_chunks_fts(nodix_memory_chunks_fts)
+SELECT 'rebuild'
+WHERE EXISTS (SELECT 1 FROM nodix_memory_chunks LIMIT 1);

package/drizzle/0007_restore_simple_fts.sql

@@ -0,0 +1,40 @@
+-- Restore nodix_memory_chunks_fts to the wangfenjin/simple tokenizer after the
+-- temporary 0006 rollback to porter unicode61.
+DROP TRIGGER IF EXISTS nodix_memory_chunks_ai;
+--> statement-breakpoint
+DROP TRIGGER IF EXISTS nodix_memory_chunks_ad;
+--> statement-breakpoint
+DROP TRIGGER IF EXISTS nodix_memory_chunks_au;
+--> statement-breakpoint
+DROP TABLE IF EXISTS nodix_memory_chunks_fts;
+--> statement-breakpoint
+CREATE VIRTUAL TABLE nodix_memory_chunks_fts USING fts5(
+  dense_payload,
+  content='nodix_memory_chunks',
+  content_rowid='rowid',
+  tokenize='simple 0'
+);
+--> statement-breakpoint
+CREATE TRIGGER IF NOT EXISTS 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;
+--> statement-breakpoint
+CREATE TRIGGER IF NOT EXISTS 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;
+--> statement-breakpoint
+CREATE TRIGGER IF NOT EXISTS 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;
+--> statement-breakpoint
+INSERT INTO nodix_memory_chunks_fts(nodix_memory_chunks_fts)
+SELECT 'rebuild'
+WHERE EXISTS (SELECT 1 FROM nodix_memory_chunks LIMIT 1);

package/drizzle/0008_widen_memory_hash_unique_index.sql

@@ -0,0 +1,4 @@
+DROP INDEX IF EXISTS nodix_idx_memories_project_content_hash;
+--> statement-breakpoint
+CREATE UNIQUE INDEX IF NOT EXISTS nodix_idx_memories_project_content_hash
+ON nodix_memories (project_id, content_hash, category);

package/drizzle/0009_memory_telemetry.sql

@@ -0,0 +1,109 @@
+ALTER TABLE nodix_memories ADD COLUMN fact_id TEXT;
+--> statement-breakpoint
+UPDATE nodix_memories SET fact_id = id WHERE fact_id IS NULL;
+--> statement-breakpoint
+ALTER TABLE nodix_memories ADD COLUMN derived_from TEXT;
+--> statement-breakpoint
+ALTER TABLE nodix_memories ADD COLUMN consolidation_epoch_id TEXT;
+--> statement-breakpoint
+ALTER TABLE nodix_memories ADD COLUMN confidence_source TEXT;
+--> statement-breakpoint
+CREATE TRIGGER IF NOT EXISTS 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;
+--> statement-breakpoint
+CREATE TRIGGER IF NOT EXISTS 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;
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS nodix_memory_events (
+  id            INTEGER PRIMARY KEY AUTOINCREMENT,
+  event_type    TEXT    NOT NULL,
+  fact_id       TEXT,
+  memory_kind   TEXT,
+  timestamp_ms  INTEGER NOT NULL,
+  session_uuid  TEXT,
+  turn_id       TEXT,
+  agent_id      TEXT    NOT NULL,
+  project_id    TEXT,
+  tenant_id     TEXT,
+
+  source_event_id   INTEGER,
+  derived_from      TEXT,
+
+  consolidation_epoch_id  TEXT,
+
+  content_hash    TEXT,
+  receipt_hmac    TEXT,
+  key_version     INTEGER,
+
+  retrieval_rank    INTEGER,
+  retrieval_score   REAL,
+
+  query_tenant_id   TEXT,
+  result_tenant_id  TEXT,
+
+  metadata_json   TEXT,
+
+  CHECK (event_type IN (
+    'create',
+    'update',
+    'recall',
+    'supersede',
+    'delete',
+    'inject',
+    'epoch_boundary',
+    'purge'
+  )),
+  CHECK (event_type = 'epoch_boundary' OR fact_id IS NOT NULL)
+);
+--> statement-breakpoint
+CREATE INDEX nodix_idx_memory_events_fact      ON nodix_memory_events(fact_id);
+--> statement-breakpoint
+CREATE INDEX nodix_idx_memory_events_type      ON nodix_memory_events(event_type);
+--> statement-breakpoint
+CREATE INDEX nodix_idx_memory_events_epoch     ON nodix_memory_events(consolidation_epoch_id);
+--> statement-breakpoint
+CREATE INDEX nodix_idx_memory_events_session   ON nodix_memory_events(session_uuid);
+--> statement-breakpoint
+CREATE INDEX nodix_idx_memory_events_tenant    ON nodix_memory_events(tenant_id, timestamp_ms);
+--> statement-breakpoint
+CREATE INDEX nodix_idx_memory_events_kind      ON nodix_memory_events(memory_kind, timestamp_ms);
+--> statement-breakpoint
+CREATE INDEX nodix_idx_memory_events_project   ON nodix_memory_events(project_id, event_type, timestamp_ms);
+--> statement-breakpoint
+CREATE INDEX nodix_idx_memory_events_turn      ON nodix_memory_events(turn_id);
+--> statement-breakpoint
+CREATE TRIGGER memory_events_no_update BEFORE UPDATE ON nodix_memory_events
+BEGIN SELECT RAISE(ABORT, 'nodix_memory_events is append-only'); END;
+--> statement-breakpoint
+CREATE TRIGGER memory_events_no_delete BEFORE DELETE ON nodix_memory_events
+BEGIN SELECT RAISE(ABORT, 'nodix_memory_events is append-only'); END;
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS nodix_memory_usage_outbox (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  event_type TEXT NOT NULL CHECK (event_type IN ('recall', 'inject')),
+  payload_json TEXT NOT NULL,
+  accepted_at_ms INTEGER NOT NULL,
+  status TEXT NOT NULL CHECK (status IN ('pending', 'failed', 'flushing', 'quarantined')),
+  attempt_count INTEGER NOT NULL DEFAULT 0,
+  last_error TEXT,
+  next_attempt_ms INTEGER
+);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS nodix_memory_telemetry_incidents (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  incident_type TEXT NOT NULL,
+  severity TEXT NOT NULL CHECK (severity IN ('warning', 'error')),
+  message TEXT NOT NULL,
+  payload_json TEXT,
+  created_at_ms INTEGER NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS nodix_memory_telemetry_sync_state (
+  sink TEXT PRIMARY KEY,
+  last_event_id INTEGER NOT NULL DEFAULT 0,
+  updated_at_ms INTEGER NOT NULL
+);

package/drizzle/0010_provider_mappings.sql

@@ -0,0 +1,27 @@
+CREATE TABLE IF NOT EXISTS nodix_provider_project_mappings (
+  user_id TEXT NOT NULL,
+  external_system TEXT NOT NULL,
+  external_project_key TEXT NOT NULL,
+  project_id TEXT NOT NULL,
+  created_at_ms INTEGER NOT NULL,
+  PRIMARY KEY (user_id, external_system, external_project_key),
+  UNIQUE (project_id)
+);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS nodix_provider_agent_mappings (
+  user_id TEXT NOT NULL,
+  external_system TEXT NOT NULL,
+  external_agent_key TEXT NOT NULL,
+  agent_id TEXT NOT NULL,
+  created_at_ms INTEGER NOT NULL,
+  PRIMARY KEY (user_id, external_system, external_agent_key),
+  UNIQUE (agent_id)
+);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS nodix_provider_project_agents (
+  user_id TEXT NOT NULL,
+  project_id TEXT NOT NULL,
+  agent_id TEXT NOT NULL,
+  created_at_ms INTEGER NOT NULL,
+  PRIMARY KEY (user_id, project_id, agent_id)
+);

package/drizzle/0011_db_optimization.sql

@@ -0,0 +1,82 @@
+-- Hand-rolled migration; do NOT run `npm run db:generate` against this file.
+-- DB-optimization pass (2026-07): missing indexes for real query shapes, removal of
+-- redundant/unused indexes to cut write amplification, and retention enablement for
+-- usage events. Complete DDL for the pass lives in this single migration.
+
+-- fact_id lookups (purge cascade deleteFacts/readAffectedEpochIds/readPurgeEventAnchor,
+-- telemetry readCurrentContentHash) currently full-scan the memories table.
+CREATE INDEX IF NOT EXISTS nodix_idx_memories_fact_id ON nodix_memories(fact_id);
+--> statement-breakpoint
+-- Outbox flush-candidate reads and pending scans filter on status (+ next_attempt_ms);
+-- the table previously had no non-PK index at all.
+CREATE INDEX IF NOT EXISTS nodix_idx_memory_usage_outbox_status_next
+ON nodix_memory_usage_outbox(status, next_attempt_ms);
+--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS nodix_idx_memory_telemetry_incidents_created
+ON nodix_memory_telemetry_incidents(created_at_ms);
+--> statement-breakpoint
+-- listReflectionItems full-scans + JSON-parses every row today. The partial predicate
+-- restricts index content to reflection rows only, so even a project-filtered query is
+-- bounded by the total number of reflection rows; timestamp keying serves the
+-- unfiltered ORDER BY timestamp DESC LIMIT shape in index order.
+CREATE INDEX IF NOT EXISTS nodix_idx_memories_reflection_items
+ON nodix_memories(timestamp DESC)
+WHERE json_valid(metadata) AND json_extract(metadata, '$.type') = 'memory-reflection-item';
+--> statement-breakpoint
+-- findByExtractionIdempotencyKey and the createEventAndSupersede duplicate probe
+-- full-scan on json_extract today. Non-unique on purpose: uniqueness stays enforced by
+-- the existing code guard, so pre-existing duplicate rows cannot break this migration.
+CREATE INDEX IF NOT EXISTS nodix_idx_memories_idempotency_key
+ON nodix_memories(project_id, json_extract(metadata, '$.idempotency_key'))
+WHERE json_valid(metadata) AND json_extract(metadata, '$.idempotency_key') IS NOT NULL;
+--> statement-breakpoint
+-- Redundant left-prefix indexes: (project_id) is a prefix of
+-- nodix_idx_memories_project_timestamp and of the UNIQUE
+-- (project_id, content_hash, category); chunks(memory_id) is a prefix of the UNIQUE
+-- (memory_id, chunk_index). Every write pays for them; no query needs them.
+DROP INDEX IF EXISTS nodix_idx_memories_project;
+--> statement-breakpoint
+DROP INDEX IF EXISTS nodix_idx_memory_chunks_memory_id;
+--> statement-breakpoint
+-- nodix_memory_events index trim. Every memory write inserts an event inside the same
+-- transaction, so each secondary index is per-write amplification. Verified by
+-- repo-wide query sweep (2026-07-12): tenant_id and memory_kind are never queried;
+-- session_uuid is only ever queried together with turn_id; bare event_type predicates
+-- always pair with an indexed fact_id.
+DROP INDEX IF EXISTS nodix_idx_memory_events_type;
+--> statement-breakpoint
+-- The hourly usage-event retention query filters
+-- event_type IN ('recall','inject') AND timestamp_ms < cutoff — a partial index shaped
+-- exactly for that scan, near-free for lifecycle inserts (outside the predicate).
+CREATE INDEX IF NOT EXISTS nodix_idx_memory_events_usage_retention
+ON nodix_memory_events(timestamp_ms)
+WHERE event_type IN ('recall', 'inject');
+--> statement-breakpoint
+DROP INDEX IF EXISTS nodix_idx_memory_events_tenant;
+--> statement-breakpoint
+DROP INDEX IF EXISTS nodix_idx_memory_events_kind;
+--> statement-breakpoint
+DROP INDEX IF EXISTS nodix_idx_memory_events_session;
+--> statement-breakpoint
+DROP INDEX IF EXISTS nodix_idx_memory_events_epoch;
+--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS nodix_idx_memory_events_epoch ON nodix_memory_events(consolidation_epoch_id)
+WHERE consolidation_epoch_id IS NOT NULL;
+--> statement-breakpoint
+DROP INDEX IF EXISTS nodix_idx_memory_events_turn;
+--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS nodix_idx_memory_events_turn ON nodix_memory_events(turn_id)
+WHERE turn_id IS NOT NULL;
+--> statement-breakpoint
+-- Retention enablement. The blanket no-delete trigger is replaced by a GUARDED trigger:
+-- only high-volume usage events ('recall','inject') may ever be deleted; receipt and
+-- lineage events (create/update/supersede/delete/purge/epoch_boundary) stay
+-- database-protected forever. Age policy (90d) lives in code; the schema enforces the
+-- event-class boundary. Fail-safe order: the guarded trigger is created BEFORE the
+-- blanket trigger is dropped, so an interrupted migration leaves BOTH triggers active
+-- (deletes over-protected), never a window where lifecycle rows are deletable.
+CREATE TRIGGER IF NOT EXISTS memory_events_lifecycle_delete_guard BEFORE DELETE ON nodix_memory_events
+WHEN OLD.event_type NOT IN ('recall', 'inject')
+BEGIN SELECT RAISE(ABORT, 'nodix_memory_events lifecycle rows are append-only'); END;
+--> statement-breakpoint
+DROP TRIGGER IF EXISTS memory_events_no_delete;

package/drizzle/0012_b_profile_lanes.sql

@@ -0,0 +1,9 @@
+ALTER TABLE `nodix_memories` ADD `lane` text DEFAULT 'active' NOT NULL CHECK (`lane` IN ('active', 'parked', 'quarantined'));
+--> statement-breakpoint
+ALTER TABLE `nodix_memories` ADD `raw_candidate_json` text;
+--> statement-breakpoint
+ALTER TABLE `nodix_memories` ADD `disposition_reason` text;
+--> statement-breakpoint
+ALTER TABLE `nodix_memories` ADD `dispositioned_at_ms` integer;
+--> statement-breakpoint
+CREATE INDEX `nodix_idx_memories_lane_project` ON `nodix_memories` (`lane`,`project_id`);

package/drizzle/0013_extraction_timestamps.sql

@@ -0,0 +1,6 @@
+CREATE TABLE IF NOT EXISTS `nodix_memory_extraction_timestamps` (
+	`project_id` text NOT NULL,
+	`replay_key` text NOT NULL,
+	`resolved_at_ms` integer NOT NULL,
+	PRIMARY KEY (`project_id`, `replay_key`)
+) WITHOUT ROWID;

package/drizzle/0014_extraction_timestamp_source.sql

@@ -0,0 +1,3 @@
+ALTER TABLE `nodix_memory_extraction_timestamps`
+ADD COLUMN `time_source` text
+CHECK (`time_source` IN ('event_at', 'session_time', 'first_resolution'));

package/drizzle/0015_task_lifecycle_state.sql

@@ -0,0 +1,101 @@
+CREATE TABLE `nodix_task_lifecycle_commands` (
+	`project_id` text NOT NULL,
+	`command_id` text NOT NULL,
+	`canonical_tuple_json` text,
+	`identity_json` text NOT NULL,
+	`action` text NOT NULL CHECK (`action` IN ('open_or_refine', 'complete', 'remove')),
+	`source_assertion_json` text NOT NULL,
+	`effective_at_ms` integer NOT NULL,
+	`time_source` text NOT NULL CHECK (`time_source` IN ('event_at', 'session_time', 'first_resolution')),
+	`result` text NOT NULL CHECK (`result` IN (
+		'created_instance',
+		'created_unresolved_instance',
+		'refined',
+		'evidence_only',
+		'completed',
+		'removed',
+		'terminal_evidence_only',
+		'none',
+		'uncertain'
+	)),
+	`active_task_id` text,
+	`active_task_revision_id` text,
+	`diagnostics_json` text NOT NULL,
+	`created_at_ms` integer NOT NULL,
+	PRIMARY KEY (`project_id`, `command_id`)
+) WITHOUT ROWID;
+--> statement-breakpoint
+CREATE TABLE `nodix_active_task_instances` (
+	`project_id` text NOT NULL,
+	`active_task_id` text NOT NULL,
+	`opening_command_id` text NOT NULL,
+	`canonical_tuple_json` text NOT NULL,
+	`identity_state` text NOT NULL CHECK (`identity_state` IN ('normal', 'unresolved')),
+	`status` text NOT NULL CHECK (`status` IN ('active', 'completed', 'removed')),
+	`created_at_ms` integer NOT NULL,
+	`terminal_at_ms` integer,
+	PRIMARY KEY (`project_id`, `active_task_id`),
+	UNIQUE (`project_id`, `opening_command_id`),
+	FOREIGN KEY (`project_id`, `opening_command_id`)
+		REFERENCES `nodix_task_lifecycle_commands` (`project_id`, `command_id`)
+) WITHOUT ROWID;
+--> statement-breakpoint
+CREATE TABLE `nodix_active_task_revisions` (
+	`project_id` text NOT NULL,
+	`active_task_revision_id` text NOT NULL,
+	`active_task_id` text NOT NULL,
+	`creating_command_id` text NOT NULL,
+	`canonical_tuple_json` text NOT NULL,
+	`description` text NOT NULL,
+	`occurrence_anchors_json` text NOT NULL,
+	`revision_details_json` text NOT NULL,
+	`created_at_ms` integer NOT NULL,
+	`is_current` integer NOT NULL CHECK (`is_current` IN (0, 1)),
+	PRIMARY KEY (`project_id`, `active_task_revision_id`),
+	UNIQUE (`project_id`, `active_task_id`, `creating_command_id`),
+	FOREIGN KEY (`project_id`, `active_task_id`)
+		REFERENCES `nodix_active_task_instances` (`project_id`, `active_task_id`),
+	FOREIGN KEY (`project_id`, `creating_command_id`)
+		REFERENCES `nodix_task_lifecycle_commands` (`project_id`, `command_id`)
+) WITHOUT ROWID;
+--> statement-breakpoint
+CREATE UNIQUE INDEX `nodix_idx_active_task_current_revision`
+ON `nodix_active_task_revisions` (`project_id`, `active_task_id`)
+WHERE `is_current` = 1;
+--> statement-breakpoint
+CREATE TABLE `nodix_active_task_transitions` (
+	`project_id` text NOT NULL,
+	`command_id` text NOT NULL,
+	`active_task_id` text NOT NULL,
+	`transition_kind` text NOT NULL CHECK (`transition_kind` IN ('open', 'refine', 'complete', 'remove')),
+	`from_status` text CHECK (`from_status` IS NULL OR `from_status` IN ('active', 'completed', 'removed')),
+	`to_status` text NOT NULL CHECK (`to_status` IN ('active', 'completed', 'removed')),
+	`effective_at_ms` integer NOT NULL,
+	PRIMARY KEY (`project_id`, `command_id`),
+	FOREIGN KEY (`project_id`, `command_id`)
+		REFERENCES `nodix_task_lifecycle_commands` (`project_id`, `command_id`),
+	FOREIGN KEY (`project_id`, `active_task_id`)
+		REFERENCES `nodix_active_task_instances` (`project_id`, `active_task_id`)
+) WITHOUT ROWID;
+--> statement-breakpoint
+CREATE TABLE `nodix_active_task_evidence` (
+	`project_id` text NOT NULL,
+	`command_id` text NOT NULL,
+	`active_task_id` text,
+	`evidence_memory_id` text,
+	`source_assertion_json` text NOT NULL,
+	`outcome` text NOT NULL,
+	`diagnostics_json` text NOT NULL,
+	`linked_at_ms` integer NOT NULL,
+	PRIMARY KEY (`project_id`, `command_id`),
+	FOREIGN KEY (`project_id`, `command_id`)
+		REFERENCES `nodix_task_lifecycle_commands` (`project_id`, `command_id`),
+	FOREIGN KEY (`project_id`, `active_task_id`)
+		REFERENCES `nodix_active_task_instances` (`project_id`, `active_task_id`)
+) WITHOUT ROWID;
+--> statement-breakpoint
+CREATE INDEX `nodix_idx_active_task_instances_projection`
+ON `nodix_active_task_instances` (`project_id`, `status`, `created_at_ms`, `active_task_id`);
+--> statement-breakpoint
+CREATE INDEX `nodix_idx_active_task_evidence_instance`
+ON `nodix_active_task_evidence` (`project_id`, `active_task_id`);