omnius 1.0.399 → 1.0.401

package/dist/memory-maintenance-worker.js

@@ -0,0 +1,3636 @@
+#!/usr/bin/env node
+import { createRequire as __omnius_createRequire } from "node:module"; import { fileURLToPath as __omnius_fileURLToPath } from "node:url"; import { dirname as __omnius_dirname } from "node:path"; const require = __omnius_createRequire(import.meta.url); const __filename = __omnius_fileURLToPath(import.meta.url); const __dirname = __omnius_dirname(__filename);
+
+// packages/memory/dist/db.js
+import { createRequire } from "node:module";
+var _Database = null;
+function getDatabase() {
+  if (_Database !== null)
+    return _Database;
+  try {
+    const req = createRequire(import.meta.url);
+    _Database = req("better-sqlite3");
+  } catch {
+    throw new Error("better-sqlite3 is not available (native module build may have failed).\nTry: npm rebuild better-sqlite3\nMemory features (SQLite) are disabled until this is resolved.");
+  }
+  return _Database;
+}
+function initDb(dbPath) {
+  const Database = getDatabase();
+  const db = new Database(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  runMigrations(db);
+  return db;
+}
+function runMigrations(db) {
+  db.exec(`
+    -- repo_profiles: one row per repository root.
+    CREATE TABLE IF NOT EXISTS repo_profiles (
+      repo_root       TEXT    PRIMARY KEY,
+      languages       TEXT    NOT NULL DEFAULT '[]',   -- JSON array
+      frameworks      TEXT    NOT NULL DEFAULT '[]',   -- JSON array
+      build_system    TEXT    NOT NULL DEFAULT '',
+      test_commands   TEXT    NOT NULL DEFAULT '[]',   -- JSON array
+      lint_commands   TEXT    NOT NULL DEFAULT '[]',   -- JSON array
+      package_manager TEXT    NOT NULL DEFAULT '',
+      notes           TEXT,
+      created_at      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),
+      updated_at      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now'))
+    );
+
+    -- file_summaries: one row per (repo_root, file_path) pair.
+    CREATE TABLE IF NOT EXISTS file_summaries (
+      file_path       TEXT    NOT NULL,
+      repo_root       TEXT    NOT NULL,
+      purpose         TEXT    NOT NULL DEFAULT '',
+      exports         TEXT    NOT NULL DEFAULT '[]',   -- JSON array
+      imports         TEXT    NOT NULL DEFAULT '[]',   -- JSON array
+      domain          TEXT    NOT NULL DEFAULT '',
+      risk_level      TEXT    NOT NULL DEFAULT 'low',  -- low | medium | high
+      related_tests   TEXT    NOT NULL DEFAULT '[]',   -- JSON array
+      notes           TEXT,
+      created_at      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),
+      updated_at      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),
+      PRIMARY KEY (file_path)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_file_summaries_repo
+      ON file_summaries (repo_root);
+
+    CREATE INDEX IF NOT EXISTS idx_file_summaries_domain
+      ON file_summaries (domain);
+
+    CREATE INDEX IF NOT EXISTS idx_file_summaries_risk
+      ON file_summaries (risk_level);
+
+    -- task_memory: historical record of agent tasks.
+    CREATE TABLE IF NOT EXISTS task_memory (
+      id              TEXT    PRIMARY KEY,
+      session_id      TEXT    NOT NULL,
+      repo_root       TEXT    NOT NULL,
+      goal            TEXT    NOT NULL DEFAULT '',
+      constraints     TEXT    NOT NULL DEFAULT '[]',   -- JSON array
+      files_touched   TEXT    NOT NULL DEFAULT '[]',   -- JSON array
+      patches         TEXT    NOT NULL DEFAULT '[]',   -- JSON array
+      outcome         TEXT    NOT NULL DEFAULT 'unknown', -- success | failure | partial | unknown
+      quality_score   REAL,
+      notes           TEXT,
+      created_at      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_task_memory_session
+      ON task_memory (session_id);
+
+    CREATE INDEX IF NOT EXISTS idx_task_memory_repo
+      ON task_memory (repo_root);
+
+    CREATE INDEX IF NOT EXISTS idx_task_memory_outcome
+      ON task_memory (outcome);
+
+    -- patch_history: individual file diffs applied by the agent.
+    CREATE TABLE IF NOT EXISTS patch_history (
+      id              TEXT    PRIMARY KEY,
+      task_id         TEXT    NOT NULL,
+      session_id      TEXT    NOT NULL,
+      repo_root       TEXT    NOT NULL,
+      file_path       TEXT    NOT NULL,
+      diff            TEXT    NOT NULL DEFAULT '',
+      status          TEXT    NOT NULL DEFAULT 'applied', -- applied | reverted | pending | failed
+      applied_at      TEXT,
+      reverted_at     TEXT,
+      notes           TEXT,
+      created_at      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_patch_history_task
+      ON patch_history (task_id);
+
+    CREATE INDEX IF NOT EXISTS idx_patch_history_file
+      ON patch_history (file_path);
+
+    CREATE INDEX IF NOT EXISTS idx_patch_history_status
+      ON patch_history (status);
+
+    -- failures: fingerprinted failure events for pattern detection.
+    CREATE TABLE IF NOT EXISTS failures (
+      id              TEXT    PRIMARY KEY,
+      task_id         TEXT    NOT NULL,
+      session_id      TEXT    NOT NULL,
+      repo_root       TEXT    NOT NULL,
+      failure_type    TEXT    NOT NULL DEFAULT '',
+      fingerprint     TEXT    NOT NULL DEFAULT '',
+      file_path       TEXT,
+      error_message   TEXT    NOT NULL DEFAULT '',
+      context         TEXT,                            -- JSON object or null
+      resolved        INTEGER NOT NULL DEFAULT 0,      -- 0 = false, 1 = true
+      resolved_at     TEXT,
+      notes           TEXT,
+      created_at      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_failures_type
+      ON failures (failure_type);
+
+    CREATE INDEX IF NOT EXISTS idx_failures_fingerprint
+      ON failures (fingerprint);
+
+    CREATE INDEX IF NOT EXISTS idx_failures_resolved
+      ON failures (resolved);
+
+    -- validation_runs: results of lint / test / build / typecheck runs.
+    CREATE TABLE IF NOT EXISTS validation_runs (
+      id              TEXT    PRIMARY KEY,
+      task_id         TEXT    NOT NULL,
+      session_id      TEXT    NOT NULL,
+      repo_root       TEXT    NOT NULL,
+      run_type        TEXT    NOT NULL DEFAULT '',     -- test | lint | build | typecheck
+      command         TEXT    NOT NULL DEFAULT '',
+      passed          INTEGER NOT NULL DEFAULT 0,      -- 0 = false, 1 = true
+      duration_ms     INTEGER,
+      output          TEXT,
+      error_output    TEXT,
+      coverage_percent REAL,
+      notes           TEXT,
+      created_at      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_validation_runs_task
+      ON validation_runs (task_id);
+
+    CREATE INDEX IF NOT EXISTS idx_validation_runs_run_type
+      ON validation_runs (run_type);
+
+    CREATE INDEX IF NOT EXISTS idx_validation_runs_passed
+      ON validation_runs (passed);
+
+    -- =======================================================================
+    -- Structured procedural memory (Fortemi-inspired, WO-FM1)
+    -- Replaces flat JSON metabolism store with semantic-searchable DB
+    -- =======================================================================
+
+    -- procedural_memory: core entity for agent learnings
+    CREATE TABLE IF NOT EXISTS procedural_memory (
+      id              TEXT    PRIMARY KEY,
+      type            TEXT    NOT NULL DEFAULT 'procedural', -- procedural | episodic | semantic | normative
+      category        TEXT    NOT NULL DEFAULT 'strategy',   -- strategy | recovery | optimization
+      content         TEXT    NOT NULL DEFAULT '',            -- the lesson text
+      trigger_pattern TEXT    NOT NULL DEFAULT '',            -- when to apply this memory
+      steps           TEXT    NOT NULL DEFAULT '',            -- ordered steps (semicolon-separated)
+      source_trace    TEXT    NOT NULL DEFAULT '',            -- what created this (llm-extraction, manual, etc.)
+      utility         REAL    NOT NULL DEFAULT 0.5,           -- 0-1 usefulness score
+      confidence      REAL    NOT NULL DEFAULT 0.5,           -- 0-1 certainty score
+      access_count    INTEGER NOT NULL DEFAULT 0,
+      deleted_at      TEXT,                                   -- soft-delete (NULL = active)
+      created_at      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),
+      updated_at      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_procedural_memory_type
+      ON procedural_memory (type);
+    CREATE INDEX IF NOT EXISTS idx_procedural_memory_category
+      ON procedural_memory (category);
+    CREATE INDEX IF NOT EXISTS idx_procedural_memory_deleted
+      ON procedural_memory (deleted_at);
+
+    -- memory_revision: tracks changes to procedural memories
+    CREATE TABLE IF NOT EXISTS memory_revision (
+      id              TEXT    PRIMARY KEY,
+      memory_id       TEXT    NOT NULL REFERENCES procedural_memory(id),
+      content         TEXT    NOT NULL DEFAULT '',
+      revision_type   TEXT    NOT NULL DEFAULT 'update',     -- create | update | reinforce | decay
+      model           TEXT,                                   -- which LLM made this revision
+      created_at      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_memory_revision_memory
+      ON memory_revision (memory_id);
+
+    -- memory_embedding: vector embeddings for semantic search
+    CREATE TABLE IF NOT EXISTS memory_embedding (
+      id              TEXT    PRIMARY KEY,
+      memory_id       TEXT    NOT NULL REFERENCES procedural_memory(id),
+      vector          BLOB    NOT NULL,                       -- float32[] as binary blob
+      model           TEXT    NOT NULL DEFAULT '',             -- embedding model name
+      dimensions      INTEGER NOT NULL DEFAULT 0,
+      created_at      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_memory_embedding_memory
+      ON memory_embedding (memory_id);
+
+    -- memory_link: bidirectional relationships between memories
+    CREATE TABLE IF NOT EXISTS memory_link (
+      id              TEXT    PRIMARY KEY,
+      source_id       TEXT    NOT NULL REFERENCES procedural_memory(id),
+      target_id       TEXT    NOT NULL REFERENCES procedural_memory(id),
+      link_type       TEXT    NOT NULL DEFAULT 'related',     -- related | contradicts | supersedes
+      confidence      REAL    NOT NULL DEFAULT 0.5,
+      created_at      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_memory_link_source
+      ON memory_link (source_id);
+    CREATE INDEX IF NOT EXISTS idx_memory_link_target
+      ON memory_link (target_id);
+
+    -- =======================================================================
+    -- Unified memory substrate
+    -- Clean-room TypeScript memory layer for scoped, chunked, weighted retrieval.
+    -- =======================================================================
+
+    CREATE TABLE IF NOT EXISTS memory_scope (
+      id              TEXT    PRIMARY KEY,
+      name            TEXT    NOT NULL UNIQUE,
+      kind            TEXT    NOT NULL DEFAULT 'custom',
+      parent_id       TEXT    REFERENCES memory_scope(id) ON DELETE SET NULL,
+      repo_root       TEXT,
+      source_surface  TEXT,
+      isolation_level TEXT    NOT NULL DEFAULT 'normal',
+      metadata_json   TEXT    NOT NULL DEFAULT '{}',
+      created_at      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),
+      updated_at      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_memory_scope_kind
+      ON memory_scope (kind);
+    CREATE INDEX IF NOT EXISTS idx_memory_scope_parent
+      ON memory_scope (parent_id);
+    CREATE INDEX IF NOT EXISTS idx_memory_scope_repo
+      ON memory_scope (repo_root);
+
+    CREATE TABLE IF NOT EXISTS memory_item (
+      id              TEXT    PRIMARY KEY,
+      scope_id        TEXT    NOT NULL REFERENCES memory_scope(id) ON DELETE CASCADE,
+      kind            TEXT    NOT NULL DEFAULT 'note',
+      source          TEXT    NOT NULL DEFAULT '',
+      title           TEXT    NOT NULL DEFAULT '',
+      body            TEXT    NOT NULL DEFAULT '',
+      content_hash    TEXT    NOT NULL DEFAULT '',
+      base_weight     REAL    NOT NULL DEFAULT 0.5,
+      importance      REAL    NOT NULL DEFAULT 0.5,
+      confidence      REAL    NOT NULL DEFAULT 0.5,
+      access_count    INTEGER NOT NULL DEFAULT 0,
+      metadata_json   TEXT    NOT NULL DEFAULT '{}',
+      observed_at     TEXT,
+      expires_at      TEXT,
+      deleted_at      TEXT,
+      created_at      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),
+      updated_at      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_memory_item_scope
+      ON memory_item (scope_id);
+    CREATE INDEX IF NOT EXISTS idx_memory_item_kind
+      ON memory_item (kind);
+    CREATE INDEX IF NOT EXISTS idx_memory_item_source
+      ON memory_item (source);
+    CREATE INDEX IF NOT EXISTS idx_memory_item_hash
+      ON memory_item (content_hash);
+    CREATE INDEX IF NOT EXISTS idx_memory_item_deleted
+      ON memory_item (deleted_at);
+
+    CREATE TABLE IF NOT EXISTS memory_chunk (
+      id              TEXT    PRIMARY KEY,
+      item_id         TEXT    NOT NULL REFERENCES memory_item(id) ON DELETE CASCADE,
+      sequence        INTEGER NOT NULL DEFAULT 0,
+      text            TEXT    NOT NULL DEFAULT '',
+      start_offset    INTEGER NOT NULL DEFAULT 0,
+      end_offset      INTEGER NOT NULL DEFAULT 0,
+      token_count     INTEGER NOT NULL DEFAULT 0,
+      metadata_json   TEXT    NOT NULL DEFAULT '{}',
+      created_at      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),
+      UNIQUE(item_id, sequence)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_memory_chunk_item
+      ON memory_chunk (item_id);
+    CREATE INDEX IF NOT EXISTS idx_memory_chunk_sequence
+      ON memory_chunk (item_id, sequence);
+
+    CREATE TABLE IF NOT EXISTS memory_embedding_set (
+      id              TEXT    PRIMARY KEY,
+      slug            TEXT    NOT NULL UNIQUE,
+      set_type        TEXT    NOT NULL DEFAULT 'full',
+      model           TEXT    NOT NULL DEFAULT '',
+      dimensions      INTEGER,
+      description     TEXT    NOT NULL DEFAULT '',
+      metadata_json   TEXT    NOT NULL DEFAULT '{}',
+      created_at      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),
+      updated_at      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_memory_embedding_set_type
+      ON memory_embedding_set (set_type);
+
+    CREATE TABLE IF NOT EXISTS memory_embedding_v2 (
+      id               TEXT    PRIMARY KEY,
+      chunk_id         TEXT    NOT NULL REFERENCES memory_chunk(id) ON DELETE CASCADE,
+      embedding_set_id TEXT    NOT NULL REFERENCES memory_embedding_set(id) ON DELETE CASCADE,
+      vector           BLOB    NOT NULL,
+      model            TEXT    NOT NULL DEFAULT '',
+      dimensions       INTEGER NOT NULL DEFAULT 0,
+      input_hash       TEXT    NOT NULL DEFAULT '',
+      created_at       TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),
+      UNIQUE(chunk_id, embedding_set_id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_memory_embedding_v2_chunk
+      ON memory_embedding_v2 (chunk_id);
+    CREATE INDEX IF NOT EXISTS idx_memory_embedding_v2_set
+      ON memory_embedding_v2 (embedding_set_id);
+
+    CREATE TABLE IF NOT EXISTS memory_link_v2 (
+      id              TEXT    PRIMARY KEY,
+      source_item_id  TEXT    NOT NULL REFERENCES memory_item(id) ON DELETE CASCADE,
+      target_item_id  TEXT    NOT NULL REFERENCES memory_item(id) ON DELETE CASCADE,
+      link_type       TEXT    NOT NULL DEFAULT 'related',
+      weight          REAL    NOT NULL DEFAULT 0.5,
+      evidence        TEXT    NOT NULL DEFAULT '',
+      metadata_json   TEXT    NOT NULL DEFAULT '{}',
+      created_at      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),
+      UNIQUE(source_item_id, target_item_id, link_type)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_memory_link_v2_source
+      ON memory_link_v2 (source_item_id);
+    CREATE INDEX IF NOT EXISTS idx_memory_link_v2_target
+      ON memory_link_v2 (target_item_id);
+
+    CREATE TABLE IF NOT EXISTS memory_provenance (
+      id              TEXT    PRIMARY KEY,
+      item_id         TEXT    NOT NULL REFERENCES memory_item(id) ON DELETE CASCADE,
+      source_type     TEXT    NOT NULL DEFAULT '',
+      source_id       TEXT    NOT NULL DEFAULT '',
+      source_uri      TEXT    NOT NULL DEFAULT '',
+      observed_at     TEXT,
+      actor           TEXT    NOT NULL DEFAULT '',
+      metadata_json   TEXT    NOT NULL DEFAULT '{}',
+      created_at      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_memory_provenance_item
+      ON memory_provenance (item_id);
+    CREATE INDEX IF NOT EXISTS idx_memory_provenance_source
+      ON memory_provenance (source_type, source_id);
+
+    CREATE TABLE IF NOT EXISTS memory_job_queue (
+      id              TEXT    PRIMARY KEY,
+      job_type        TEXT    NOT NULL DEFAULT '',
+      status          TEXT    NOT NULL DEFAULT 'pending',
+      item_id         TEXT    REFERENCES memory_item(id) ON DELETE CASCADE,
+      chunk_id        TEXT    REFERENCES memory_chunk(id) ON DELETE CASCADE,
+      attempts        INTEGER NOT NULL DEFAULT 0,
+      payload_json    TEXT    NOT NULL DEFAULT '{}',
+      error           TEXT    NOT NULL DEFAULT '',
+      scheduled_at    TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),
+      started_at      TEXT,
+      completed_at    TEXT,
+      created_at      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),
+      updated_at      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_memory_job_queue_status
+      ON memory_job_queue (status, scheduled_at);
+    CREATE INDEX IF NOT EXISTS idx_memory_job_queue_item
+      ON memory_job_queue (item_id);
+
+    -- Kept as a regular table because some packaged SQLite builds crash on
+    -- FTS5 virtual-table creation. The store maintains this table as the
+    -- lexical index and can be upgraded to FTS5 behind the same API later.
+    CREATE TABLE IF NOT EXISTS memory_fts (
+      chunk_id    TEXT PRIMARY KEY,
+      item_id     TEXT NOT NULL,
+      title       TEXT NOT NULL DEFAULT '',
+      text        TEXT NOT NULL DEFAULT '',
+      source      TEXT NOT NULL DEFAULT '',
+      kind        TEXT NOT NULL DEFAULT '',
+      scope_name  TEXT NOT NULL DEFAULT ''
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_memory_fts_item
+      ON memory_fts (item_id);
+    CREATE INDEX IF NOT EXISTS idx_memory_fts_scope
+      ON memory_fts (scope_name);
+
+    CREATE TABLE IF NOT EXISTS memory_graph_node (
+      id              TEXT    PRIMARY KEY,
+      scope_id        TEXT    NOT NULL REFERENCES memory_scope(id) ON DELETE CASCADE,
+      normalized_text TEXT    NOT NULL,
+      text            TEXT    NOT NULL,
+      node_type       TEXT    NOT NULL DEFAULT 'concept',
+      weight          REAL    NOT NULL DEFAULT 0.5,
+      mention_count   INTEGER NOT NULL DEFAULT 1,
+      metadata_json   TEXT    NOT NULL DEFAULT '{}',
+      first_seen_at   TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),
+      last_seen_at    TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),
+      UNIQUE(scope_id, normalized_text, node_type)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_memory_graph_node_scope
+      ON memory_graph_node (scope_id);
+    CREATE INDEX IF NOT EXISTS idx_memory_graph_node_text
+      ON memory_graph_node (normalized_text);
+    CREATE INDEX IF NOT EXISTS idx_memory_graph_node_type
+      ON memory_graph_node (node_type);
+
+    CREATE TABLE IF NOT EXISTS memory_item_node (
+      item_id         TEXT    NOT NULL REFERENCES memory_item(id) ON DELETE CASCADE,
+      node_id         TEXT    NOT NULL REFERENCES memory_graph_node(id) ON DELETE CASCADE,
+      relation        TEXT    NOT NULL DEFAULT 'mentions',
+      weight          REAL    NOT NULL DEFAULT 0.5,
+      evidence        TEXT    NOT NULL DEFAULT '',
+      created_at      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),
+      updated_at      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),
+      PRIMARY KEY (item_id, node_id, relation)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_memory_item_node_item
+      ON memory_item_node (item_id);
+    CREATE INDEX IF NOT EXISTS idx_memory_item_node_node
+      ON memory_item_node (node_id);
+
+    CREATE TABLE IF NOT EXISTS memory_graph_edge (
+      id              TEXT    PRIMARY KEY,
+      scope_id        TEXT    NOT NULL REFERENCES memory_scope(id) ON DELETE CASCADE,
+      source_node_id  TEXT    NOT NULL REFERENCES memory_graph_node(id) ON DELETE CASCADE,
+      target_node_id  TEXT    NOT NULL REFERENCES memory_graph_node(id) ON DELETE CASCADE,
+      relation        TEXT    NOT NULL DEFAULT 'related_to',
+      weight          REAL    NOT NULL DEFAULT 0.5,
+      source_item_id  TEXT    REFERENCES memory_item(id) ON DELETE SET NULL,
+      evidence        TEXT    NOT NULL DEFAULT '',
+      metadata_json   TEXT    NOT NULL DEFAULT '{}',
+      valid_from      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),
+      valid_until     TEXT,
+      created_at      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),
+      UNIQUE(scope_id, source_node_id, target_node_id, relation, source_item_id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_memory_graph_edge_scope
+      ON memory_graph_edge (scope_id);
+    CREATE INDEX IF NOT EXISTS idx_memory_graph_edge_source
+      ON memory_graph_edge (source_node_id);
+    CREATE INDEX IF NOT EXISTS idx_memory_graph_edge_target
+      ON memory_graph_edge (target_node_id);
+    CREATE INDEX IF NOT EXISTS idx_memory_graph_edge_valid
+      ON memory_graph_edge (valid_from, valid_until);
+
+    CREATE TABLE IF NOT EXISTS memory_retrieval_event (
+      id              TEXT    PRIMARY KEY,
+      query           TEXT    NOT NULL DEFAULT '',
+      query_hash      TEXT    NOT NULL DEFAULT '',
+      item_id         TEXT    REFERENCES memory_item(id) ON DELETE SET NULL,
+      chunk_id        TEXT    REFERENCES memory_chunk(id) ON DELETE SET NULL,
+      score           REAL    NOT NULL DEFAULT 0,
+      mode            TEXT    NOT NULL DEFAULT 'hybrid',
+      materialization TEXT    NOT NULL DEFAULT 'skip',
+      outcome         TEXT    NOT NULL DEFAULT 'retrieved',
+      feedback        TEXT    NOT NULL DEFAULT '',
+      metadata_json   TEXT    NOT NULL DEFAULT '{}',
+      created_at      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_memory_retrieval_event_query
+      ON memory_retrieval_event (query_hash);
+    CREATE INDEX IF NOT EXISTS idx_memory_retrieval_event_item
+      ON memory_retrieval_event (item_id);
+    CREATE INDEX IF NOT EXISTS idx_memory_retrieval_event_outcome
+      ON memory_retrieval_event (outcome);
+
+    CREATE TABLE IF NOT EXISTS memory_weight_event (
+      id              TEXT    PRIMARY KEY,
+      item_id         TEXT    NOT NULL REFERENCES memory_item(id) ON DELETE CASCADE,
+      chunk_id        TEXT    REFERENCES memory_chunk(id) ON DELETE SET NULL,
+      delta           REAL    NOT NULL DEFAULT 0,
+      reason          TEXT    NOT NULL DEFAULT '',
+      signal          TEXT    NOT NULL DEFAULT '',
+      metadata_json   TEXT    NOT NULL DEFAULT '{}',
+      created_at      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_memory_weight_event_item
+      ON memory_weight_event (item_id);
+    CREATE INDEX IF NOT EXISTS idx_memory_weight_event_signal
+      ON memory_weight_event (signal);
+  `);
+}
+
+// packages/memory/dist/episodeStore.js
+import { join } from "node:path";
+import { mkdirSync, existsSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { createHash } from "node:crypto";
+
+// packages/memory/dist/zettelkasten.js
+var DEFAULT_CONFIG = {
+  topK: 3,
+  minSimilarity: 0.3,
+  evolutionThreshold: 0.6,
+  maxLinksPerEpisode: 10
+};
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length || a.length === 0)
+    return 0;
+  let dot = 0, normA = 0, normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  return denom > 0 ? dot / denom : 0;
+}
+function hasAssociativeEmbedding(episode) {
+  return Boolean(episode.embedding || episode.clipEmbedding);
+}
+function associativeSimilarity(episode, candidate) {
+  if (episode.embedding && candidate.embedding && episode.embedding.length === candidate.embedding.length) {
+    return cosineSimilarity(episode.embedding, candidate.embedding);
+  }
+  if (episode.clipEmbedding && candidate.clipEmbedding && episode.clipEmbedding.length === candidate.clipEmbedding.length) {
+    return cosineSimilarity(episode.clipEmbedding, candidate.clipEmbedding);
+  }
+  return null;
+}
+function findNeighbors(episode, candidates, topK, minSimilarity) {
+  if (!hasAssociativeEmbedding(episode))
+    return [];
+  const scored = [];
+  for (const candidate of candidates) {
+    if (candidate.id === episode.id)
+      continue;
+    if (!hasAssociativeEmbedding(candidate))
+      continue;
+    const sim = associativeSimilarity(episode, candidate);
+    if (sim == null)
+      continue;
+    if (sim >= minSimilarity) {
+      scored.push({ episode: candidate, similarity: sim });
+    }
+  }
+  scored.sort((a, b) => b.similarity - a.similarity);
+  return scored.slice(0, topK);
+}
+function linkEpisode(episode, episodeStore, graph, config) {
+  const cfg = { ...DEFAULT_CONFIG, ...config };
+  const result = { episodeId: episode.id, linkedTo: [], linksCreated: 0 };
+  if (!hasAssociativeEmbedding(episode))
+    return result;
+  const candidates = episodeStore.recent(500).filter(hasAssociativeEmbedding);
+  const neighbors = findNeighbors(episode, candidates, cfg.topK, cfg.minSimilarity);
+  for (const { episode: neighbor, similarity } of neighbors) {
+    if (result.linksCreated >= cfg.maxLinksPerEpisode)
+      break;
+    const srcNodeId = graph.upsertNode({
+      text: episode.content.slice(0, 100),
+      nodeType: "event"
+    });
+    const dstNodeId = graph.upsertNode({
+      text: neighbor.content.slice(0, 100),
+      nodeType: "event"
+    });
+    graph.addEdge({
+      srcId: srcNodeId,
+      dstId: dstNodeId,
+      relation: "related_to",
+      fact: `Associated: ${episode.content.slice(0, 50)} ↔ ${neighbor.content.slice(0, 50)}`,
+      edgeType: "synonym",
+      confidence: similarity,
+      sourceEpisodeId: episode.id
+    });
+    result.linkedTo.push({ neighborId: neighbor.id, similarity, linked: true });
+    result.linksCreated++;
+    if (similarity >= cfg.evolutionThreshold && neighbor.gist !== episode.content.slice(0, 200)) {
+      const evolvedGist = neighbor.gist ? `${neighbor.gist} | Also related: ${episode.content.slice(0, 100)}` : `Related context: ${episode.content.slice(0, 150)}`;
+      episodeStore.setGist(neighbor.id, evolvedGist.slice(0, 500));
+    }
+  }
+  return result;
+}
+
+// packages/memory/dist/homeostaticRegulation.js
+var DEFAULT_ENCODING = {
+  valenceWeight: 0.3,
+  arousalWeight: 0.2,
+  maxMultiplier: 1.5
+};
+var DEFAULT_RETRIEVAL = {
+  valenceCongruence: 0.5,
+  arousalCongruence: 0.3
+};
+var clampValence = (v) => clamp(v, -1, 1);
+var clampArousal = (a) => clamp(a, 0, 1);
+function clamp(x, lo, hi) {
+  if (!Number.isFinite(x))
+    return (lo + hi) / 2;
+  if (x < lo)
+    return lo;
+  if (x > hi)
+    return hi;
+  return x;
+}
+function sanitizeEmotionalState(raw) {
+  if (!raw)
+    return { valence: 0, arousal: 0 };
+  return {
+    valence: clampValence(raw.valence ?? 0),
+    arousal: clampArousal(raw.arousal ?? 0),
+    emotion: typeof raw.emotion === "string" ? raw.emotion : void 0
+  };
+}
+function importanceMultiplier(state, tuning = DEFAULT_ENCODING) {
+  const v = clampValence(state.valence);
+  const a = clampArousal(state.arousal);
+  const valenceBoost = Math.max(0, v) * tuning.valenceWeight;
+  const arousalBoost = a * tuning.arousalWeight;
+  const raw = 1 + valenceBoost + arousalBoost;
+  return Math.min(raw, tuning.maxMultiplier);
+}
+function modulateImportance(baseImportance, state, tuning = DEFAULT_ENCODING) {
+  if (!state)
+    return baseImportance;
+  const mult = importanceMultiplier(state, tuning);
+  const adjusted = baseImportance * mult;
+  if (adjusted < 0)
+    return 0;
+  if (adjusted > 10)
+    return 10;
+  return adjusted;
+}
+function congruenceMultiplier(current, memory, tuning = DEFAULT_RETRIEVAL) {
+  const valenceDist = Math.abs(clampValence(current.valence) - clampValence(memory.valence));
+  const arousalDist = Math.abs(clampArousal(current.arousal) - clampArousal(memory.arousal));
+  const valenceSim = 1 - valenceDist / 2;
+  const arousalSim = 1 - arousalDist;
+  const valenceBonus = (valenceSim - 0.5) * tuning.valenceCongruence;
+  const arousalBonus = (arousalSim - 0.5) * tuning.arousalCongruence;
+  return 1 + valenceBonus + arousalBonus;
+}
+function modulateRetrievalScore(baseScore, current, memory, tuning = DEFAULT_RETRIEVAL) {
+  if (!current || !memory)
+    return baseScore;
+  return baseScore * congruenceMultiplier(current, memory, tuning);
+}
+
+// packages/memory/dist/socialInfluence.js
+function clamp2(x, lo, hi) {
+  if (!Number.isFinite(x))
+    return (lo + hi) / 2;
+  if (x < lo)
+    return lo;
+  if (x > hi)
+    return hi;
+  return x;
+}
+function clamp012(x) {
+  return clamp2(x, 0, 1);
+}
+function conformityBias(myConfidence, groupAgreement, memoryAlignsWithGroup, weight = 0.5) {
+  const conf = clamp012(myConfidence);
+  const agree = clamp012(groupAgreement);
+  const w = clamp012(weight);
+  const pull = (agree - 0.5) * 2 * conf * w;
+  return memoryAlignsWithGroup ? 1 + pull : 1 - pull;
+}
+function authorityBias(sourceTrust, weight = 0.4) {
+  const t = clamp012(sourceTrust);
+  const w = clamp012(weight);
+  return 1 + (t - 0.5) * 2 * w;
+}
+function noveltyBias(memoryDivergence, weight = 0.3) {
+  const d = clamp012(memoryDivergence);
+  const w = clamp012(weight);
+  return 1 + d * w;
+}
+function reciprocityBias(relationshipStrength, relationshipValence, weight = 0.3) {
+  const s = clamp012(relationshipStrength);
+  const v = clamp2(relationshipValence, -1, 1);
+  const w = clamp012(weight);
+  return 1 + s * v * w;
+}
+function applyInfluence(baseScore, ctx) {
+  let m = 1;
+  if (ctx.myConfidence != null && ctx.groupAgreement != null && ctx.memoryAlignsWithGroup != null) {
+    m *= conformityBias(ctx.myConfidence, ctx.groupAgreement, ctx.memoryAlignsWithGroup, ctx.weights?.conformity);
+  }
+  if (ctx.sourceTrust != null) {
+    m *= authorityBias(ctx.sourceTrust, ctx.weights?.authority);
+  }
+  if (ctx.memoryDivergence != null) {
+    m *= noveltyBias(ctx.memoryDivergence, ctx.weights?.novelty);
+  }
+  if (ctx.relationshipStrength != null && ctx.relationshipValence != null) {
+    m *= reciprocityBias(ctx.relationshipStrength, ctx.relationshipValence, ctx.weights?.reciprocity);
+  }
+  return baseScore * m;
+}
+
+// packages/memory/dist/embodiedTrace.js
+var NEUTRAL_AFFECT = { valence: 0, arousal: 0 };
+var DEFAULT_TRACE = {
+  durationMs: 0,
+  hesitationCount: 0,
+  retryCount: 0,
+  intensity: 0,
+  confidence: 0.5,
+  cognitiveLoad: 0,
+  contextTokensUsed: 0,
+  contextTokensMax: 0,
+  affect: NEUTRAL_AFFECT,
+  timeOfDay: 0,
+  sessionDurationMin: 0,
+  consecutiveActions: 0
+};
+function clamp3(x, lo, hi) {
+  if (!Number.isFinite(x))
+    return (lo + hi) / 2;
+  if (x < lo)
+    return lo;
+  if (x > hi)
+    return hi;
+  return x;
+}
+function clamp013(x) {
+  return clamp3(x, 0, 1);
+}
+function nonNegative(x) {
+  if (!Number.isFinite(x) || x < 0)
+    return 0;
+  return x;
+}
+function buildTrace(input) {
+  const i = input ?? {};
+  const used = nonNegative(i.contextTokensUsed ?? DEFAULT_TRACE.contextTokensUsed);
+  const max = nonNegative(i.contextTokensMax ?? DEFAULT_TRACE.contextTokensMax);
+  const derivedLoad = max > 0 ? used / max : 0;
+  const load = i.cognitiveLoad != null ? clamp013(i.cognitiveLoad) : clamp013(derivedLoad);
+  return {
+    durationMs: nonNegative(i.durationMs ?? DEFAULT_TRACE.durationMs),
+    hesitationCount: Math.max(0, Math.floor(i.hesitationCount ?? 0)),
+    retryCount: Math.max(0, Math.floor(i.retryCount ?? 0)),
+    intensity: clamp013(i.intensity ?? DEFAULT_TRACE.intensity),
+    visualGist: typeof i.visualGist === "string" ? i.visualGist : void 0,
+    auditoryGist: typeof i.auditoryGist === "string" ? i.auditoryGist : void 0,
+    screenState: typeof i.screenState === "string" ? i.screenState : void 0,
+    confidence: clamp013(i.confidence ?? DEFAULT_TRACE.confidence),
+    cognitiveLoad: load,
+    contextTokensUsed: used,
+    contextTokensMax: max,
+    affect: sanitizeEmotionalState(i.affect ?? NEUTRAL_AFFECT),
+    timeOfDay: clamp3(Math.floor(i.timeOfDay ?? DEFAULT_TRACE.timeOfDay), 0, 23),
+    sessionDurationMin: nonNegative(i.sessionDurationMin ?? 0),
+    consecutiveActions: Math.max(0, Math.floor(i.consecutiveActions ?? 0))
+  };
+}
+var EMBODIED_KEY = "embodiedTrace";
+function extractTrace(metadata) {
+  if (!metadata || typeof metadata !== "object")
+    return null;
+  const raw = metadata[EMBODIED_KEY];
+  if (!raw || typeof raw !== "object")
+    return null;
+  return buildTrace(raw);
+}
+function engagementScore(trace) {
+  const alertness = 1 - trace.cognitiveLoad;
+  return clamp013((trace.intensity + alertness + trace.confidence) / 3);
+}
+
+// packages/memory/dist/pprRetrieval.js
+function readEpisodeAffect(metadata) {
+  if (!metadata || typeof metadata !== "object")
+    return null;
+  const trace = metadata["embodiedTrace"];
+  if (!trace || typeof trace !== "object")
+    return null;
+  const affect = trace["affect"];
+  if (!affect || typeof affect !== "object")
+    return null;
+  return sanitizeEmotionalState(affect);
+}
+var DEFAULT_CONFIG2 = {
+  damping: 0.5,
+  maxIterations: 50,
+  convergenceThreshold: 1e-6,
+  topK: 10
+};
+function extractQueryEntities(query) {
+  const entities = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (text) => {
+    const normalized = text.trim().toLowerCase();
+    if (normalized.length < 2 || seen.has(normalized))
+      return;
+    seen.add(normalized);
+    entities.push(text.trim());
+  };
+  const filePattern = /(?:[\w./-]+\/[\w./-]+|[\w-]+\.\w{1,5})\b/g;
+  for (const match of query.matchAll(filePattern)) {
+    if (match[0].includes(".") || match[0].includes("/"))
+      add(match[0]);
+  }
+  const errorPattern = /\b[A-Z][a-z]+(?:[A-Z][a-z]+)+\b|\b\w+(?:Error|Exception|Failed|Failure)\b/g;
+  for (const match of query.matchAll(errorPattern))
+    add(match[0]);
+  const camelPattern = /\b[a-z][a-z0-9]*(?:[A-Z][a-zA-Z0-9]+)+\b/g;
+  for (const match of query.matchAll(camelPattern))
+    add(match[0]);
+  const toolPattern = /\b(?:file_read|file_write|file_edit|shell|grep_search|find_files|memory_\w+|web_\w+|camera_\w+|audio_\w+|wifi_\w+|bluetooth_\w+|sdr_\w+|flipper_\w+|meshtastic|gps_\w+|visual_\w+)\b/g;
+  for (const match of query.matchAll(toolPattern))
+    add(match[0]);
+  const quotedPattern = /["']([^"']{2,50})["']/g;
+  for (const match of query.matchAll(quotedPattern))
+    add(match[1]);
+  const STOP_WORDS = /* @__PURE__ */ new Set([
+    "the",
+    "and",
+    "for",
+    "was",
+    "are",
+    "not",
+    "but",
+    "had",
+    "has",
+    "have",
+    "this",
+    "that",
+    "with",
+    "from",
+    "what",
+    "when",
+    "where",
+    "how",
+    "why",
+    "which",
+    "who",
+    "did",
+    "does",
+    "can",
+    "could",
+    "would",
+    "should",
+    "will",
+    "been",
+    "being",
+    "were",
+    "about",
+    "than",
+    "then",
+    "also",
+    "just",
+    "more",
+    "some",
+    "only",
+    "into",
+    "over"
+  ]);
+  const words = query.split(/\s+/).filter((w) => w.length >= 4 && !STOP_WORDS.has(w.toLowerCase()));
+  for (const word of words) {
+    if (/^[A-Z]/.test(word) || /[._-]/.test(word) || /\d/.test(word)) {
+      add(word.replace(/[.,;:!?]+$/, ""));
+    }
+  }
+  return entities;
+}
+function personalizedPageRank(graph, seedNodeIds, config) {
+  const cfg = { ...DEFAULT_CONFIG2, ...config };
+  const scores = /* @__PURE__ */ new Map();
+  if (seedNodeIds.length === 0)
+    return scores;
+  const nodeCount = graph.nodeCount();
+  if (nodeCount === 0)
+    return scores;
+  const teleportProb = 1 / seedNodeIds.length;
+  const seedSet = new Set(seedNodeIds);
+  const allNodes = /* @__PURE__ */ new Set();
+  for (const seedId of seedNodeIds) {
+    allNodes.add(seedId);
+    const neighbors = graph.neighbors(seedId);
+    for (const { node } of neighbors) {
+      allNodes.add(node.id);
+      const hop2 = graph.neighbors(node.id);
+      for (const { node: n2 } of hop2)
+        allNodes.add(n2.id);
+    }
+  }
+  for (const nodeId of allNodes) {
+    scores.set(nodeId, seedSet.has(nodeId) ? teleportProb : 0);
+  }
+  for (let iter = 0; iter < cfg.maxIterations; iter++) {
+    const newScores = /* @__PURE__ */ new Map();
+    let maxDelta = 0;
+    for (const nodeId of allNodes) {
+      const teleport = seedSet.has(nodeId) ? (1 - cfg.damping) * teleportProb : 0;
+      let walkSum = 0;
+      const inEdges = graph.currentEdges(nodeId);
+      for (const edge of inEdges) {
+        const neighborId = edge.srcId === nodeId ? edge.dstId : edge.srcId;
+        const neighborScore = scores.get(neighborId) ?? 0;
+        const neighborOutDegree = graph.currentEdges(neighborId).length || 1;
+        walkSum += neighborScore / neighborOutDegree;
+      }
+      const newScore = teleport + cfg.damping * walkSum;
+      newScores.set(nodeId, newScore);
+      const delta = Math.abs(newScore - (scores.get(nodeId) ?? 0));
+      if (delta > maxDelta)
+        maxDelta = delta;
+    }
+    for (const [id, score] of newScores)
+      scores.set(id, score);
+    if (maxDelta < cfg.convergenceThreshold) {
+      return scores;
+    }
+  }
+  return scores;
+}
+function retrieveByPPR(query, graph, episodeStore, config) {
+  const cfg = { ...DEFAULT_CONFIG2, ...config };
+  const queryEntities = extractQueryEntities(query);
+  if (queryEntities.length === 0) {
+    return { episodes: [], queryEntities: [], seedNodes: [], iterations: 0 };
+  }
+  const seedNodes = [];
+  for (const entity of queryEntities) {
+    const seedsBefore = seedNodes.length;
+    const node = graph.findNode(entity);
+    if (node) {
+      seedNodes.push(node.id);
+    }
+    const symbolNodes = graph.findSymbolNodesByName(entity, 10);
+    for (const s of symbolNodes)
+      seedNodes.push(s.id);
+    if (seedNodes.length > seedsBefore)
+      continue;
+    for (const nodeType of ["file", "error", "tool", "entity", "event", "concept", "person"]) {
+      const candidates = graph.nodesByType(nodeType, 50);
+      for (const candidate of candidates) {
+        if (candidate.text.toLowerCase().includes(entity.toLowerCase()) || entity.toLowerCase().includes(candidate.text.toLowerCase())) {
+          seedNodes.push(candidate.id);
+          break;
+        }
+      }
+      if (seedNodes.length > seedsBefore)
+        break;
+    }
+  }
+  if (seedNodes.length === 0) {
+    return { episodes: [], queryEntities, seedNodes: [], iterations: 0 };
+  }
+  const pprScores = personalizedPageRank(graph, seedNodes, cfg);
+  const episodeScores = /* @__PURE__ */ new Map();
+  for (const [nodeId, score] of pprScores) {
+    if (score < 1e-3)
+      continue;
+    const node = graph.getNode(nodeId);
+    if (!node)
+      continue;
+    const edges = graph.currentEdges(nodeId);
+    for (const edge of edges) {
+      if (edge.sourceEpisodeId) {
+        const existing = episodeScores.get(edge.sourceEpisodeId);
+        if (existing) {
+          existing.score += score;
+          existing.matchedNodes.push(node.text);
+        } else {
+          episodeScores.set(edge.sourceEpisodeId, { score, matchedNodes: [node.text] });
+        }
+      }
+    }
+  }
+  let entries = [...episodeScores.entries()];
+  const engagementWeight = cfg.engagementWeight ?? 0;
+  if (cfg.currentEmotionalState || cfg.influenceFor || engagementWeight !== 0) {
+    const current = cfg.currentEmotionalState;
+    entries = entries.map(([epId, payload]) => {
+      const ep = episodeStore.get(epId);
+      let score = payload.score;
+      if (current) {
+        const memoryAffect = ep ? readEpisodeAffect(ep.metadata) : null;
+        if (memoryAffect)
+          score = modulateRetrievalScore(score, current, memoryAffect);
+      }
+      if (cfg.influenceFor) {
+        const ctx = cfg.influenceFor(epId);
+        if (ctx)
+          score = applyInfluence(score, ctx);
+      }
+      if (engagementWeight !== 0 && ep) {
+        const trace = extractTrace(ep.metadata);
+        if (trace) {
+          const eng = engagementScore(trace);
+          score = score * (1 + (eng - 0.5) * engagementWeight);
+        }
+      }
+      return [epId, { ...payload, score }];
+    });
+  }
+  const ranked = entries.sort((a, b) => b[1].score - a[1].score).slice(0, cfg.topK);
+  const episodes = [];
+  for (const [epId, { score, matchedNodes }] of ranked) {
+    const episode = episodeStore.get(epId);
+    if (episode) {
+      episodes.push({ episode, pprScore: score, matchedNodes: [...new Set(matchedNodes)] });
+    }
+  }
+  return {
+    episodes,
+    queryEntities,
+    seedNodes,
+    iterations: cfg.maxIterations
+  };
+}
+
+// packages/memory/dist/episodeStore.js
+function readEpisodeAffect2(metadata) {
+  if (!metadata || typeof metadata !== "object")
+    return null;
+  const trace = metadata["embodiedTrace"];
+  if (!trace || typeof trace !== "object")
+    return null;
+  const affect = trace["affect"];
+  if (!affect || typeof affect !== "object")
+    return null;
+  return sanitizeEmotionalState(affect);
+}
+function readEpisodeEngagement(metadata) {
+  if (!metadata || typeof metadata !== "object")
+    return null;
+  const trace = metadata["embodiedTrace"];
+  if (!trace || typeof trace !== "object")
+    return null;
+  const t = trace;
+  const intensity = typeof t["intensity"] === "number" ? clamp01Local(t["intensity"]) : 0;
+  const cogLoad = typeof t["cognitiveLoad"] === "number" ? clamp01Local(t["cognitiveLoad"]) : 0;
+  const conf = typeof t["confidence"] === "number" ? clamp01Local(t["confidence"]) : 0.5;
+  const alertness = 1 - cogLoad;
+  return clamp01Local((intensity + alertness + conf) / 3);
+}
+function clamp01Local(x) {
+  if (!Number.isFinite(x))
+    return 0;
+  if (x < 0)
+    return 0;
+  if (x > 1)
+    return 1;
+  return x;
+}
+function stableJson(value) {
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableJson(item)).join(",")}]`;
+  }
+  const entries = Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a.localeCompare(b));
+  return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${stableJson(v)}`).join(",")}}`;
+}
+function episodeIdentityHash(ep) {
+  const identity = ep.metadata ? `${ep.content}\0metadata:${stableJson(ep.metadata)}` : ep.content;
+  return createHash("sha256").update(identity).digest("hex").slice(0, 16);
+}
+var DECAY_TAU = {
+  session: 36e5,
+  // 1 hour
+  daily: 864e5,
+  // 1 day
+  procedural: 2592e6,
+  // 30 days
+  permanent: Infinity
+};
+function sanitizeImportance(raw, fallback = 5) {
+  if (typeof raw !== "number" || !Number.isFinite(raw))
+    return fallback;
+  if (raw < 0)
+    return 0;
+  if (raw > 10)
+    return 10;
+  return raw;
+}
+function autoImportance(toolName, modality, content) {
+  if (toolName === "task_complete")
+    return 9;
+  if (["file_write", "file_edit", "file_patch", "batch_edit"].includes(toolName ?? ""))
+    return 8;
+  if (content.toLowerCase().includes("error") || content.toLowerCase().includes("failed"))
+    return 6;
+  if (["grep_search", "find_files", "codebase_map", "diagnostic"].includes(toolName ?? ""))
+    return 5;
+  if (toolName === "shell")
+    return 5;
+  if (toolName?.startsWith("memory_"))
+    return 6;
+  if (modality === "social")
+    return 9;
+  if (modality === "visual")
+    return 7;
+  if (modality === "audio")
+    return 6;
+  if (modality === "spatial")
+    return 5;
+  if (modality === "reflection")
+    return 7;
+  if (modality === "gist")
+    return 8;
+  if (toolName === "file_read")
+    return 3;
+  return 5;
+}
+function autoDecayClass(toolName, modality, content) {
+  if (toolName === "task_complete")
+    return "procedural";
+  if (toolName?.startsWith("memory_"))
+    return "procedural";
+  if (["file_write", "file_edit", "file_patch"].includes(toolName ?? ""))
+    return "daily";
+  if (content.toLowerCase().includes("error") || content.toLowerCase().includes("failed"))
+    return "procedural";
+  if (modality === "social")
+    return "permanent";
+  if (modality === "visual")
+    return "procedural";
+  if (modality === "spatial")
+    return "procedural";
+  if (modality === "audio")
+    return "daily";
+  if (modality === "reflection" || modality === "gist")
+    return "procedural";
+  if (toolName === "file_read" || toolName === "list_directory")
+    return "session";
+  return "daily";
+}
+var EpisodeStore = class {
+  db;
+  /** Read-only access to the underlying SQLite handle for cross-cutting tools
+   *  like SelfModel that need to query multiple tables atomically. */
+  getDb() {
+    return this.db;
+  }
+  /** WO-AM-05: Optional TemporalGraph for Zettelkasten auto-linking */
+  graph = null;
+  /** WO-AM-05: Zettelkasten config for neighbor linking */
+  zettelConfig = { topK: 5, minSimilarity: 0.7, evolutionThreshold: 0.6, maxLinksPerEpisode: 10 };
+  /** AUDIT-3 (A2 completion): minimum importance an inserted episode must
+   *  meet (or beat) to actually persist. When 0 (default), all episodes
+   *  pass the gate — preserves backward-compatible behavior. The
+   *  orchestrator sets this from `MemoryStageContext.importanceFloor()`
+   *  so wisdom-stage agents store fewer routine episodes than
+   *  exploration-stage agents. */
+  importanceFloor = 0;
+  /** AUDIT-3: opt-in setter so the orchestrator can override the
+   *  hardcoded zettelConfig at session start (and after sleep
+   *  consolidation) with stage-derived values. */
+  setZettelConfig(partial) {
+    this.zettelConfig = { ...this.zettelConfig, ...partial };
+  }
+  setImportanceFloor(floor) {
+    this.importanceFloor = Number.isFinite(floor) && floor > 0 ? floor : 0;
+  }
+  /** MEM_PATH item #2: bump reuse_count for an episode. Called by the
+   *  orchestrator when an episode that was retrieved is detected to have
+   *  been mentioned in a subsequent assistant turn. Idempotent on missing
+   *  ids (no row → no-op). Returns the new count, or null if not found. */
+  bumpReuseCount(id, delta = 1) {
+    const safeDelta = Number.isFinite(delta) ? delta : 1;
+    try {
+      const result = this.db.prepare(`UPDATE episodes SET reuse_count = COALESCE(reuse_count, 0) + ? WHERE id = ?`).run(safeDelta, id);
+      if (result.changes === 0)
+        return null;
+      const row = this.db.prepare(`SELECT reuse_count FROM episodes WHERE id = ?`).get(id);
+      return row?.reuse_count ?? null;
+    } catch {
+      return null;
+    }
+  }
+  constructor(dbPath, graph, zettelConfig) {
+    const dir = dbPath === ":memory:" ? null : join(dbPath, "..");
+    if (dir && !existsSync(dir))
+      mkdirSync(dir, { recursive: true });
+    this.db = initDb(dbPath);
+    this.graph = graph ?? null;
+    if (zettelConfig) {
+      this.zettelConfig = { ...this.zettelConfig, ...zettelConfig };
+    }
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS episodes (
+        id TEXT PRIMARY KEY,
+        timestamp INTEGER NOT NULL,
+        session_id TEXT,
+        task_id TEXT,
+        turn_number INTEGER,
+        modality TEXT DEFAULT 'text',
+        tool_name TEXT,
+        content TEXT NOT NULL,
+        content_hash TEXT,
+        metadata TEXT,
+        embedding BLOB,
+        importance REAL DEFAULT 5.0,
+        decay_class TEXT DEFAULT 'daily',
+        strength REAL DEFAULT 1.0,
+        last_retrieved INTEGER,
+        gist TEXT,
+        source_episode_id TEXT
+      )
+    `);
+    this.db.exec(`CREATE INDEX IF NOT EXISTS idx_ep_ts ON episodes(timestamp)`);
+    this.db.exec(`CREATE INDEX IF NOT EXISTS idx_ep_session ON episodes(session_id)`);
+    this.db.exec(`CREATE INDEX IF NOT EXISTS idx_ep_tool ON episodes(tool_name)`);
+    this.db.exec(`CREATE INDEX IF NOT EXISTS idx_ep_decay ON episodes(decay_class)`);
+    this.db.exec(`CREATE INDEX IF NOT EXISTS idx_ep_hash ON episodes(content_hash, session_id)`);
+    try {
+      this.db.exec(`
+        CREATE UNIQUE INDEX IF NOT EXISTS idx_ep_hash_unique
+          ON episodes(content_hash, COALESCE(session_id, ''), COALESCE(tool_name, ''))
+          WHERE content_hash IS NOT NULL AND content_hash != ''
+      `);
+    } catch (err) {
+      if (process.env["OMNIUS_SUPPRESS_INDEX_WARN"] !== "1" && process.env["NODE_ENV"] !== "test") {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.warn(`[episodeStore] failed to install idx_ep_hash_unique: ${msg}. Run \`node scripts/dedupe-omnius-memory.mjs --execute\` to remove existing dupes first.`);
+      }
+    }
+    try {
+      this.db.exec(`ALTER TABLE episodes ADD COLUMN clip_embedding BLOB`);
+    } catch {
+    }
+    try {
+      this.db.exec(`ALTER TABLE episodes ADD COLUMN reuse_count INTEGER DEFAULT 0`);
+    } catch {
+    }
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("synchronous = NORMAL");
+  }
+  /** Insert a new episode. Returns the episode ID. */
+  insert(ep) {
+    const id = randomUUID();
+    const now = Date.now();
+    const contentHash = episodeIdentityHash(ep);
+    const modality = ep.modality ?? "text";
+    const rawImportance = ep.importance ?? autoImportance(ep.toolName ?? null, modality, ep.content);
+    const modulated = ep.emotionalState ? modulateImportance(sanitizeImportance(rawImportance), ep.emotionalState) : sanitizeImportance(rawImportance);
+    const importance = sanitizeImportance(modulated);
+    if (this.importanceFloor > 0 && importance < this.importanceFloor) {
+      return "";
+    }
+    const decayClass = ep.decayClass ?? autoDecayClass(ep.toolName ?? null, modality, ep.content);
+    const existing = this.db.prepare(`SELECT id FROM episodes
+       WHERE content_hash = ?
+         AND COALESCE(session_id, '') = COALESCE(?, '')
+         AND COALESCE(tool_name, '') = COALESCE(?, '')
+       LIMIT 1`).get(contentHash, ep.sessionId ?? null, ep.toolName ?? null);
+    if (existing)
+      return existing.id;
+    this.db.prepare(`
+      INSERT INTO episodes (id, timestamp, session_id, task_id, turn_number, modality, tool_name, content, content_hash, metadata, importance, decay_class, strength)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1.0)
+    `).run(id, now, ep.sessionId ?? null, ep.taskId ?? null, ep.turnNumber ?? null, modality, ep.toolName ?? null, ep.content, contentHash, ep.metadata ? JSON.stringify(ep.metadata) : null, importance, decayClass);
+    if (this.graph) {
+      try {
+        const episode = this.get(id);
+        if (episode) {
+          linkEpisode(episode, this, this.graph, this.zettelConfig);
+        }
+      } catch {
+      }
+    }
+    return id;
+  }
+  /** Retrieve episodes matching a query, scored by recency + importance + (lexical + embedding). */
+  search(query, opts = {}) {
+    const now = Date.now();
+    const limit = query.limit ?? 20;
+    const qEmb = opts.queryEmbedding ?? null;
+    const wLex = opts.lexicalWeight ?? 1;
+    const wEmb = opts.embeddingWeight ?? 1;
+    let sql = "SELECT * FROM episodes WHERE 1=1";
+    const params = [];
+    if (query.sessionId) {
+      sql += " AND session_id = ?";
+      params.push(query.sessionId);
+    }
+    if (query.taskId) {
+      sql += " AND task_id = ?";
+      params.push(query.taskId);
+    }
+    if (query.toolName) {
+      sql += " AND tool_name = ?";
+      params.push(query.toolName);
+    }
+    if (query.modality) {
+      sql += " AND modality = ?";
+      params.push(query.modality);
+    }
+    if (query.since) {
+      sql += " AND timestamp >= ?";
+      params.push(query.since);
+    }
+    if (query.until) {
+      sql += " AND timestamp <= ?";
+      params.push(query.until);
+    }
+    if (query.minImportance) {
+      sql += " AND importance >= ?";
+      params.push(query.minImportance);
+    }
+    sql += " ORDER BY timestamp DESC LIMIT ?";
+    params.push(Math.min(limit * 5, 500));
+    let rows = this.db.prepare(sql).all(...params);
+    if (query.metadataFilter || query.soundClass || query.rmsRange) {
+      rows = rows.filter((row) => {
+        let meta = null;
+        try {
+          meta = row.metadata ? typeof row.metadata === "string" ? JSON.parse(row.metadata) : row.metadata : null;
+        } catch {
+          return false;
+        }
+        if (!meta)
+          return false;
+        if (query.metadataFilter) {
+          for (const [k, v] of Object.entries(query.metadataFilter)) {
+            if (meta[k] !== v)
+              return false;
+          }
+        }
+        if (query.soundClass && meta.sound_class !== query.soundClass)
+          return false;
+        if (query.rmsRange) {
+          const rms = meta.rms_db ?? meta.rmsDb;
+          if (typeof rms !== "number")
+            return false;
+          if (query.rmsRange.min !== void 0 && rms < query.rmsRange.min)
+            return false;
+          if (query.rmsRange.max !== void 0 && rms > query.rmsRange.max)
+            return false;
+        }
+        return true;
+      });
+    }
+    const scored = rows.map((row) => {
+      const ep = this.rowToEpisode(row);
+      const tau = DECAY_TAU[ep.decayClass] ?? DECAY_TAU.daily;
+      const recency = tau === Infinity ? 1 : Math.exp(-(now - ep.timestamp) / tau);
+      const importance = ep.importance / 10;
+      let lex = 0;
+      if (query.query) {
+        const queryLower = query.query.toLowerCase();
+        const contentLower = ep.content.toLowerCase();
+        const queryTerms = queryLower.split(/\s+/).filter((t) => t.length > 2);
+        const matched = queryTerms.filter((t) => contentLower.includes(t)).length;
+        lex = queryTerms.length > 0 ? matched / queryTerms.length : 0;
+      }
+      let emb = 0;
+      if (qEmb && ep.embedding && ep.embedding.length === qEmb.length) {
+        const a = ep.embedding;
+        const b = qEmb;
+        let dot = 0, na = 0, nb = 0;
+        for (let i = 0; i < a.length; i++) {
+          const va = a[i], vb = b[i];
+          dot += va * vb;
+          na += va * va;
+          nb += vb * vb;
+        }
+        const denom = Math.sqrt(na) * Math.sqrt(nb) || 1;
+        emb = dot / denom;
+        emb = Math.max(0, Math.min(1, (emb + 1) / 2));
+      }
+      const relevance = wLex * lex + wEmb * emb;
+      const strengthBonus = Math.min(1, Math.log2(Math.max(1, ep.strength)));
+      const baseScore = recency + importance + relevance + strengthBonus;
+      let score = baseScore;
+      if (opts.currentEmotionalState) {
+        const memoryAffect = readEpisodeAffect2(ep.metadata);
+        if (memoryAffect) {
+          score = modulateRetrievalScore(score, opts.currentEmotionalState, memoryAffect);
+        }
+      }
+      if (opts.influenceFor) {
+        const ctx = opts.influenceFor(ep);
+        if (ctx)
+          score = applyInfluence(score, ctx);
+      }
+      if ((opts.engagementWeight ?? 0) !== 0) {
+        const eng = readEpisodeEngagement(ep.metadata);
+        if (eng != null) {
+          score = score * (1 + (eng - 0.5) * (opts.engagementWeight ?? 0));
+        }
+      }
+      return { episode: ep, score };
+    });
+    scored.sort((a, b) => b.score - a.score);
+    const topK = scored.slice(0, limit);
+    const updateStmt = this.db.prepare("UPDATE episodes SET strength = strength + 1, last_retrieved = ? WHERE id = ?");
+    for (const { episode } of topK) {
+      updateStmt.run(now, episode.id);
+    }
+    return topK.map((s) => s.episode);
+  }
+  /** WO-AM-05: PPR-enhanced search for multi-hop retrieval (HippoRAG).
+   *  Falls back to standard search if graph is unavailable or no entities found.
+   */
+  searchWithPPR(query, opts = {}) {
+    const standardResults = this.search(query, opts);
+    if (!this.graph || !query.query) {
+      return standardResults;
+    }
+    try {
+      const pprResult = retrieveByPPR(query.query, this.graph, this, {
+        damping: 0.5,
+        maxIterations: 50,
+        convergenceThreshold: 1e-6,
+        topK: query.limit ?? 20
+      });
+      const merged = [...standardResults];
+      const seenIds = new Set(merged.map((e) => e.id));
+      for (const { episode } of pprResult.episodes) {
+        if (!seenIds.has(episode.id)) {
+          merged.push(episode);
+          seenIds.add(episode.id);
+        }
+      }
+      return merged.slice(0, query.limit ?? 20);
+    } catch {
+      return standardResults;
+    }
+  }
+  /** Get a single episode by ID. */
+  get(id) {
+    const row = this.db.prepare("SELECT * FROM episodes WHERE id = ?").get(id);
+    return row ? this.rowToEpisode(row) : null;
+  }
+  /** Get recent episodes (for context assembly). */
+  recent(limit = 10, sessionId) {
+    const sql = sessionId ? "SELECT * FROM episodes WHERE session_id = ? ORDER BY timestamp DESC LIMIT ?" : "SELECT * FROM episodes ORDER BY timestamp DESC LIMIT ?";
+    const params = sessionId ? [sessionId, limit] : [limit];
+    return this.db.prepare(sql).all(...params).map((r) => this.rowToEpisode(r));
+  }
+  /** Count episodes.
+   *
+   *  BUG FIX (2026-04-07): previously passed `sessionId` to `.get()` even
+   *  when the SQL had no placeholder, causing `RangeError: Too many
+   *  parameter values were provided` on every `count()` call without args.
+   *  Now we only bind when the placeholder is actually present.
+   */
+  count(sessionId) {
+    if (sessionId) {
+      return this.db.prepare("SELECT COUNT(*) as n FROM episodes WHERE session_id = ?").get(sessionId).n;
+    }
+    return this.db.prepare("SELECT COUNT(*) as n FROM episodes").get().n;
+  }
+  /** Prune expired session-class episodes (call at session end). */
+  pruneExpired() {
+    const sessionExpiry = Date.now() - DECAY_TAU.session * 3;
+    const result = this.db.prepare("DELETE FROM episodes WHERE decay_class = 'session' AND timestamp < ?").run(sessionExpiry);
+    return result.changes;
+  }
+  /** Update embedding for an episode (async fill from WO-AM-10). */
+  setEmbedding(id, embedding) {
+    const buf = Buffer.from(embedding.buffer);
+    this.db.prepare("UPDATE episodes SET embedding = ? WHERE id = ?").run(buf, id);
+  }
+  /** WO-AM-GAP-03: Set CLIP embedding for cross-modal retrieval (512d). */
+  setClipEmbedding(id, clipEmbedding) {
+    const buf = Buffer.from(clipEmbedding.buffer);
+    this.db.prepare("UPDATE episodes SET clip_embedding = ? WHERE id = ?").run(buf, id);
+  }
+  /** Update gist for an episode (from WO-AM-07 gist compression). */
+  setGist(id, gist) {
+    this.db.prepare("UPDATE episodes SET gist = ? WHERE id = ?").run(gist, id);
+  }
+  /** Close the database connection. */
+  close() {
+    try {
+      this.db.close();
+    } catch {
+    }
+  }
+  // ─── Internal ────────────────────────────────────────────────────────────
+  rowToEpisode(row) {
+    return {
+      id: row.id,
+      timestamp: row.timestamp,
+      sessionId: row.session_id,
+      taskId: row.task_id,
+      turnNumber: row.turn_number,
+      modality: row.modality,
+      toolName: row.tool_name,
+      content: row.content,
+      contentHash: row.content_hash,
+      metadata: row.metadata ? JSON.parse(row.metadata) : null,
+      embedding: row.embedding ? new Float32Array(new Uint8Array(row.embedding).buffer) : null,
+      // Belt-and-braces: rows from pre-fix DBs may have null importance
+      // (from legacy inserts with NaN that SQLite coerced to NULL).
+      // Re-sanitize on read so downstream code always sees a valid number.
+      importance: sanitizeImportance(row.importance),
+      decayClass: row.decay_class,
+      strength: typeof row.strength === "number" && Number.isFinite(row.strength) ? row.strength : 1,
+      lastRetrieved: row.last_retrieved,
+      clipEmbedding: row.clip_embedding ? new Float32Array(new Uint8Array(row.clip_embedding).buffer) : null,
+      gist: row.gist,
+      sourceEpisodeId: row.source_episode_id,
+      reuseCount: typeof row.reuse_count === "number" ? row.reuse_count : 0
+    };
+  }
+};
+
+// packages/memory/dist/crl/index.js
+var CRL_SYMBOLS = {
+  // Logical operators (Core)
+  THEREFORE: "∴",
+  // Conclusion marker (SymbCoT)
+  BECAUSE: "∵",
+  // Premise marker
+  EQUIVALENT: "≡",
+  // Definition/bidirectional
+  DEFINITION: ":=",
+  // Definitional equality
+  IMPLIES: "→",
+  // Forward implication
+  BICONDITIONAL: "↔",
+  // Mutual implication
+  STRONG_IMPLIES: "⟹",
+  // Logical entailment (Aristotle)
+  STRONG_IMPLIED_BY: "⟸",
+  // Reverse entailment
+  STRONG_BICONDITIONAL: "⟺",
+  // Logical equivalence
+  NOT: "¬",
+  // Negation
+  AND: "∧",
+  // Conjunction
+  OR: "∨",
+  // Disjunction
+  XOR: "⊕",
+  // Exclusive or
+  TRUE: "⊤",
+  // Tautology (LogicReward verification)
+  FALSE: "⊥",
+  // Contradiction
+  // Proof Theory / Metalogical (Aristotle framework)
+  PROVABLE: "⊢",
+  // Syntactic derivability
+  NOT_PROVABLE: "⊣",
+  // Refutation
+  MODELS: "⊨",
+  // Semantic entailment
+  NOT_MODELS: "⊭",
+  // Semantic refutation
+  FORCES: "⊩",
+  // Kripke semantics
+  NOT_PROVE: "⊬",
+  // Underivability
+  END_PROOF: "∎",
+  // QED/tombstone
+  NOTE: "※",
+  // Annotation marker
+  // Relational operators
+  ELEMENT_OF: "∈",
+  NOT_ELEMENT_OF: "∉",
+  PROPER_SUBSET: "⊂",
+  SUBSET_OR_EQUAL: "⊆",
+  PROPER_SUPERSET: "⊃",
+  SUPERSET_OR_EQUAL: "⊇",
+  UNION: "∪",
+  INTERSECTION: "∩",
+  SET_DIFFERENCE: "∖",
+  SYMMETRIC_DIFF: "△",
+  EMPTY: "∅",
+  POWER_SET: "℘",
+  // Comparison operators
+  EQUAL: "=",
+  NOT_EQUAL: "≠",
+  APPROXIMATELY: "≈",
+  PROPORTIONAL: "∝",
+  LESS_THAN: "<",
+  GREATER_THAN: ">",
+  LESS_OR_EQUAL: "≤",
+  GREATER_OR_EQUAL: "≥",
+  MUCH_LESS: "≪",
+  MUCH_GREATER: "≫",
+  // Temporal/Sequential
+  THEN: "⇒",
+  FROM: "⇐",
+  LOOP: "⟳",
+  CYCLE: "↻",
+  NEXT: "⏵",
+  PREVIOUS: "⏴",
+  // Modal/Evidential (MuSLR multimodal grounding)
+  POSSIBLE: "◇",
+  DIAMOND: "◊",
+  // Possibility (alt)
+  NECESSARY: "□",
+  BOX: "◻",
+  // Necessity (alt)
+  OBSERVED: "⊙",
+  // Empirical evidence
+  UNCERTAIN: "?",
+  CRITICAL: "!",
+  APPROXIMATE: "~",
+  NOT_POSSIBLE: "⟐",
+  // Impossibility
+  NOT_NECESSARY: "⟏",
+  // Contingency
+  // Quantifiers
+  FOR_ALL: "∀",
+  EXISTS: "∃",
+  NOT_EXISTS: "∄",
+  UNIQUE_EXISTS: "∃!",
+  // Exactly one
+  AGGREGATE: "∑",
+  PRODUCT: "∏",
+  MOST: "∀∃"
+  // Majority quantifier
+};
+var SYMBOL_MEANINGS = {
+  // Logical operators (Core)
+  "∴": "therefore",
+  "∵": "because",
+  "≡": "equivalent",
+  ":=": "definition",
+  "→": "implies",
+  "↔": "biconditional",
+  "⟹": "strong_implies",
+  "⟸": "strong_implied_by",
+  "⟺": "strong_biconditional",
+  "¬": "not",
+  "∧": "and",
+  "∨": "or",
+  "⊕": "xor",
+  "⊤": "true",
+  "⊥": "false",
+  // Proof Theory / Metalogical (Aristotle framework)
+  "⊢": "provable",
+  "⊣": "not_provable",
+  "⊨": "models",
+  "⊭": "not_models",
+  "⊩": "forces",
+  "⊬": "not_prove",
+  "∎": "end_proof",
+  "※": "note",
+  // Relational operators
+  "∈": "element_of",
+  "∉": "not_element_of",
+  "⊂": "proper_subset",
+  "⊆": "subset_or_equal",
+  "⊃": "proper_superset",
+  "⊇": "superset_or_equal",
+  "∪": "union",
+  "∩": "intersection",
+  "∖": "set_difference",
+  "△": "symmetric_difference",
+  "∅": "empty",
+  "℘": "power_set",
+  // Comparison operators
+  "=": "equal",
+  "≠": "not_equal",
+  "≈": "approximately",
+  "∝": "proportional",
+  "<": "less_than",
+  ">": "greater_than",
+  "≤": "less_or_equal",
+  "≥": "greater_or_equal",
+  "≪": "much_less",
+  "≫": "much_greater",
+  // Temporal/Sequential
+  "⇒": "then",
+  "⇐": "from",
+  "⟳": "loop",
+  "↻": "cycle",
+  "⏵": "next",
+  "⏴": "previous",
+  // Modal/Evidential (MuSLR multimodal grounding)
+  "◇": "possible",
+  "◊": "diamond",
+  "□": "necessary",
+  "◻": "box",
+  "⊙": "observed",
+  "?": "uncertain",
+  "!": "critical",
+  "~": "approximate",
+  "⟐": "not_possible",
+  "⟏": "not_necessary",
+  // Quantifiers
+  "∀": "for_all",
+  "∃": "exists",
+  "∄": "not_exists",
+  "∃!": "unique_exists",
+  "∑": "aggregate",
+  "∏": "product",
+  "∀∃": "most"
+};
+var CRLParser = class {
+  pos = 0;
+  input = "";
+  parse(input) {
+    this.input = input;
+    this.pos = 0;
+    const nodes = [];
+    const start = this.pos;
+    while (this.pos < this.input.length) {
+      this.skipWhitespace();
+      if (this.pos >= this.input.length)
+        break;
+      const node = this.parseNode();
+      if (node)
+        nodes.push(node);
+    }
+    return {
+      type: "statement",
+      nodes,
+      raw: input,
+      position: { start, end: this.pos }
+    };
+  }
+  parseNode() {
+    this.skipWhitespace();
+    if (this.peek() === "[") {
+      return this.parseConcept();
+    }
+    if (this.peek() === "$" && this.peek(1) === "{") {
+      return this.parseTemplate();
+    }
+    if (this.isQuantifier(this.peek())) {
+      return this.parseQuantifier();
+    }
+    if (this.isOperator(this.peek())) {
+      return this.parseOperator();
+    }
+    this.pos++;
+    return null;
+  }
+  parseConcept() {
+    const start = this.pos;
+    this.pos++;
+    let name = "";
+    while (this.pos < this.input.length && this.peek() !== "]") {
+      name += this.peek();
+      this.pos++;
+    }
+    this.pos++;
+    let properties;
+    if (this.peek() === "{") {
+      properties = this.parseProperties();
+    }
+    let strength;
+    if (this.peek() === "★") {
+      strength = 0;
+      while (this.peek() === "★") {
+        strength++;
+        this.pos++;
+      }
+    }
+    return {
+      type: "concept",
+      name: name.trim(),
+      properties,
+      strength,
+      raw: this.input.substring(start, this.pos),
+      position: { start, end: this.pos }
+    };
+  }
+  parseProperties() {
+    const props = {};
+    this.pos++;
+    while (this.pos < this.input.length && this.peek() !== "}") {
+      const key = this.parseIdentifier();
+      if (this.peek() === ":") {
+        this.pos++;
+        const value = this.parseIdentifier();
+        props[key] = value;
+      }
+      if (this.peek() === ",")
+        this.pos++;
+    }
+    this.pos++;
+    return props;
+  }
+  parseIdentifier() {
+    let id = "";
+    while (this.pos < this.input.length && /[a-zA-Z0-9_]/.test(this.peek())) {
+      id += this.peek();
+      this.pos++;
+    }
+    return id;
+  }
+  parseTemplate() {
+    const start = this.pos;
+    this.pos += 2;
+    let variable = "";
+    let defaultValue;
+    let typeAnnotation;
+    let transform;
+    while (this.pos < this.input.length && this.peek() !== "}" && this.peek() !== ":" && this.peek() !== "|" && this.peek() !== "→") {
+      variable += this.peek();
+      this.pos++;
+    }
+    if (this.peek() === ":") {
+      this.pos++;
+      defaultValue = "";
+      while (this.pos < this.input.length && this.peek() !== "}") {
+        defaultValue += this.peek();
+        this.pos++;
+      }
+    }
+    if (this.peek() === "|") {
+      this.pos++;
+      typeAnnotation = "";
+      while (this.pos < this.input.length && this.peek() !== "}" && this.peek() !== "→") {
+        typeAnnotation += this.peek();
+        this.pos++;
+      }
+    }
+    if (this.peek() === "→") {
+      this.pos++;
+      transform = "";
+      while (this.pos < this.input.length && this.peek() !== "}") {
+        transform += this.peek();
+        this.pos++;
+      }
+    }
+    this.pos++;
+    return {
+      type: "template",
+      variable: variable.trim(),
+      defaultValue,
+      typeAnnotation,
+      transform,
+      raw: this.input.substring(start, this.pos),
+      position: { start, end: this.pos }
+    };
+  }
+  parseQuantifier() {
+    const start = this.pos;
+    const quantifier = this.peek();
+    this.pos++;
+    let variable = "";
+    while (this.pos < this.input.length && /[a-zA-Z_]/.test(this.peek())) {
+      variable += this.peek();
+      this.pos++;
+    }
+    let domain;
+    if (this.peek() === "∈") {
+      this.pos++;
+      this.skipWhitespace();
+      domain = this.parseConcept();
+    }
+    this.skipWhitespace();
+    if (this.peek() === ":")
+      this.pos++;
+    this.skipWhitespace();
+    const predicate = this.parseNode();
+    return {
+      type: "quantifier",
+      quantifier,
+      variable,
+      domain,
+      predicate,
+      raw: this.input.substring(start, this.pos),
+      position: { start, end: this.pos }
+    };
+  }
+  parseOperator() {
+    const start = this.pos;
+    const op = this.peek();
+    this.pos++;
+    return {
+      type: "relation",
+      raw: op,
+      position: { start, end: this.pos }
+    };
+  }
+  skipWhitespace() {
+    while (this.pos < this.input.length && /\s/.test(this.peek())) {
+      this.pos++;
+    }
+  }
+  peek(offset = 0) {
+    return this.input[this.pos + offset] || "";
+  }
+  // Extended quantifiers per LogicReward (ICLR 2026)
+  isQuantifier(char) {
+    return ["∀", "∃", "∄", "∃!", "∑", "∏", "∀∃"].includes(char);
+  }
+  // Extended operators per Aristotle (ACL 2025) and MuSLR (NeurIPS 2025)
+  isOperator(char) {
+    return [
+      "∴",
+      "∵",
+      "≡",
+      ":=",
+      "→",
+      "↔",
+      "⟹",
+      "⟸",
+      "⟺",
+      "¬",
+      "∧",
+      "∨",
+      "⊕",
+      "⊤",
+      "⊥",
+      "⊢",
+      "⊣",
+      "⊨",
+      "⊭",
+      "⊩",
+      "⊬",
+      "∎",
+      "※",
+      "∈",
+      "∉",
+      "⊂",
+      "⊆",
+      "⊃",
+      "⊇",
+      "∪",
+      "∩",
+      "∖",
+      "△",
+      "∅",
+      "℘",
+      "=",
+      "≠",
+      "≈",
+      "∝",
+      "<",
+      ">",
+      "≤",
+      "≥",
+      "≪",
+      "≫",
+      "⇒",
+      "⇐",
+      "⟳",
+      "↻",
+      "⏵",
+      "⏴",
+      "◇",
+      "◊",
+      "□",
+      "◻",
+      "⊙",
+      "?",
+      "!",
+      "~",
+      "⟐",
+      "⟏"
+    ].includes(char);
+  }
+};
+var CRLEncoder = class {
+  conceptPatterns = /* @__PURE__ */ new Map();
+  /**
+   * Encode natural language text to CRL
+   */
+  encode(text) {
+    let result = this.compress(text);
+    const concepts = this.extractConcepts(result);
+    const relations = this.extractRelations(result, concepts);
+    if (relations.length > 0) {
+      return this.buildExpression(concepts, relations);
+    }
+    return result;
+  }
+  /**
+   * Extract key concepts from text
+   */
+  extractConcepts(text) {
+    const concepts = [];
+    const conceptPattern = /\[([^\]]+)\]/g;
+    let match;
+    while ((match = conceptPattern.exec(text)) !== null) {
+      concepts.push({
+        type: "concept",
+        name: match[1],
+        raw: match[0],
+        position: { start: match.index, end: match.index + match[0].length }
+      });
+    }
+    const implicitPattern = /\b([A-Z][a-z]+(?:_[A-Z][a-z]+)*)\b/g;
+    while ((match = implicitPattern.exec(text)) !== null) {
+      if (!concepts.find((c) => c.name === match[1])) {
+        concepts.push({
+          type: "concept",
+          name: match[1],
+          raw: match[0],
+          position: { start: match.index, end: match.index + match[0].length }
+        });
+      }
+    }
+    return concepts;
+  }
+  /**
+   * Extract relations between concepts
+   */
+  extractRelations(text, concepts) {
+    const relations = [];
+    const relationPattern = /\[([^\]]+)\]\s*(→|↔|∴|∵|⇒|⇐)(?::(\w+))?\s*(?:→)?\s*\[([^\]]+)\]/g;
+    let match;
+    while ((match = relationPattern.exec(text)) !== null) {
+      const from = concepts.find((c) => c.name === match[1]);
+      const to = concepts.find((c) => c.name === match[4]);
+      if (from && to) {
+        relations.push({
+          type: "relation",
+          from,
+          to,
+          operator: match[2],
+          edgeType: match[3],
+          raw: match[0],
+          position: { start: match.index, end: match.index + match[0].length }
+        });
+      }
+    }
+    return relations;
+  }
+  /**
+   * Build CRL expression from concepts and relations
+   */
+  buildExpression(concepts, relations) {
+    const lines = [];
+    for (const rel of relations) {
+      let line = `[${rel.from.name}] ${rel.operator}`;
+      if (rel.edgeType)
+        line += `:${rel.edgeType}`;
+      line += ` [${rel.to.name}]`;
+      lines.push(line);
+    }
+    const relatedConcepts = /* @__PURE__ */ new Set();
+    for (const rel of relations) {
+      relatedConcepts.add(rel.from.name);
+      relatedConcepts.add(rel.to.name);
+    }
+    for (const concept of concepts) {
+      if (!relatedConcepts.has(concept.name)) {
+        lines.push(`[${concept.name}]`);
+      }
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Compress text using CRL patterns
+   */
+  compress(text) {
+    const replacements = [
+      [/therefore/gi, "∴"],
+      [/because/gi, "∵"],
+      [/implies that/gi, "→"],
+      [/is equivalent to/gi, "≡"],
+      [/is an? element of/gi, "∈"],
+      [/is not an? element of/gi, "∉"],
+      [/is a subset of/gi, "⊂"],
+      [/for all/gi, "∀"],
+      [/there exists/gi, "∃"],
+      [/and then/gi, "⇒"],
+      [/leads to/gi, "→"],
+      [/causes/gi, "→:causes"],
+      [/fixes/gi, "→:fixes"],
+      [/relates to/gi, "∩"]
+    ];
+    let result = text;
+    for (const [pattern, replacement] of replacements) {
+      result = result.replace(pattern, replacement);
+    }
+    return result;
+  }
+};
+var CRLDecoder = class {
+  /**
+   * Decode CRL expression to natural language
+   */
+  decode(crl) {
+    const hasCRLStructure = /[\[\]∀∃∴∵→⇒⇐∩∪⊂⊃∈∉]/.test(crl);
+    if (!hasCRLStructure) {
+      return crl;
+    }
+    let result = this.expand(crl);
+    const parser = new CRLParser();
+    const ast = parser.parse(result);
+    if (ast.nodes.length > 0) {
+      const rendered = this.renderStatement(ast);
+      if (rendered && rendered.trim().length > 0) {
+        return rendered;
+      }
+    }
+    return result;
+  }
+  /**
+   * Render a statement node
+   */
+  renderStatement(node) {
+    const results = [];
+    const nodes = node.nodes;
+    for (let i = 0; i < nodes.length; i++) {
+      const current = nodes[i];
+      if (current.type === "concept" && i + 2 < nodes.length) {
+        const next = nodes[i + 1];
+        const afterNext = nodes[i + 2];
+        if (next.type === "relation" && afterNext.type === "concept") {
+          const relationNode = {
+            type: "relation",
+            from: current,
+            operator: next.raw || "",
+            to: afterNext,
+            raw: `${current.raw}${next.raw}${afterNext.raw}`,
+            position: { start: current.position.start, end: afterNext.position.end }
+          };
+          results.push(this.renderRelation(relationNode));
+          i += 2;
+          continue;
+        }
+      }
+      const rendered = this.renderNode(current);
+      if (rendered)
+        results.push(rendered);
+    }
+    return results.filter(Boolean).join(". ");
+  }
+  /**
+   * Render any CRL node
+   */
+  renderNode(node) {
+    switch (node.type) {
+      case "concept":
+        return this.renderConcept(node);
+      case "template":
+        return this.renderTemplate(node);
+      case "quantifier":
+        return this.renderQuantifier(node);
+      case "relation":
+        return this.renderRelation(node);
+      default:
+        return "";
+    }
+  }
+  /**
+   * Render a concept
+   */
+  renderConcept(node) {
+    let result = node.name;
+    if (node.properties) {
+      const props = Object.entries(node.properties).map(([k, v]) => `${k}=${v}`).join(", ");
+      result += ` (${props})`;
+    }
+    if (node.strength) {
+      result += ` [strength: ${node.strength}/5]`;
+    }
+    return result;
+  }
+  /**
+   * Render a template
+   */
+  renderTemplate(node) {
+    let result = node.variable;
+    if (node.typeAnnotation) {
+      result += ` (${node.typeAnnotation})`;
+    }
+    if (node.defaultValue) {
+      result += ` [default: ${node.defaultValue}]`;
+    }
+    return result;
+  }
+  /**
+   * Render a quantifier
+   */
+  renderQuantifier(node) {
+    const quantifierMeanings = {
+      "∀": "For all",
+      "∃": "There exists",
+      "∄": "There does not exist",
+      "∑": "Sum of",
+      "∏": "Product of"
+    };
+    let result = `${quantifierMeanings[node.quantifier]} ${node.variable}`;
+    if (node.domain) {
+      result += ` in ${this.renderNode(node.domain)}`;
+    }
+    if (node.predicate) {
+      result += `, ${this.renderNode(node.predicate)}`;
+    }
+    return result;
+  }
+  /**
+   * Render a relation
+   */
+  renderRelation(node) {
+    const operatorMeanings = {
+      "→": "implies",
+      "∴": "therefore",
+      "∵": "because",
+      "≡": "is equivalent to",
+      "↔": "is mutually related to",
+      "∈": "is an element of",
+      "⊂": "is a subset of",
+      "∪": "combined with",
+      "∩": "intersects with",
+      "⇒": "then",
+      "⇐": "from"
+    };
+    const from = node.from ? this.renderConcept(node.from) : "";
+    const to = node.to ? this.renderConcept(node.to) : "";
+    const op = operatorMeanings[node.operator] || node.operator;
+    if (node.edgeType) {
+      return `${from} ${node.edgeType} ${to}`;
+    }
+    if (from && to) {
+      return `${from} ${op} ${to}`;
+    }
+    return op;
+  }
+  /**
+   * Expand CRL symbols to natural language
+   */
+  expand(text) {
+    const expansions = {
+      "∴": "therefore",
+      "∵": "because",
+      "≡": "is equivalent to",
+      "→": "implies",
+      "↔": "is mutually related to",
+      "¬": "not",
+      "∧": "and",
+      "∨": "or",
+      "∈": "is an element of",
+      "∉": "is not an element of",
+      "⊂": "is a subset of",
+      "⊆": "is a subset of or equal to",
+      "∪": "union with",
+      "∩": "intersection with",
+      "∅": "empty",
+      "⇒": "then",
+      "⇐": "from",
+      "◇": "possibly",
+      "□": "necessarily",
+      "⊙": "observed",
+      "∀": "for all",
+      "∃": "there exists",
+      "∄": "there does not exist"
+    };
+    let result = text;
+    for (const [symbol, expansion] of Object.entries(expansions)) {
+      result = result.replace(new RegExp(`(^|[.!?]\\s*)${symbol}`, "g"), (match, prefix) => {
+        const capitalized = expansion.charAt(0).toUpperCase() + expansion.slice(1);
+        return `${prefix}${capitalized}`;
+      });
+      result = result.replace(new RegExp(`(?<!^)(?<![.!?]\\s*)${symbol}`, "g"), expansion);
+    }
+    result = result.replace(/\s+([.,;:!?])/g, "$1");
+    result = result.replace(/\s+/g, " ").trim();
+    return result;
+  }
+};
+var CRLTemplateResolver = class {
+  /**
+   * Resolve templates in CRL expression
+   */
+  resolve(crl, context) {
+    const templatePattern = /\$\{([^}]+)\}/g;
+    return crl.replace(templatePattern, (match, template) => {
+      return this.resolveTemplate(template, context);
+    });
+  }
+  resolveTemplate(template, context) {
+    let value;
+    if (template.startsWith("ctx:")) {
+      const ctxVar = template.substring(4);
+      value = context[ctxVar];
+    } else if (template.startsWith("mem:")) {
+      const memVar = template.substring(4);
+      const memArray = context.memories?.[memVar];
+      value = memArray?.join(", ");
+    } else if (template.startsWith("state:")) {
+      const stateVar = template.substring(6);
+      value = context.state?.[stateVar];
+    } else {
+      const parts = template.split(/[:|→]/);
+      const variable = parts[0].trim();
+      const defaultValue = parts[1]?.trim();
+      value = context.variables?.[variable] || defaultValue;
+    }
+    return value || `[${template}]`;
+  }
+};
+var CRL = {
+  parser: new CRLParser(),
+  encoder: new CRLEncoder(),
+  decoder: new CRLDecoder(),
+  resolver: new CRLTemplateResolver(),
+  symbols: CRL_SYMBOLS,
+  meanings: SYMBOL_MEANINGS,
+  /**
+   * Quick encode: natural language → CRL
+   */
+  encode(text) {
+    return this.encoder.encode(text);
+  },
+  /**
+   * Quick decode: CRL → natural language
+   */
+  decode(crl) {
+    return this.decoder.decode(crl);
+  },
+  /**
+   * Quick compress: replace common patterns with symbols
+   */
+  compress(text) {
+    return this.encoder.compress(text);
+  },
+  /**
+   * Quick expand: replace symbols with natural language
+   */
+  expand(text) {
+    return this.decoder.expand(text);
+  },
+  /**
+   * Resolve templates with context
+   */
+  resolve(template, context) {
+    return this.resolver.resolve(template, context);
+  }
+};
+
+// packages/memory/dist/sleepConsolidation.js
+function slowWaveReplay(db, options = {}) {
+  const topK = options.topK ?? 20;
+  const lookback = options.lookbackMs ?? 2 * 60 * 60 * 1e3;
+  const minImp = options.minImportance ?? 6;
+  const delta = options.strengthDelta ?? 1;
+  const start = Date.now();
+  const cutoff = start - lookback;
+  let rows = [];
+  try {
+    rows = db.prepare(`SELECT id FROM episodes
+           WHERE importance >= ?
+             AND timestamp >= ?
+           ORDER BY importance DESC, timestamp DESC
+           LIMIT ?`).all(minImp, cutoff, topK);
+  } catch {
+    rows = [];
+  }
+  if (rows.length === 0) {
+    return {
+      cycle: emptyCycle("slow_wave", start)
+    };
+  }
+  const ids = rows.map((r) => r.id);
+  const placeholders = ids.map(() => "?").join(",");
+  const safeDelta = Number.isFinite(delta) ? delta : 1;
+  try {
+    db.prepare(`UPDATE episodes
+          SET strength = COALESCE(strength, 1) + ?,
+              last_retrieved = ?
+        WHERE id IN (${placeholders})`).run(safeDelta, start, ...ids);
+  } catch {
+  }
+  const integratedNodes = [];
+  if (options.graph) {
+    for (const id of ids) {
+      try {
+        const referenced = db.prepare(`SELECT 1 FROM kg_edges WHERE source_episode_id = ? LIMIT 1`).get(id);
+        if (!referenced) {
+          const nodeText = `episode:${id}`;
+          const newNodeId = options.graph.upsertNode({ text: nodeText, nodeType: "event" });
+          if (newNodeId)
+            integratedNodes.push(newNodeId);
+        }
+      } catch {
+      }
+    }
+  }
+  return {
+    cycle: {
+      phase: "slow_wave",
+      startTime: start,
+      endTime: Date.now(),
+      replayedEpisodes: ids,
+      downscaledEpisodes: [],
+      prunedEpisodes: [],
+      novelAssociations: [],
+      energyCost: ids.length + integratedNodes.length,
+      compressedEpisodes: [],
+      flaggedHubs: [],
+      integratedNodes
+    }
+  };
+}
+function remDream(db, options = {}) {
+  const seeds = Math.max(1, options.seeds ?? 8);
+  const start = Date.now();
+  const novel = [];
+  let seedRows = [];
+  try {
+    seedRows = db.prepare(`SELECT id FROM episodes
+           WHERE importance >= 4
+           ORDER BY importance * COALESCE(strength, 1) DESC, RANDOM()
+           LIMIT ?`).all(seeds);
+  } catch {
+    seedRows = [];
+  }
+  if (seedRows.length === 0) {
+    return { cycle: emptyCycle("rem", start) };
+  }
+  const walkDepth = Math.max(1, options.walkDepth ?? 3);
+  const minSim = options.minSimilarity ?? 0.6;
+  for (const seed of seedRows) {
+    let candidateRows = [];
+    try {
+      candidateRows = db.prepare(`SELECT id, embedding, timestamp AS ts FROM episodes
+             WHERE session_id IS (SELECT session_id FROM episodes WHERE id = ?)
+               AND id != ?
+             ORDER BY timestamp DESC
+             LIMIT 100`).all(seed.id, seed.id);
+    } catch {
+      continue;
+    }
+    if (candidateRows.length === 0)
+      continue;
+    let seedEmb = null;
+    try {
+      seedEmb = db.prepare(`SELECT embedding FROM episodes WHERE id = ?`).get(seed.id)?.embedding ?? null;
+    } catch {
+    }
+    let chosen = null;
+    const seedFloat = toFloat32(seedEmb);
+    if (seedFloat) {
+      const distantCandidates = candidateRows.slice(walkDepth);
+      let bestSim = minSim;
+      let bestId = null;
+      for (const cand of distantCandidates) {
+        const candFloat = toFloat32(cand.embedding);
+        if (!candFloat || candFloat.length !== seedFloat.length)
+          continue;
+        const sim = cosineSim(seedFloat, candFloat);
+        if (sim > bestSim) {
+          bestSim = sim;
+          bestId = cand.id;
+        }
+      }
+      if (bestId) {
+        chosen = { id: bestId, reason: `rem-embedding-similarity:${bestSim.toFixed(3)}` };
+      }
+    }
+    if (!chosen && candidateRows.length > walkDepth) {
+      const target = candidateRows[walkDepth];
+      if (target)
+        chosen = { id: target.id, reason: "rem-temporal-distance" };
+    }
+    if (chosen)
+      novel.push({ from: seed.id, to: chosen.id, reason: chosen.reason });
+  }
+  if (options.graph && novel.length > 0) {
+    for (const link of novel) {
+      try {
+        const srcId = options.graph.upsertNode({ text: `episode:${link.from}`, nodeType: "event" });
+        const dstId = options.graph.upsertNode({ text: `episode:${link.to}`, nodeType: "event" });
+        if (srcId && dstId) {
+          options.graph.addEdge({
+            srcId,
+            dstId,
+            relation: "associated_via_rem",
+            edgeType: "associative",
+            confidence: 0.4,
+            sourceEpisodeId: link.from
+          });
+        }
+      } catch {
+      }
+    }
+  }
+  return {
+    cycle: {
+      phase: "rem",
+      startTime: start,
+      endTime: Date.now(),
+      replayedEpisodes: seedRows.map((r) => r.id),
+      downscaledEpisodes: [],
+      prunedEpisodes: [],
+      novelAssociations: novel,
+      energyCost: seedRows.length + novel.length,
+      compressedEpisodes: [],
+      flaggedHubs: [],
+      integratedNodes: []
+    }
+  };
+}
+function lightSleep(db, options = {}) {
+  const start = Date.now();
+  const downThreshold = options.downscaleThreshold ?? 0.3;
+  const downDelta = options.downscaleDelta ?? 0.1;
+  const pruneImportance = options.pruneImportanceCeiling ?? 2;
+  const maxPrune = Math.max(0, options.maxPrune ?? 200);
+  const prunableClasses = options.prunableClasses ?? ["session", "daily"];
+  const stalePerClass = {};
+  for (const c of prunableClasses) {
+    stalePerClass[c] = options.pruneStaleAfterMs ?? DECAY_TAU[c] * 2;
+  }
+  let downscaled = [];
+  try {
+    downscaled = db.prepare(`SELECT id FROM episodes
+           WHERE COALESCE(strength, 1) < ?
+           ORDER BY strength ASC
+           LIMIT 500`).all(downThreshold);
+    if (downscaled.length > 0) {
+      const placeholders = downscaled.map(() => "?").join(",");
+      const safeDelta = Number.isFinite(downDelta) ? downDelta : 0.1;
+      db.prepare(`UPDATE episodes
+            SET strength = MAX(0.05, COALESCE(strength, 1) - ?)
+          WHERE id IN (${placeholders})`).run(safeDelta, ...downscaled.map((r) => r.id));
+    }
+  } catch {
+  }
+  const promotedToDaily = [];
+  const promotedToProcedural = [];
+  try {
+    const sessionPromos = db.prepare(`SELECT id FROM episodes WHERE decay_class = 'session' AND COALESCE(reuse_count, 0) >= 3 LIMIT 200`).all();
+    for (const r of sessionPromos) {
+      try {
+        db.prepare(`UPDATE episodes SET decay_class = 'daily' WHERE id = ?`).run(r.id);
+        promotedToDaily.push(r.id);
+      } catch {
+      }
+    }
+    const dailyPromos = db.prepare(`SELECT id FROM episodes WHERE decay_class = 'daily' AND COALESCE(reuse_count, 0) >= 8 LIMIT 200`).all();
+    for (const r of dailyPromos) {
+      try {
+        db.prepare(`UPDATE episodes SET decay_class = 'procedural' WHERE id = ?`).run(r.id);
+        promotedToProcedural.push(r.id);
+      } catch {
+      }
+    }
+  } catch {
+  }
+  const pruned = [];
+  const compressed = [];
+  const compressMode = !!options.compressInsteadOfPrune;
+  const gistMaxChars = Math.max(20, options.gistMaxChars ?? 80);
+  for (const klass of prunableClasses) {
+    const stale = stalePerClass[klass];
+    const cutoff = start - stale;
+    const remaining = maxPrune - (pruned.length + compressed.length);
+    if (remaining <= 0)
+      break;
+    let rows = [];
+    try {
+      rows = db.prepare(`SELECT id, content FROM episodes
+             WHERE decay_class = ?
+               AND importance < ?
+               AND timestamp < ?
+             ORDER BY timestamp ASC
+             LIMIT ?`).all(klass, pruneImportance, cutoff, remaining);
+    } catch {
+      rows = [];
+    }
+    if (rows.length === 0)
+      continue;
+    if (compressMode) {
+      try {
+        const updateStmt = db.prepare(`UPDATE episodes
+              SET content = ?,
+                  metadata = json_patch(COALESCE(metadata, '{}'), json_object('compressedAt', ?))
+            WHERE id = ?`);
+        for (const row of rows) {
+          const truncated = (row.content ?? "").slice(0, gistMaxChars);
+          const gist = (row.content ?? "").length > gistMaxChars ? truncated + "…" : truncated;
+          try {
+            updateStmt.run(gist, start, row.id);
+            compressed.push(row.id);
+          } catch {
+            try {
+              db.prepare(`UPDATE episodes SET content = ? WHERE id = ?`).run(gist, row.id);
+              compressed.push(row.id);
+            } catch {
+            }
+          }
+        }
+      } catch {
+      }
+    } else {
+      const ids = rows.map((r) => r.id);
+      try {
+        const placeholders = ids.map(() => "?").join(",");
+        db.prepare(`DELETE FROM episodes WHERE id IN (${placeholders})`).run(...ids);
+        pruned.push(...ids);
+      } catch {
+      }
+    }
+    if (pruned.length + compressed.length >= maxPrune)
+      break;
+  }
+  const hubThreshold = Math.max(1, options.hubThreshold ?? 50);
+  const flaggedHubs = [];
+  try {
+    const rows = db.prepare(`SELECT node_id, edge_count FROM (
+         SELECT src_id AS node_id, COUNT(*) AS edge_count FROM kg_edges GROUP BY src_id
+         UNION ALL
+         SELECT dst_id AS node_id, COUNT(*) AS edge_count FROM kg_edges GROUP BY dst_id
+       )
+       GROUP BY node_id
+       HAVING SUM(edge_count) >= ?
+       ORDER BY SUM(edge_count) DESC
+       LIMIT 50`).all(hubThreshold);
+    for (const r of rows)
+      flaggedHubs.push(r.node_id);
+  } catch {
+  }
+  return {
+    cycle: {
+      phase: "light",
+      startTime: start,
+      endTime: Date.now(),
+      replayedEpisodes: [],
+      downscaledEpisodes: downscaled.map((r) => r.id),
+      prunedEpisodes: pruned,
+      novelAssociations: [],
+      energyCost: downscaled.length + pruned.length + compressed.length + flaggedHubs.length + promotedToDaily.length + promotedToProcedural.length,
+      compressedEpisodes: compressed,
+      flaggedHubs,
+      integratedNodes: [],
+      promotedToDaily,
+      promotedToProcedural
+    }
+  };
+}
+function runConsolidationCycle(db, opts = {}) {
+  const slow = slowWaveReplay(db, opts.slowWave).cycle;
+  const rem = remDream(db, opts.rem).cycle;
+  const light = lightSleep(db, opts.light).cycle;
+  return {
+    slowWave: slow,
+    rem,
+    light,
+    totalEnergy: slow.energyCost + rem.energyCost + light.energyCost
+  };
+}
+function emptyCycle(phase, start) {
+  return {
+    phase,
+    startTime: start,
+    endTime: Date.now(),
+    replayedEpisodes: [],
+    downscaledEpisodes: [],
+    prunedEpisodes: [],
+    novelAssociations: [],
+    energyCost: 0,
+    compressedEpisodes: [],
+    flaggedHubs: [],
+    integratedNodes: []
+  };
+}
+function toFloat32(raw) {
+  if (raw == null)
+    return null;
+  if (raw instanceof Float32Array) {
+    return new Float32Array(raw);
+  }
+  if (raw instanceof Uint8Array) {
+    if (raw.byteLength === 0 || raw.byteLength % 4 !== 0)
+      return null;
+    const fresh = new Uint8Array(raw.byteLength);
+    fresh.set(raw);
+    return new Float32Array(fresh.buffer, 0, raw.byteLength / 4);
+  }
+  if (raw instanceof ArrayBuffer) {
+    if (raw.byteLength === 0 || raw.byteLength % 4 !== 0)
+      return null;
+    return new Float32Array(raw.slice(0));
+  }
+  return null;
+}
+function cosineSim(a, b) {
+  if (a.length !== b.length || a.length === 0)
+    return 0;
+  let dot = 0, na = 0, nb = 0;
+  for (let i = 0; i < a.length; i++) {
+    const x = a[i];
+    const y = b[i];
+    dot += x * y;
+    na += x * x;
+    nb += y * y;
+  }
+  const denom = Math.sqrt(na) * Math.sqrt(nb);
+  if (denom === 0)
+    return 0;
+  return dot / denom;
+}
+
+// packages/memory/dist/toolOutcomes.js
+var DEFAULT_WINDOW_MS = 6 * 60 * 60 * 1e3;
+
+// packages/memory/dist/scoring.js
+var DEFAULT_CONFIG3 = {
+  recencyHalfLifeMs: 7 * 24 * 60 * 60 * 1e3,
+  // 7 days
+  minScore: 0.05,
+  hotWindowMs: 60 * 60 * 1e3,
+  // 1 hour
+  hotBoost: 2
+};
+
+// packages/memory/dist/maintenance.js
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync, renameSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join as join2 } from "node:path";
+var HOUR = 36e5;
+var DAY = 24 * HOUR;
+var DECAY_TAU2 = {
+  session: HOUR,
+  daily: DAY,
+  procedural: 30 * DAY,
+  permanent: Number.POSITIVE_INFINITY
+};
+function runMemoryMaintenance(options) {
+  const started = Date.now();
+  const result = emptyResult(options, started);
+  const shouldStop = () => Number.isFinite(options.maxRuntimeMs) && Date.now() - started >= Math.max(1e3, options.maxRuntimeMs ?? 0);
+  const stateDir = options.stateDir;
+  const episodesPath = join2(stateDir, "episodes.db");
+  const knowledgePath = join2(stateDir, "knowledge.db");
+  result.stores.episodes = storeStats(episodesPath);
+  result.stores.knowledge = storeStats(knowledgePath);
+  if (!options.dryRun)
+    mkdirSync2(stateDir, { recursive: true });
+  if (!shouldStop()) {
+    result.deferred = ingestDeferredEpisodes(stateDir, episodesPath, {
+      dryRun: !!options.dryRun
+    });
+  }
+  if (!shouldStop() && existsSync2(episodesPath)) {
+    const episodeResult = maintainEpisodes(episodesPath, options, shouldStop);
+    result.episodes = episodeResult.episodes;
+    result.compacted.episodesVacuumed = episodeResult.vacuumed;
+    result.compacted.walCheckpoints += episodeResult.walCheckpoint ? 1 : 0;
+  }
+  if (!shouldStop() && existsSync2(knowledgePath)) {
+    const graphResult = maintainGraph(knowledgePath, options, shouldStop);
+    result.graph = graphResult.graph;
+    result.compacted.knowledgeVacuumed = graphResult.vacuumed;
+    result.compacted.walCheckpoints += graphResult.walCheckpoint ? 1 : 0;
+  }
+  result.stoppedEarly = shouldStop();
+  result.stores.episodes.sizeAfterBytes = fileSize(episodesPath);
+  result.stores.knowledge.sizeAfterBytes = fileSize(knowledgePath);
+  result.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+  result.durationMs = Date.now() - started;
+  return result;
+}
+function emptyResult(options, started) {
+  const missing = (path) => ({
+    path,
+    exists: false,
+    sizeBeforeBytes: 0,
+    sizeAfterBytes: 0
+  });
+  return {
+    startedAt: new Date(started).toISOString(),
+    finishedAt: new Date(started).toISOString(),
+    durationMs: 0,
+    dryRun: !!options.dryRun,
+    stores: {
+      episodes: missing(join2(options.stateDir, "episodes.db")),
+      knowledge: missing(join2(options.stateDir, "knowledge.db"))
+    },
+    deferred: { scanned: 0, imported: 0, malformed: 0 },
+    episodes: {
+      scanned: 0,
+      lowSignalDeleted: 0,
+      duplicateDeleted: 0,
+      sleepPruned: 0,
+      sleepCompressed: 0,
+      sleepPromoted: 0
+    },
+    graph: {
+      nodesScanned: 0,
+      nodesMerged: 0,
+      edgesDeduped: 0,
+      inactiveEdgesDeleted: 0,
+      orphanNodesDeleted: 0,
+      lowSignalNodesPruned: 0,
+      lowSignalEdgesPruned: 0,
+      nodesArchived: 0,
+      nodesTotalBefore: 0,
+      nodesTotalAfter: 0
+    },
+    compacted: {
+      episodesVacuumed: false,
+      knowledgeVacuumed: false,
+      walCheckpoints: 0
+    },
+    stoppedEarly: false
+  };
+}
+function storeStats(path) {
+  return {
+    path,
+    exists: existsSync2(path),
+    sizeBeforeBytes: fileSize(path),
+    sizeAfterBytes: fileSize(path)
+  };
+}
+function fileSize(path) {
+  try {
+    return existsSync2(path) ? statSync(path).size : 0;
+  } catch {
+    return 0;
+  }
+}
+function ingestDeferredEpisodes(stateDir, episodesPath, options) {
+  const spoolPath = join2(stateDir, "memory-deferred", "episodes.jsonl");
+  const stats = { scanned: 0, imported: 0, malformed: 0 };
+  if (!existsSync2(spoolPath))
+    return stats;
+  const raw = readFileSync(spoolPath, "utf8");
+  const lines = raw.split(/\r?\n/).filter((line) => line.trim().length > 0);
+  if (lines.length === 0)
+    return stats;
+  let store = null;
+  const malformed = [];
+  try {
+    if (!options.dryRun)
+      store = new EpisodeStore(episodesPath);
+    for (const line of lines) {
+      stats.scanned++;
+      try {
+        const parsed = JSON.parse(line);
+        const episode = parsed.episode;
+        if (!episode || typeof episode.content !== "string") {
+          stats.malformed++;
+          malformed.push(line);
+          continue;
+        }
+        if (!options.dryRun && store) {
+          store.insert({
+            sessionId: typeof episode.sessionId === "string" ? episode.sessionId : void 0,
+            taskId: typeof episode.taskId === "string" ? episode.taskId : void 0,
+            turnNumber: typeof episode.turnNumber === "number" ? episode.turnNumber : void 0,
+            modality: episode.modality,
+            toolName: typeof episode.toolName === "string" ? episode.toolName : void 0,
+            content: episode.content,
+            metadata: episode.metadata && typeof episode.metadata === "object" ? episode.metadata : void 0,
+            importance: typeof episode.importance === "number" ? episode.importance : void 0,
+            decayClass: episode.decayClass,
+            sourceEpisodeId: typeof episode.sourceEpisodeId === "string" ? episode.sourceEpisodeId : void 0
+          });
+        }
+        stats.imported++;
+      } catch {
+        stats.malformed++;
+        malformed.push(line);
+      }
+    }
+  } finally {
+    store?.close();
+  }
+  if (!options.dryRun) {
+    mkdirSync2(dirname(spoolPath), { recursive: true });
+    if (malformed.length > 0) {
+      writeFileSync(spoolPath, `${malformed.join("\n")}
+`, "utf8");
+    } else {
+      const importedPath = join2(dirname(spoolPath), `episodes.${Date.now().toString(36)}.imported.jsonl`);
+      renameSync(spoolPath, importedPath);
+    }
+  }
+  return stats;
+}
+function maintainEpisodes(dbPath, options, shouldStop) {
+  const stats = {
+    scanned: 0,
+    lowSignalDeleted: 0,
+    duplicateDeleted: 0,
+    sleepPruned: 0,
+    sleepCompressed: 0,
+    sleepPromoted: 0
+  };
+  const db = initDb(dbPath);
+  let vacuumed = false;
+  let walCheckpoint = false;
+  try {
+    db.pragma("busy_timeout = 5000");
+    if (!shouldStop()) {
+      try {
+        const cycle = runConsolidationCycle(db, {
+          slowWave: { topK: 24, lookbackMs: 24 * HOUR, minImportance: 6 },
+          rem: { seeds: 8, walkDepth: 3, minSimilarity: 0.68 },
+          light: {
+            prunableClasses: ["session", "daily"],
+            pruneImportanceCeiling: 2.5,
+            pruneStaleAfterMs: 12 * HOUR,
+            maxPrune: Math.min(500, options.maxEpisodeDeletes ?? 500),
+            compressInsteadOfPrune: false
+          }
+        });
+        stats.sleepPruned = cycle.light.prunedEpisodes.length;
+        stats.sleepCompressed = cycle.light.compressedEpisodes.length;
+        stats.sleepPromoted = (cycle.light.promotedToDaily?.length ?? 0) + (cycle.light.promotedToProcedural?.length ?? 0);
+      } catch {
+      }
+    }
+    if (!shouldStop()) {
+      const candidates = loadEpisodeCandidates(db, options.maxEpisodes ?? 2500);
+      stats.scanned = candidates.length;
+      const duplicateIds = vectorDuplicateIds(candidates, options.duplicateSimilarity ?? 0.965);
+      stats.duplicateDeleted = deleteEpisodes(db, duplicateIds.slice(0, options.maxEpisodeDeletes ?? 1e3), !!options.dryRun);
+      const remainingDeleteBudget = Math.max(0, (options.maxEpisodeDeletes ?? 1e3) - stats.duplicateDeleted);
+      if (remainingDeleteBudget > 0) {
+        const lowSignalIds = candidates.filter((row) => !duplicateIds.includes(row.id)).map((row) => ({
+          id: row.id,
+          score: memoryUtilityScore(row, Date.now())
+        })).filter((row) => row.score < (options.minUtilityScore ?? 0.18)).sort((a, b) => a.score - b.score).slice(0, remainingDeleteBudget).map((row) => row.id);
+        stats.lowSignalDeleted = deleteEpisodes(db, lowSignalIds, !!options.dryRun);
+      }
+    }
+    walCheckpoint = checkpointWal(db);
+    if (!options.dryRun && options.vacuum !== false && stats.lowSignalDeleted + stats.duplicateDeleted + stats.sleepPruned > 0) {
+      vacuumed = vacuum(db);
+    }
+  } finally {
+    try {
+      db.close();
+    } catch {
+    }
+  }
+  return { episodes: stats, vacuumed, walCheckpoint };
+}
+function loadEpisodeCandidates(db, limit) {
+  try {
+    return db.prepare(`SELECT id,
+                content,
+                COALESCE(tool_name, '') AS toolName,
+                COALESCE(modality, 'text') AS modality,
+                timestamp,
+                COALESCE(last_retrieved, timestamp) AS lastAccessed,
+                COALESCE(importance, 5) AS importance,
+                COALESCE(strength, 1) AS strength,
+                COALESCE(reuse_count, 0) AS reuseCount,
+                COALESCE(decay_class, 'daily') AS decayClass,
+                embedding
+           FROM episodes
+          WHERE decay_class IN ('session', 'daily')
+            AND COALESCE(importance, 5) < 7.5
+          ORDER BY timestamp ASC
+          LIMIT ?`).all(Math.max(100, limit));
+  } catch {
+    return [];
+  }
+}
+function deleteEpisodes(db, ids, dryRun) {
+  const unique = [...new Set(ids)].filter(Boolean);
+  if (dryRun || unique.length === 0)
+    return unique.length;
+  let deleted = 0;
+  const stmt = db.prepare(`DELETE FROM episodes WHERE id = ?`);
+  const tx = db.transaction((rows) => {
+    for (const id of rows) {
+      const result = stmt.run(id);
+      deleted += Number(result.changes ?? 0);
+    }
+  });
+  tx(unique);
+  return deleted;
+}
+function maintainGraph(dbPath, options, shouldStop) {
+  const stats = {
+    nodesScanned: 0,
+    nodesMerged: 0,
+    edgesDeduped: 0,
+    inactiveEdgesDeleted: 0,
+    orphanNodesDeleted: 0,
+    lowSignalNodesPruned: 0,
+    lowSignalEdgesPruned: 0,
+    nodesArchived: 0,
+    nodesTotalBefore: 0,
+    nodesTotalAfter: 0
+  };
+  const db = initDb(dbPath);
+  let vacuumed = false;
+  let walCheckpoint = false;
+  try {
+    db.pragma("busy_timeout = 5000");
+    stats.nodesTotalBefore = countNodes(db);
+    if (!shouldStop()) {
+      const nodes = loadGraphNodeCandidates(db, options.maxGraphNodes ?? 4e3);
+      stats.nodesScanned = nodes.length;
+      const mergePairs = vectorDuplicateNodePairs(nodes, options.duplicateSimilarity ?? 0.94).slice(0, options.maxGraphDeletes ?? 1e3);
+      stats.nodesMerged = mergeGraphNodes(db, mergePairs, !!options.dryRun);
+    }
+    if (!shouldStop()) {
+      stats.edgesDeduped = dedupeGraphEdges(db, options.maxGraphDeletes ?? 2e3, !!options.dryRun);
+    }
+    if (!shouldStop()) {
+      stats.inactiveEdgesDeleted = pruneInactiveEdges(db, options.maxGraphDeletes ?? 2e3, !!options.dryRun);
+    }
+    if (!shouldStop()) {
+      stats.orphanNodesDeleted = pruneOrphanNodes(db, options.maxGraphDeletes ?? 2e3, !!options.dryRun);
+    }
+    if (!shouldStop()) {
+      const capped = pruneLowSignalNodesToCap(db, dbPath, options);
+      stats.lowSignalNodesPruned = capped.nodes;
+      stats.lowSignalEdgesPruned = capped.edges;
+      stats.nodesArchived = capped.archived;
+    }
+    stats.nodesTotalAfter = countNodes(db);
+    walCheckpoint = checkpointWal(db);
+    if (!options.dryRun && options.vacuum !== false && stats.nodesMerged + stats.edgesDeduped + stats.inactiveEdgesDeleted + stats.orphanNodesDeleted + stats.lowSignalNodesPruned > 0) {
+      vacuumed = vacuum(db);
+    }
+  } finally {
+    try {
+      db.close();
+    } catch {
+    }
+  }
+  return { graph: stats, vacuumed, walCheckpoint };
+}
+function loadGraphNodeCandidates(db, limit) {
+  try {
+    return db.prepare(`SELECT id,
+                text,
+                COALESCE(node_type, 'entity') AS nodeType,
+                COALESCE(first_seen, 0) AS firstSeen,
+                COALESCE(last_seen, 0) AS lastSeen,
+                COALESCE(mention_count, 1) AS mentionCount,
+                embedding
+           FROM kg_nodes
+          ORDER BY mention_count ASC, last_seen ASC
+          LIMIT ?`).all(Math.max(100, limit));
+  } catch {
+    return [];
+  }
+}
+function vectorDuplicateNodePairs(rows, threshold) {
+  const pairs = [];
+  const buckets = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const bucketKey = row.nodeType || "entity";
+    const bucket = buckets.get(bucketKey) ?? [];
+    const vector = vectorFor(row.embedding, row.text);
+    let merged = false;
+    for (let i = 0; i < bucket.length; i++) {
+      const other = bucket[i];
+      const otherVector = vectorFor(other.embedding, other.text);
+      if (cosine2(vector, otherVector) < threshold)
+        continue;
+      const keep = graphNodeScore(row) > graphNodeScore(other) ? row : other;
+      const drop = keep.id === row.id ? other : row;
+      pairs.push({ keepId: keep.id, dropId: drop.id });
+      if (keep.id === row.id)
+        bucket[i] = row;
+      merged = true;
+      break;
+    }
+    if (!merged)
+      bucket.push(row);
+    buckets.set(bucketKey, bucket);
+  }
+  return pairs;
+}
+function mergeGraphNodes(db, pairs, dryRun) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = pairs.filter((pair) => {
+    if (!pair.keepId || !pair.dropId || pair.keepId === pair.dropId)
+      return false;
+    if (seen.has(pair.dropId))
+      return false;
+    seen.add(pair.dropId);
+    return true;
+  });
+  if (dryRun || unique.length === 0)
+    return unique.length;
+  let merged = 0;
+  const tx = db.transaction((rows) => {
+    const src = db.prepare(`UPDATE kg_edges SET src_id = ? WHERE src_id = ?`);
+    const dst = db.prepare(`UPDATE kg_edges SET dst_id = ? WHERE dst_id = ?`);
+    const del = db.prepare(`DELETE FROM kg_nodes WHERE id = ?`);
+    const bump = db.prepare(`UPDATE kg_nodes
+          SET mention_count = mention_count + COALESCE((SELECT mention_count FROM kg_nodes WHERE id = ?), 0),
+              last_seen = MAX(last_seen, COALESCE((SELECT last_seen FROM kg_nodes WHERE id = ?), last_seen))
+        WHERE id = ?`);
+    for (const pair of rows) {
+      bump.run(pair.dropId, pair.dropId, pair.keepId);
+      src.run(pair.keepId, pair.dropId);
+      dst.run(pair.keepId, pair.dropId);
+      const deleted = del.run(pair.dropId);
+      merged += Number(deleted.changes ?? 0);
+    }
+  });
+  tx(unique);
+  return merged;
+}
+function dedupeGraphEdges(db, limit, dryRun) {
+  let ids = [];
+  try {
+    ids = db.prepare(`SELECT id FROM (
+             SELECT id,
+                    ROW_NUMBER() OVER (
+                      PARTITION BY src_id, dst_id, relation, COALESCE(fact, ''), COALESCE(modality, ''), COALESCE(valid_until, -1)
+                      ORDER BY confidence DESC, valid_from DESC, id DESC
+                    ) AS rn
+               FROM kg_edges
+           )
+           WHERE rn > 1
+           LIMIT ?`).all(Math.max(1, limit)).map((row) => row.id);
+  } catch {
+    return 0;
+  }
+  if (dryRun || ids.length === 0)
+    return ids.length;
+  return deleteById(db, "kg_edges", ids);
+}
+function pruneInactiveEdges(db, limit, dryRun) {
+  const cutoff = Date.now() - 14 * DAY;
+  let ids = [];
+  try {
+    ids = db.prepare(`SELECT id
+             FROM kg_edges
+            WHERE valid_until IS NOT NULL
+              AND valid_until < ?
+              AND COALESCE(confidence, 1) < 0.55
+            ORDER BY valid_until ASC
+            LIMIT ?`).all(cutoff, Math.max(1, limit)).map((row) => row.id);
+  } catch {
+    return 0;
+  }
+  if (dryRun || ids.length === 0)
+    return ids.length;
+  return deleteById(db, "kg_edges", ids);
+}
+function pruneOrphanNodes(db, limit, dryRun) {
+  const cutoff = Date.now() - 30 * DAY;
+  let ids = [];
+  try {
+    ids = db.prepare(`SELECT n.id
+             FROM kg_nodes n
+            WHERE COALESCE(n.mention_count, 1) <= 1
+              AND COALESCE(n.last_seen, 0) < ?
+              AND NOT EXISTS (SELECT 1 FROM kg_edges e WHERE e.src_id = n.id OR e.dst_id = n.id)
+            ORDER BY n.last_seen ASC
+            LIMIT ?`).all(cutoff, Math.max(1, limit)).map((row) => row.id);
+  } catch {
+    return 0;
+  }
+  if (dryRun || ids.length === 0)
+    return ids.length;
+  return deleteById(db, "kg_nodes", ids);
+}
+function countNodes(db) {
+  try {
+    const row = db.prepare("SELECT COUNT(*) AS n FROM kg_nodes").get();
+    return Number(row?.n ?? 0);
+  } catch {
+    return 0;
+  }
+}
+function selectCapEvictionCandidates(db, options, withText) {
+  const cap = Math.max(0, options.graphTargetNodes ?? Number(process.env["OMNIUS_KG_TARGET_NODES"] ?? 5e3));
+  if (!Number.isFinite(cap) || cap <= 0)
+    return [];
+  const total = countNodes(db);
+  if (total <= cap)
+    return [];
+  const overflow = total - cap;
+  const batch = Math.min(overflow, options.maxGraphDeletes ?? 2e3);
+  if (batch <= 0)
+    return [];
+  const now = Date.now();
+  const protectMs = Math.max(0, options.graphProtectRecentMs ?? DAY);
+  const protectCut = now - protectMs;
+  const protect = new Set(options.graphProtectNodeIds ?? []);
+  const hubDegreeGuard = 6;
+  try {
+    const shortlistLimit = Math.max(1, Math.min(batch * 4, batch + 2e4));
+    const cols = withText ? `id, COALESCE(text, '') AS text, COALESCE(node_type, 'entity') AS nodeType,
+         COALESCE(mention_count, 1) AS mc, COALESCE(last_seen, 0) AS ls` : `id, '' AS text, 'entity' AS nodeType,
+         COALESCE(mention_count, 1) AS mc, COALESCE(last_seen, 0) AS ls`;
+    const shortlist = db.prepare(`SELECT ${cols}
+           FROM kg_nodes
+          WHERE COALESCE(last_seen, 0) < ?
+          ORDER BY mc ASC, ls ASC
+          LIMIT ?`).all(protectCut, shortlistLimit);
+    const degStmt = db.prepare("SELECT COUNT(*) AS d FROM kg_edges WHERE src_id = ? OR dst_id = ?");
+    const scored = [];
+    for (const row of shortlist) {
+      if (protect.has(row.id))
+        continue;
+      let deg = 0;
+      try {
+        deg = Number(degStmt.get(row.id, row.id)?.d ?? 0);
+      } catch {
+        deg = 0;
+      }
+      if (deg >= hubDegreeGuard)
+        continue;
+      const ageMs = Math.max(0, now - row.ls);
+      const recency = Math.exp(-ageMs / (30 * DAY));
+      const utility = Math.log1p(row.mc) * 0.5 + Math.min(deg, 8) / 8 * 0.3 + recency * 0.2;
+      scored.push({
+        id: row.id,
+        text: row.text,
+        nodeType: row.nodeType,
+        mentionCount: row.mc,
+        degree: deg,
+        lastSeen: row.ls,
+        score: utility
+      });
+    }
+    scored.sort((a, b) => a.score - b.score || a.lastSeen - b.lastSeen);
+    return scored.slice(0, batch).map(({ score: _score, ...c }) => c);
+  } catch {
+    return [];
+  }
+}
+function pruneLowSignalNodesToCap(db, dbPath, options) {
+  const candidates = selectCapEvictionCandidates(db, options, false).map((c) => c.id);
+  if (candidates.length === 0)
+    return { nodes: 0, edges: 0, archived: 0 };
+  if (options.dryRun)
+    return { nodes: candidates.length, edges: 0, archived: 0 };
+  return archiveAndDeleteNodes(db, dbPath, candidates, options.graphArchive !== false);
+}
+function selectGraphPruneCandidates(dbPath, options) {
+  if (!existsSync2(dbPath))
+    return [];
+  const db = initDb(dbPath);
+  try {
+    db.pragma("busy_timeout = 5000");
+    return selectCapEvictionCandidates(db, options, true);
+  } catch {
+    return [];
+  } finally {
+    try {
+      db.close();
+    } catch {
+    }
+  }
+}
+function reinforceGraphNodes(dbPath, ids) {
+  if (!existsSync2(dbPath) || ids.length === 0)
+    return 0;
+  const db = initDb(dbPath);
+  try {
+    db.pragma("busy_timeout = 5000");
+    const now = Date.now();
+    const stmt = db.prepare("UPDATE kg_nodes SET last_seen = ?, mention_count = COALESCE(mention_count, 1) + 1 WHERE id = ?");
+    let updated = 0;
+    const tx = db.transaction((rows) => {
+      for (const id of rows)
+        updated += Number(stmt.run(now, id).changes ?? 0);
+    });
+    tx(ids);
+    return updated;
+  } catch {
+    return 0;
+  } finally {
+    try {
+      db.close();
+    } catch {
+    }
+  }
+}
+function archiveAndDeleteNodes(db, dbPath, ids, archive) {
+  if (ids.length === 0)
+    return { nodes: 0, edges: 0, archived: 0 };
+  const archivePath = dbPath.replace(/\.db$/i, ".archive.db");
+  let attached = false;
+  let archived = 0;
+  let nodesDeleted = 0;
+  let edgesDeleted = 0;
+  try {
+    if (archive) {
+      try {
+        db.prepare("ATTACH DATABASE ? AS kgarchive").run(archivePath);
+        attached = true;
+        db.exec("CREATE TABLE IF NOT EXISTS kgarchive.kg_nodes AS SELECT * FROM main.kg_nodes WHERE 0");
+        db.exec("CREATE TABLE IF NOT EXISTS kgarchive.kg_edges AS SELECT * FROM main.kg_edges WHERE 0");
+      } catch {
+        attached = false;
+      }
+    }
+    const chunkSize = 250;
+    const run = db.transaction((chunk) => {
+      const ph = chunk.map(() => "?").join(",");
+      if (attached) {
+        try {
+          const n = db.prepare(`INSERT INTO kgarchive.kg_nodes SELECT * FROM main.kg_nodes WHERE id IN (${ph})`).run(...chunk);
+          archived += Number(n.changes ?? 0);
+          db.prepare(`INSERT INTO kgarchive.kg_edges SELECT * FROM main.kg_edges WHERE src_id IN (${ph}) OR dst_id IN (${ph})`).run(...chunk, ...chunk);
+        } catch {
+        }
+      }
+      const e = db.prepare(`DELETE FROM kg_edges WHERE src_id IN (${ph}) OR dst_id IN (${ph})`).run(...chunk, ...chunk);
+      edgesDeleted += Number(e.changes ?? 0);
+      const nd = db.prepare(`DELETE FROM kg_nodes WHERE id IN (${ph})`).run(...chunk);
+      nodesDeleted += Number(nd.changes ?? 0);
+    });
+    for (let i = 0; i < ids.length; i += chunkSize) {
+      run(ids.slice(i, i + chunkSize));
+    }
+  } finally {
+    if (attached) {
+      try {
+        db.exec("DETACH DATABASE kgarchive");
+      } catch {
+      }
+    }
+  }
+  return { nodes: nodesDeleted, edges: edgesDeleted, archived };
+}
+function deleteById(db, table, ids) {
+  let deleted = 0;
+  const stmt = db.prepare(`DELETE FROM ${table} WHERE id = ?`);
+  const tx = db.transaction((rows) => {
+    for (const id of rows) {
+      const result = stmt.run(id);
+      deleted += Number(result.changes ?? 0);
+    }
+  });
+  tx(ids);
+  return deleted;
+}
+function vectorDuplicateIds(rows, threshold) {
+  const duplicateIds = [];
+  const buckets = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const key = `${row.toolName}\0${row.modality}`;
+    const bucket = buckets.get(key) ?? [];
+    const vector = vectorFor(row.embedding, row.content);
+    let absorbed = false;
+    for (let i = 0; i < bucket.length; i++) {
+      const other = bucket[i];
+      const otherVector = vectorFor(other.embedding, other.content);
+      if (cosine2(vector, otherVector) < threshold)
+        continue;
+      const keep = memoryUtilityScore(row, Date.now()) > memoryUtilityScore(other, Date.now()) ? row : other;
+      const drop = keep.id === row.id ? other : row;
+      duplicateIds.push(drop.id);
+      if (keep.id === row.id)
+        bucket[i] = row;
+      absorbed = true;
+      break;
+    }
+    if (!absorbed)
+      bucket.push(row);
+    buckets.set(key, bucket);
+  }
+  return [...new Set(duplicateIds)];
+}
+function memoryUtilityScore(row, now) {
+  const tau = DECAY_TAU2[row.decayClass] ?? DECAY_TAU2.daily;
+  const retention = tau === Number.POSITIVE_INFINITY ? 1 : Math.exp(-Math.max(0, now - row.lastAccessed) / tau);
+  const importance = clamp014(row.importance / 10);
+  const strength = clamp014(Math.log2(Math.max(1, row.strength)) / 4);
+  const reuse = clamp014(Math.log1p(Math.max(0, row.reuseCount)) / Math.log(9));
+  const recentUse = now - row.lastAccessed <= 6 * HOUR ? 1 : 0;
+  return importance * 0.42 + retention * 0.22 + strength * 0.16 + reuse * 0.16 + recentUse * 0.04;
+}
+function graphNodeScore(row) {
+  const age = Math.max(0, Date.now() - row.lastSeen);
+  const recency = Math.exp(-age / (30 * DAY));
+  return Math.log1p(Math.max(0, row.mentionCount)) * 0.7 + recency * 0.3;
+}
+function vectorFor(rawEmbedding, text) {
+  const decoded = decodeEmbedding(rawEmbedding);
+  return decoded ?? hashEmbedding(text);
+}
+function decodeEmbedding(raw) {
+  if (!raw)
+    return null;
+  if (raw instanceof Float32Array)
+    return Array.from(raw);
+  if (raw instanceof Uint8Array) {
+    if (raw.byteLength === 0 || raw.byteLength % 4 !== 0)
+      return null;
+    const copy = new Uint8Array(raw.byteLength);
+    copy.set(raw);
+    return Array.from(new Float32Array(copy.buffer));
+  }
+  if (raw instanceof ArrayBuffer) {
+    if (raw.byteLength === 0 || raw.byteLength % 4 !== 0)
+      return null;
+    return Array.from(new Float32Array(raw.slice(0)));
+  }
+  return null;
+}
+function hashEmbedding(text, dimensions = 256) {
+  const dim = Math.max(16, dimensions);
+  const vector = new Array(dim).fill(0);
+  const tokens = text.toLowerCase().split(/[^\p{L}\p{N}_./-]+/u).map((token) => token.trim()).filter(Boolean);
+  const features = [...tokens];
+  for (let i = 0; i < tokens.length - 1; i++) {
+    features.push(`${tokens[i]} ${tokens[i + 1]}`);
+  }
+  for (const feature of features) {
+    const h = fnv1a(feature);
+    const idx = h % dim;
+    const sign = (h & 2147483648) === 0 ? 1 : -1;
+    vector[idx] += sign;
+  }
+  const norm = Math.sqrt(vector.reduce((sum, value) => sum + value * value, 0));
+  return norm ? vector.map((value) => value / norm) : vector;
+}
+function fnv1a(value) {
+  let hash = 2166136261;
+  for (let i = 0; i < value.length; i++) {
+    hash ^= value.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+function cosine2(a, b) {
+  if (a.length !== b.length || a.length === 0)
+    return 0;
+  let dot = 0;
+  let na = 0;
+  let nb = 0;
+  for (let i = 0; i < a.length; i++) {
+    const x = a[i];
+    const y = b[i];
+    dot += x * y;
+    na += x * x;
+    nb += y * y;
+  }
+  const denom = Math.sqrt(na) * Math.sqrt(nb);
+  return denom ? dot / denom : 0;
+}
+function clamp014(value) {
+  if (!Number.isFinite(value))
+    return 0;
+  if (value < 0)
+    return 0;
+  if (value > 1)
+    return 1;
+  return value;
+}
+function checkpointWal(db) {
+  try {
+    db.pragma("wal_checkpoint(TRUNCATE)");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function vacuum(db) {
+  try {
+    db.exec("VACUUM");
+    db.pragma("optimize");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// packages/cli/src/tui/memory-maintenance-worker.ts
+import { join as join3 } from "node:path";
+
+// packages/cli/src/tui/commands/kg-prune-inference.ts
+function truncate(text, max) {
+  const clean = text.replace(/\s+/g, " ").trim();
+  return clean.length > max ? clean.slice(0, max - 1) + "…" : clean;
+}
+async function classifySignalNodes(candidates, cfg) {
+  const max = Math.max(1, Math.min(cfg.maxCandidates ?? 40, 100));
+  const sample = candidates.slice(0, max);
+  if (sample.length === 0) return { reviewed: 0, keepIds: [], ok: true };
+  if (!cfg.model || !cfg.backendUrl) {
+    return { reviewed: 0, keepIds: [], ok: false, error: "no model/endpoint" };
+  }
+  const list = sample.map(
+    (n, i) => `${i + 1}. id=${n.id} type=${n.nodeType} mentions=${n.mentionCount} edges=${n.degree} :: ${truncate(n.text, 160)}`
+  ).join("\n");
+  const system = 'You are the memory-consolidation process of an AI agent, running during idle time (like sleep). You are shown low-activity knowledge-graph nodes that are scheduled to be FORGOTTEN to keep memory bounded. Your job: rescue only the ones that are durable SIGNAL — stable facts, real entities, decisions, identities, or reusable knowledge the agent will likely need again. Let transient, redundant, trivial, or noisy nodes be forgotten. Reply with ONLY a JSON array of the id strings to KEEP, e.g. ["a1","b2"]. Keep the array short and selective. If none are worth keeping, reply []';
+  const user = `Nodes scheduled for forgetting:
+${list}
+
+Return the JSON array of ids to KEEP.`;
+  const timeoutMs = Math.max(3e3, cfg.timeoutMs ?? 3e4);
+  try {
+    const res = await fetch(`${cfg.backendUrl.replace(/\/$/, "")}/api/chat`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: cfg.model,
+        messages: [
+          { role: "system", content: system },
+          { role: "user", content: user }
+        ],
+        stream: false,
+        think: false,
+        options: { temperature: 0 },
+        keep_alive: "5m"
+      }),
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    if (!res.ok) {
+      return {
+        reviewed: sample.length,
+        keepIds: [],
+        ok: false,
+        error: `HTTP ${res.status}`
+      };
+    }
+    const data = await res.json();
+    const content = data.message?.content ?? data.response ?? "";
+    const keepIds = parseIdArray(content, new Set(sample.map((n) => n.id)));
+    return { reviewed: sample.length, keepIds, ok: true };
+  } catch (err) {
+    return {
+      reviewed: sample.length,
+      keepIds: [],
+      ok: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+function parseIdArray(content, valid) {
+  const match = content.match(/\[[\s\S]*?\]/);
+  if (!match) return [];
+  let parsed;
+  try {
+    parsed = JSON.parse(match[0]);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(parsed)) return [];
+  const out = [];
+  for (const item of parsed) {
+    const id = typeof item === "string" ? item : String(item ?? "");
+    if (id && valid.has(id) && !out.includes(id)) out.push(id);
+  }
+  return out;
+}
+
+// packages/cli/src/tui/memory-maintenance-worker.ts
+function readBool(name, fallback) {
+  const raw = process.env[name];
+  if (raw === void 0 || raw === "") return fallback;
+  return /^(1|true|yes|on)$/i.test(raw);
+}
+function readNumber(name, fallback) {
+  const raw = process.env[name];
+  if (!raw) return fallback;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+async function inferSignalProtectSet(stateDir, options) {
+  const model = process.env["OMNIUS_KG_PRUNE_MODEL"] || process.env["OMNIUS_MODEL"] || "";
+  const inferenceOn = readBool("OMNIUS_KG_PRUNE_INFERENCE", Boolean(model));
+  if (!inferenceOn || !model) return { protectIds: [], reinforced: 0 };
+  const knowledgePath = join3(stateDir, "knowledge.db");
+  const candidates = selectGraphPruneCandidates(knowledgePath, options);
+  if (candidates.length === 0) return { protectIds: [], reinforced: 0 };
+  const backendUrl = process.env["OMNIUS_KG_PRUNE_BACKEND_URL"] || process.env["OMNIUS_BACKEND_URL"] || process.env["OLLAMA_HOST"] || "http://127.0.0.1:11434";
+  const cls = await classifySignalNodes(candidates, {
+    backendUrl,
+    model,
+    timeoutMs: readNumber("OMNIUS_KG_PRUNE_INFERENCE_TIMEOUT_MS", 3e4),
+    maxCandidates: readNumber("OMNIUS_KG_PRUNE_INFERENCE_MAX", 40)
+  });
+  if (!cls.ok || cls.keepIds.length === 0) {
+    return { protectIds: cls.keepIds, reinforced: 0 };
+  }
+  const reinforced = options.dryRun ? 0 : reinforceGraphNodes(knowledgePath, cls.keepIds);
+  return { protectIds: cls.keepIds, reinforced };
+}
+async function main() {
+  const stateDir = process.env["OMNIUS_MEMORY_MAINTENANCE_STATE_DIR"];
+  if (!stateDir) throw new Error("OMNIUS_MEMORY_MAINTENANCE_STATE_DIR is required");
+  const options = {
+    stateDir,
+    dryRun: readBool("OMNIUS_MEMORY_MAINTENANCE_DRY_RUN", false),
+    vacuum: readBool("OMNIUS_MEMORY_MAINTENANCE_VACUUM", true),
+    maxRuntimeMs: readNumber("OMNIUS_MEMORY_MAINTENANCE_MAX_MS", 12e4),
+    maxEpisodes: readNumber("OMNIUS_MEMORY_MAINTENANCE_MAX_EPISODES", 2500),
+    maxEpisodeDeletes: readNumber("OMNIUS_MEMORY_MAINTENANCE_MAX_EPISODE_DELETES", 1e3),
+    maxGraphNodes: readNumber("OMNIUS_MEMORY_MAINTENANCE_MAX_GRAPH_NODES", 4e3),
+    maxGraphDeletes: readNumber("OMNIUS_MEMORY_MAINTENANCE_MAX_GRAPH_DELETES", 2e3),
+    duplicateSimilarity: readNumber("OMNIUS_MEMORY_MAINTENANCE_SIMILARITY", 0.965),
+    minUtilityScore: readNumber("OMNIUS_MEMORY_MAINTENANCE_MIN_UTILITY", 0.18),
+    // Cap-based KG decay prune — the floor that keeps knowledge.db bounded.
+    graphTargetNodes: readNumber("OMNIUS_KG_TARGET_NODES", 5e3),
+    graphArchive: readBool("OMNIUS_KG_PRUNE_ARCHIVE", true),
+    graphProtectRecentMs: readNumber(
+      "OMNIUS_KG_PROTECT_RECENT_MS",
+      24 * 60 * 60 * 1e3
+    )
+  };
+  const inference = await inferSignalProtectSet(stateDir, options).catch(() => ({
+    protectIds: [],
+    reinforced: 0
+  }));
+  if (inference.protectIds.length > 0) {
+    options.graphProtectNodeIds = inference.protectIds;
+  }
+  const result = runMemoryMaintenance(options);
+  process.stdout.write(
+    `${JSON.stringify({
+      ...result,
+      inference: {
+        protectedSignal: inference.protectIds.length,
+        reinforced: inference.reinforced
+      }
+    })}
+`
+  );
+}
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`[memory-maintenance-worker] ${message}
+`);
+  process.exitCode = 1;
+});