@clude/sdk 3.2.0 → 3.3.1

package/dist/sdk/index.js

@@ -67,7 +67,20 @@ var init_config = __esm({
         accessToken: requiredUnlessSiteOnly("X_ACCESS_TOKEN"),
         accessSecret: requiredUnlessSiteOnly("X_ACCESS_SECRET"),
         botUserId: requiredUnlessSiteOnly("X_BOT_USER_ID"),
-        creatorUserId: optional("CREATOR_USER_ID", "")
+        creatorUserId: optional("CREATOR_USER_ID", ""),
+        /**
+         * Bearer token for the public "$ANSEM LIVE" feed (GET /api/ansem/feed).
+         * Reads-only X app bearer — used server-side for GET /2/tweets/search/recent.
+         * Empty → the feed endpoint returns { enabled:false } and the frontend panel hides.
+         * NEVER sent to the browser.
+         */
+        searchBearer: optional("X_SEARCH_BEARER", ""),
+        /** Min poll gap for the on-demand $ANSEM feed (ms). Idle → no polling → $0. */
+        ansemFeedIntervalMs: parseInt(optional("ANSEM_FEED_INTERVAL_MS", "90000"), 10),
+        /** Posts older than ~15min must clear this like floor (fresh posts are exempt). */
+        ansemFeedMinLikes: parseInt(optional("ANSEM_FEED_MIN_LIKES", "3"), 10),
+        /** Hard daily read-cap: once exceeded, serve the stale buffer (cost stop-loss). */
+        ansemFeedDailyReadCap: parseInt(optional("ANSEM_FEED_DAILY_READ_CAP", "40000"), 10)
       },
       supabase: {
         url: requiredUnlessSiteOnly("SUPABASE_URL"),
@@ -85,7 +98,9 @@ var init_config = __esm({
           optional("SOLANA_NETWORK", "mainnet-beta") === "devnet" ? "https://api.devnet.solana.com" : "https://api.mainnet-beta.solana.com"
         ),
         botWalletPrivateKey: optional("BOT_WALLET_PRIVATE_KEY", ""),
-        cludeTokenMint: optional("CLUUDE_TOKEN_MINT", "")
+        cludeTokenMint: optional("CLUUDE_TOKEN_MINT", ""),
+        /** Deployed memory-registry Anchor program ID. Empty → on-chain registration disabled. */
+        memoryRegistryProgramId: optional("CLUDE_PROGRAM_ID", "")
       },
       server: {
         port: parseInt(optional("PORT", "3000"), 10),
@@ -123,6 +138,69 @@ var init_config = __esm({
         freePromoCreditUsdc: parseFloat(optional("FREE_PROMO_CREDIT_USDC", "1")),
         freePromoExpiry: optional("FREE_PROMO_EXPIRY", "")
       },
+      memory: {
+        /**
+         * Memory 3.0 C2: route storeMemory enrichment (embed/link/extract) through the durable
+         * memory_write_jobs outbox instead of fire-and-forget. Default OFF — fire-and-forget stays
+         * the default until the worker is proven. Requires migrations 044 + 045; degrades gracefully
+         * (falls back to fire-and-forget) if unapplied.
+         */
+        outboxEnabled: optional("MEMORY_OUTBOX", "false") === "true",
+        /**
+         * Memory 3.0 C1: write-time reconciliation, SHADOW slice (LLM-free). When on, each write records
+         * a PROPOSED reconcile op (add / needs_router / skip) into memory_reconciliation_log WITHOUT
+         * applying it — the labeled sample the enforce path must earn its turn-on from. Default OFF;
+         * runs fully detached after embedMemory (zero write latency); degrades gracefully if migration
+         * 046 is unapplied. Disabled under BENCH_MODE. The router is a later slice; only the cosine gate
+         * runs here.
+         */
+        reconcileEnabled: optional("MEMORY_RECONCILE", "false") === "true",
+        /** Screen floor passed to match_memories_temporal — LOW so max_cosine is captured for below-LO
+         * writes (LO is tuned from the shadow data, not fixed up-front). */
+        reconcileFloor: Number(optional("MEMORY_RECONCILE_FLOOR", "0.5")),
+        /** "similar enough to reconcile" boundary → needs_router (vs add). A starting probe, not gospel. */
+        reconcileLo: Number(optional("MEMORY_RECONCILE_LO", "0.85")),
+        /** hi/mid band LABEL boundary for analysis (not a decision boundary). */
+        reconcileHi: Number(optional("MEMORY_RECONCILE_HI", "0.95")),
+        /**
+         * C1 slice 1.5: the LLM router. Its own sub-flag (default OFF, independent of reconcileEnabled)
+         * so gate-only instrumentation runs first and LO is calibrated from that data before any LLM
+         * spend. When on, a >= LO write is classified add/update/noop by reconcileModel (still SHADOW —
+         * the op is logged, never applied). Requires OpenRouter configured.
+         */
+        reconcileRouter: optional("MEMORY_RECONCILE_ROUTER", "false") === "true",
+        /** Router model — an explicit id (NEVER a cognitiveFunction, which would silently override it
+         * with the fast llama slot). Haiku-class default: capable enough for dup-vs-update, cheap. */
+        reconcileModel: optional("MEMORY_RECONCILE_MODEL", "anthropic/claude-haiku-4.5"),
+        /** Per-owner soft daily cap on router calls (approximate, per-process) — bounds LLM spend. */
+        reconcileBudget: Number(optional("MEMORY_RECONCILE_BUDGET", "200"))
+      },
+      oauth: {
+        /** HMAC secret for signing OAuth access-token JWTs. Empty disables the OAuth AS — bearer API-key auth still works. */
+        signingSecret: optional("OAUTH_SIGNING_SECRET", ""),
+        /** Issuer/audience identifier baked into tokens. Falls back to the request origin when empty. */
+        issuer: optional("OAUTH_ISSUER", ""),
+        /** Access-token lifetime in seconds (default 1h). */
+        accessTtlSec: parseInt(optional("OAUTH_ACCESS_TTL_SEC", "3600"), 10),
+        /** Refresh-token lifetime in seconds (default 30d). */
+        refreshTtlSec: parseInt(optional("OAUTH_REFRESH_TTL_SEC", "2592000"), 10),
+        /** Authorization-code lifetime in seconds (default 60s). */
+        codeTtlSec: parseInt(optional("OAUTH_CODE_TTL_SEC", "60"), 10)
+      },
+      stripe: {
+        /**
+         * Stripe secret API key (sk_live_… / sk_test_…). Empty disables the
+         * marketplace Stripe rail — the orchestrator/webhook fail closed without it.
+         * SDK/MCP consumers never need this, so it stays optional() (not required()).
+         */
+        secretKey: optional("STRIPE_SECRET_KEY", ""),
+        /**
+         * Stripe webhook signing secret (whsec_…) used by stripe.webhooks.constructEvent
+         * to verify the raw body BEFORE any DB write (Risk R6). Empty ⇒ every webhook is
+         * rejected, so a misconfigured deploy can never process an unverified event.
+         */
+        webhookSecret: optional("STRIPE_WEBHOOK_SECRET", "")
+      },
       campaign: {
         startDate: optional("CAMPAIGN_START", "")
       },
@@ -136,6 +214,51 @@ var init_config = __esm({
         queryApiKey: optional("EMBEDDING_QUERY_API_KEY", ""),
         queryModel: optional("EMBEDDING_QUERY_MODEL", "")
       },
+      migration: {
+        /**
+         * Database backend that getDb() targets during the GCP parallel-run.
+         * 'supabase' (default, current live infra) | 'cloudsql' (PostgREST /
+         * self-hosted Supabase in front of Cloud SQL). Flip per-layer for the
+         * shadow-stack cutover; Supabase stays the source of truth until sunset.
+         */
+        dbTarget: optional("DB_TARGET", "supabase"),
+        /** PostgREST endpoint for the Cloud SQL backend (used only when DB_TARGET=cloudsql). */
+        cloudsqlUrl: optional("CLOUDSQL_PGREST_URL", ""),
+        /** Service key for the Cloud SQL PostgREST backend (used only when DB_TARGET=cloudsql). */
+        cloudsqlServiceKey: optional("CLOUDSQL_SERVICE_KEY", ""),
+        /**
+         * Active embedding vector space for ingest + recall. 'voyage' (default,
+         * current corpus) | 'vertex' (shadow column, only after the LongMemEval gate
+         * passes). Separate from EMBEDDING_PROVIDER so the swap is A/B, not one-way.
+         */
+        embeddingActive: optional("EMBEDDING_ACTIVE", "voyage"),
+        /**
+         * Whether THIS process runs the in-server singleton timers (recall canary,
+         * marketplace delivery poller, title-mint reconciliation). Default true =
+         * current Railway behavior. Set false on the Cloud Run server so exactly one
+         * owner (the worker) runs them and autoscaling never duplicates them.
+         */
+        runInProcessTimers: optional("RUN_INPROCESS_TIMERS", "true") === "true"
+      },
+      vertex: {
+        /**
+         * Vertex AI embedding backend (the GCP replacement for Voyage), used only when
+         * ingest/backfill/recall target the 'vertex' space (EMBEDDING_ACTIVE=vertex or an
+         * explicit generateEmbeddingForSpace('vertex') call). Separate from config.embedding
+         * so the Vertex space can be backfilled + A/B-gated while Voyage stays live.
+         */
+        project: optional("VERTEX_PROJECT", optional("GCP_PROJECT", "")),
+        location: optional("VERTEX_LOCATION", "us-central1"),
+        model: optional("VERTEX_EMBEDDING_MODEL", "gemini-embedding-001"),
+        /** Output dims — MRL-truncated to 1024 so vector(1024) columns + HNSW + match_* RPCs are unchanged. */
+        dimensions: parseInt(optional("VERTEX_EMBEDDING_DIMENSIONS", "1024"), 10),
+        /**
+         * Optional static OAuth token override (from `gcloud auth print-access-token`) for
+         * local dev / smoke tests. Empty in prod: Cloud Run mints a token from the attached
+         * service account via the metadata server (SDK-free), no static key stored.
+         */
+        accessToken: optional("VERTEX_ACCESS_TOKEN", "")
+      },
       openrouter: {
         apiKey: optional("OPENROUTER_API_KEY", ""),
         model: optional("OPENROUTER_MODEL", "meta-llama/llama-3.3-70b-instruct")
@@ -149,6 +272,35 @@ var init_config = __esm({
       tavily: {
         apiKey: optional("TAVILY_API_KEY", "")
       },
+      higgsfield: {
+        /** Higgsfield API key ID — first half of the V2 `Authorization: Key <id>:<secret>` pair (server-only). Empty → /api/ansem/speak returns 501. */
+        apiKey: optional("HIGGSFIELD_API_KEY", ""),
+        /** Higgsfield API key SECRET — second half of the V2 `Key <id>:<secret>` pair. */
+        apiSecret: optional("HIGGSFIELD_API_SECRET", ""),
+        /** REST base URL (Higgsfield V2 API). */
+        apiBase: optional("HIGGSFIELD_API_BASE", "https://platform.higgsfield.ai"),
+        /**
+         * V2 model path for the seed_audio TTS model: create is POST {apiBase}/{ttsEndpoint}.
+         * Verified live against the Higgsfield V2 API — bytedance/seed-audio-1.0.
+         */
+        ttsEndpoint: optional("HIGGSFIELD_TTS_ENDPOINT", "bytedance/seed-audio-1.0"),
+        /** Ansem voice — Higgsfield "Sterling" preset (founder's choice). */
+        voiceId: optional("ANSEM_VOICE_ID", "dc382508-c8bd-443c-8cb2-46e57b8d2e6f"),
+        voiceType: optional("ANSEM_VOICE_TYPE", "preset"),
+        /** Deep-voice tuning: seed_audio pitch_rate / speech_rate (integers, default 0). */
+        voicePitch: parseInt(optional("ANSEM_VOICE_PITCH", "-9"), 10),
+        voiceSpeechRate: parseInt(optional("ANSEM_VOICE_SPEECH_RATE", "-12"), 10),
+        /** Output audio format (seed_audio supports wav|mp3|pcm|ogg_opus). */
+        audioFormat: optional("ANSEM_VOICE_FORMAT", "mp3")
+      },
+      elevenlabs: {
+        /** ElevenLabs API key (server-only). Set → PRIMARY TTS (~1-3s, no lag); empty → falls back to Higgsfield. */
+        apiKey: optional("ELEVENLABS_API_KEY", ""),
+        /** Voice id — default "Brian" (deep, resonant, american). Swap via ELEVENLABS_VOICE_ID. */
+        voiceId: optional("ELEVENLABS_VOICE_ID", "nPczCjzI2devNBz1zQrb"),
+        /** Model — turbo for lowest latency. */
+        model: optional("ELEVENLABS_MODEL", "eleven_turbo_v2_5")
+      },
       privy: {
         appId: optional("PRIVY_APP_ID", ""),
         appSecret: optional("PRIVY_APP_SECRET", ""),
@@ -230,28 +382,70 @@ var init_logger = __esm({
   }
 });
 
+// packages/shared/src/core/migration-profile.ts
+function defaultSupabaseConnection() {
+  return { url: config.supabase.url, serviceKey: config.supabase.serviceKey };
+}
+function resolveDbConnection(profile = config.migration, supabase2 = defaultSupabaseConnection()) {
+  if (!DB_TARGETS.includes(profile.dbTarget)) {
+    throw new Error(
+      `Invalid DB_TARGET '${profile.dbTarget}' (expected 'supabase' | 'cloudsql')`
+    );
+  }
+  if (profile.dbTarget === "cloudsql") {
+    if (!profile.cloudsqlUrl || !profile.cloudsqlServiceKey) {
+      throw new Error(
+        "DB_TARGET=cloudsql requires CLOUDSQL_PGREST_URL and CLOUDSQL_SERVICE_KEY"
+      );
+    }
+    return { url: profile.cloudsqlUrl, serviceKey: profile.cloudsqlServiceKey };
+  }
+  return { url: supabase2.url, serviceKey: supabase2.serviceKey };
+}
+function activeEmbeddingSpace(profile = config.migration) {
+  if (!EMBEDDING_SPACES.includes(profile.embeddingActive)) {
+    throw new Error(
+      `Invalid EMBEDDING_ACTIVE '${profile.embeddingActive}' (expected 'voyage' | 'vertex')`
+    );
+  }
+  return profile.embeddingActive;
+}
+function vectorRpcName(baseRpc, profile = config.migration) {
+  return activeEmbeddingSpace(profile) === "vertex" ? `${baseRpc}_vertex` : baseRpc;
+}
+var DB_TARGETS, EMBEDDING_SPACES;
+var init_migration_profile = __esm({
+  "packages/shared/src/core/migration-profile.ts"() {
+    "use strict";
+    init_config();
+    DB_TARGETS = ["supabase", "cloudsql"];
+    EMBEDDING_SPACES = ["voyage", "vertex"];
+  }
+});
+
 // packages/shared/src/core/database.ts
 var database_exports = {};
 __export(database_exports, {
   _setDb: () => _setDb,
   claimForProcessing: () => claimForProcessing,
   getDb: () => getDb,
+  getSchemaDriftReport: () => getSchemaDriftReport,
   initDatabase: () => initDatabase,
   isAlreadyProcessed: () => isAlreadyProcessed,
   markProcessed: () => markProcessed
 });
 function getDb() {
   if (!supabase) {
-    supabase = (0, import_supabase_js.createClient)(config.supabase.url, config.supabase.serviceKey);
-    log.info("Supabase client initialized");
+    const conn = resolveDbConnection();
+    supabase = (0, import_supabase_js.createClient)(conn.url, conn.serviceKey);
+    log.info({ dbTarget: config.migration.dbTarget }, "Database client initialized");
   }
   return supabase;
 }
 function _setDb(client2) {
   supabase = client2;
 }
-async function initDatabase() {
-  const db = getDb();
+async function runBootDdl(db) {
   try {
     const { error } = await db.rpc("exec_sql", {
       query: `
@@ -323,6 +517,7 @@ async function initDatabase() {
           input_memory_ids BIGINT[] DEFAULT '{}',
           output TEXT NOT NULL,
           new_memories_created BIGINT[] DEFAULT '{}',
+          owner_wallet TEXT,
           created_at TIMESTAMPTZ DEFAULT NOW()
         );
 
@@ -407,7 +602,7 @@ async function initDatabase() {
           target_id BIGINT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
           link_type TEXT NOT NULL CHECK (link_type IN (
             'supports', 'contradicts', 'elaborates', 'causes', 'follows', 'relates', 'resolves',
-            'happens_before', 'happens_after', 'concurrent_with'
+            'supersedes', 'happens_before', 'happens_after', 'concurrent_with'
           )),
           strength REAL DEFAULT 0.5,
           created_at TIMESTAMPTZ DEFAULT NOW(),
@@ -442,7 +637,11 @@ async function initDatabase() {
           WHERE ml.source_id = ANY(seed_ids)
             AND ml.target_id != ALL(seed_ids)
             AND ml.strength >= min_strength
-            AND (filter_owner IS NULL OR m.owner_wallet = filter_owner)
+            AND (
+      filter_owner IS NULL
+      OR (filter_owner = '__BOT_OWN__' AND m.owner_wallet IS NULL)
+      OR m.owner_wallet = filter_owner
+    )
           UNION
           SELECT DISTINCT ON (ml.source_id, ml.link_type)
             ml.source_id AS memory_id,
@@ -454,7 +653,11 @@ async function initDatabase() {
           WHERE ml.target_id = ANY(seed_ids)
             AND ml.source_id != ALL(seed_ids)
             AND ml.strength >= min_strength
-            AND (filter_owner IS NULL OR m.owner_wallet = filter_owner)
+            AND (
+      filter_owner IS NULL
+      OR (filter_owner = '__BOT_OWN__' AND m.owner_wallet IS NULL)
+      OR m.owner_wallet = filter_owner
+    )
           ORDER BY strength DESC
           LIMIT max_results;
         $$;
@@ -482,6 +685,10 @@ async function initDatabase() {
         ALTER TABLE dream_logs ADD CONSTRAINT dream_logs_session_type_check
           CHECK (session_type IN ('consolidation', 'reflection', 'emergence', 'compaction', 'decay', 'contradiction_resolution'));
 
+        -- Migration 021: per-owner attribution for dream_logs (fixes totalDreamSessions leak)
+        ALTER TABLE dream_logs ADD COLUMN IF NOT EXISTS owner_wallet TEXT;
+        CREATE INDEX IF NOT EXISTS idx_dream_logs_owner ON dream_logs(owner_wallet);
+
         -- Migration: add 'resolves' + temporal link types
         ALTER TABLE memory_links DROP CONSTRAINT IF EXISTS memory_links_link_type_check;
         ALTER TABLE memory_links ADD CONSTRAINT memory_links_link_type_check
@@ -663,6 +870,170 @@ async function initDatabase() {
         CREATE INDEX IF NOT EXISTS idx_memories_event_date ON memories(event_date)
           WHERE event_date IS NOT NULL;
 
+        -- Lexical index for keyword/BM25 search (encryption \xA79). content_tokens is
+        -- app-maintained; ts_summary (summary-only) is added on fresh deploys that lack it.
+        ALTER TABLE memories ADD COLUMN IF NOT EXISTS content_tokens tsvector;
+        CREATE INDEX IF NOT EXISTS idx_memories_content_tokens ON memories USING GIN(content_tokens);
+        ALTER TABLE memories ADD COLUMN IF NOT EXISTS provider_delegated BOOLEAN DEFAULT TRUE;
+        CREATE INDEX IF NOT EXISTS idx_memories_delegated ON memories(provider_delegated) WHERE encrypted = TRUE;
+        ALTER TABLE memories ADD COLUMN IF NOT EXISTS summary_ciphertext TEXT;
+        ALTER TABLE memories ADD COLUMN IF NOT EXISTS embedding_ciphertext TEXT;
+
+        -- Memory 3.0 Phase 1 (migration 044): bi-temporal validity + provenance (additive/nullable, inert until MEMORY_RECONCILE)
+        ALTER TABLE memories ADD COLUMN IF NOT EXISTS valid_from TIMESTAMPTZ;
+        ALTER TABLE memories ADD COLUMN IF NOT EXISTS invalid_at TIMESTAMPTZ;
+        ALTER TABLE memories ADD COLUMN IF NOT EXISTS superseded_by TEXT;
+        ALTER TABLE memories ADD COLUMN IF NOT EXISTS fact_key TEXT;
+        ALTER TABLE memories ADD COLUMN IF NOT EXISTS extractor_version TEXT;
+        ALTER TABLE memories ADD COLUMN IF NOT EXISTS extraction_confidence REAL;
+        ALTER TABLE memories ADD COLUMN IF NOT EXISTS source_turn_ref JSONB;
+        ALTER TABLE memories ADD COLUMN IF NOT EXISTS hash_id_v2 TEXT;
+        CREATE INDEX IF NOT EXISTS idx_memories_valid ON memories(id) WHERE invalid_at IS NULL;
+        CREATE INDEX IF NOT EXISTS idx_memories_fact_key ON memories(fact_key) WHERE fact_key IS NOT NULL;
+        CREATE INDEX IF NOT EXISTS idx_memories_hash_id_v2 ON memories(hash_id_v2) WHERE hash_id_v2 IS NOT NULL;
+
+        -- Memory 3.0 Phase 1 (migration 044): the C2 durable write outbox.
+        CREATE TABLE IF NOT EXISTS memory_write_jobs (
+          id BIGSERIAL PRIMARY KEY,
+          memory_id BIGINT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
+          job_type TEXT NOT NULL CHECK (job_type IN ('enrich', 'embed', 'link', 'extract', 'reconcile', 'backfill_v2')),
+          status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'running', 'done', 'failed')),
+          attempts INT NOT NULL DEFAULT 0,
+          next_retry_at TIMESTAMPTZ DEFAULT NOW(),
+          last_error TEXT,
+          created_at TIMESTAMPTZ DEFAULT NOW(),
+          updated_at TIMESTAMPTZ DEFAULT NOW()
+        );
+        CREATE INDEX IF NOT EXISTS idx_write_jobs_claim ON memory_write_jobs(status, next_retry_at) WHERE status IN ('pending', 'failed');
+        CREATE INDEX IF NOT EXISTS idx_write_jobs_memory ON memory_write_jobs(memory_id);
+        CREATE INDEX IF NOT EXISTS idx_write_jobs_running ON memory_write_jobs(updated_at) WHERE status = 'running';
+
+        -- Memory 3.0 C2 outbox \u2014 MIRROR of migration 045 (byte-equivalent). The table above is in
+        -- the boot blob, so the claim RPC + idempotency objects MUST be too: otherwise a
+        -- boot-provisioned box gets the table but not the RPC and the worker silently never drains
+        -- (the migration-028 class). Keep in sync with 045.
+        DO $do$
+        BEGIN
+          ALTER TABLE memory_write_jobs DROP CONSTRAINT IF EXISTS memory_write_jobs_job_type_check;
+          ALTER TABLE memory_write_jobs ADD CONSTRAINT memory_write_jobs_job_type_check
+            CHECK (job_type IN ('enrich', 'embed', 'link', 'extract', 'reconcile', 'backfill_v2'));
+        EXCEPTION WHEN undefined_table THEN NULL; END $do$;
+
+        CREATE OR REPLACE FUNCTION claim_memory_write_jobs(
+          p_limit INT DEFAULT 20, p_stale_running INTERVAL DEFAULT INTERVAL '15 minutes', p_owner TEXT DEFAULT NULL
+        )
+        RETURNS TABLE (id BIGINT, memory_id BIGINT, job_type TEXT, attempts INT, owner_wallet TEXT)
+        LANGUAGE plpgsql AS $claimfn$
+        BEGIN
+          RETURN QUERY
+          UPDATE memory_write_jobs j
+             SET status = 'running', attempts = j.attempts + 1, updated_at = NOW()
+            FROM (
+              SELECT jj.id FROM memory_write_jobs jj JOIN memories m ON m.id = jj.memory_id
+               WHERE ((jj.status IN ('pending','failed') AND jj.next_retry_at IS NOT NULL AND jj.next_retry_at <= NOW())
+                      OR (jj.status = 'running' AND jj.updated_at < NOW() - p_stale_running))
+                 AND (p_owner IS NULL OR m.owner_wallet = p_owner OR (p_owner = '__BOT_OWN__' AND m.owner_wallet IS NULL))
+               ORDER BY jj.next_retry_at ASC NULLS LAST LIMIT p_limit FOR UPDATE SKIP LOCKED
+            ) claimed
+           WHERE j.id = claimed.id
+          RETURNING j.id, j.memory_id, j.job_type, j.attempts,
+                    (SELECT mm.owner_wallet FROM memories mm WHERE mm.id = j.memory_id);
+        END; $claimfn$;
+
+        DO $do$
+        BEGIN
+          DELETE FROM memory_links a USING memory_links b
+           WHERE a.ctid < b.ctid AND a.source_id = b.source_id AND a.target_id = b.target_id AND a.link_type = b.link_type;
+          ALTER TABLE memory_links DROP CONSTRAINT IF EXISTS memory_links_unique_edge;
+          ALTER TABLE memory_links ADD CONSTRAINT memory_links_unique_edge UNIQUE (source_id, target_id, link_type);
+        EXCEPTION WHEN undefined_table THEN NULL; END $do$;
+
+        CREATE OR REPLACE FUNCTION upsert_entity_relation(
+          p_src BIGINT, p_tgt BIGINT, p_type TEXT, p_evidence BIGINT DEFAULT NULL, p_strength REAL DEFAULT 0.5
+        )
+        RETURNS VOID LANGUAGE sql AS $uerfn$
+          INSERT INTO entity_relations (source_entity_id, target_entity_id, relation_type, strength, evidence_memory_ids)
+          VALUES (p_src, p_tgt, p_type, LEAST(1.0, p_strength),
+                  CASE WHEN p_evidence IS NULL THEN '{}'::bigint[] ELSE ARRAY[p_evidence] END)
+          ON CONFLICT (source_entity_id, target_entity_id, relation_type) DO UPDATE
+            SET strength = LEAST(1.0, entity_relations.strength +
+                  CASE WHEN p_evidence IS NULL OR p_evidence = ANY(entity_relations.evidence_memory_ids) THEN 0.0 ELSE 0.1 END),
+                evidence_memory_ids = (SELECT ARRAY(SELECT DISTINCT e FROM unnest(entity_relations.evidence_memory_ids || EXCLUDED.evidence_memory_ids) AS e));
+        $uerfn$;
+
+        -- Memory 3.0 C1 (migration 046): reconciliation SHADOW decision log. MIRROR \u2014 byte-equivalent
+        -- to migration 046. Records a PROPOSED reconcile op per write without applying it, so enforce
+        -- can be greenlit from a labeled sample. Deliberately NOT added to CORE_TABLES (dormant,
+        -- default-off; must not trip SCHEMA DRIFT at boot on an un-migrated prod box \u2014 C2 precedent).
+        CREATE TABLE IF NOT EXISTS memory_reconciliation_log (
+          id               BIGSERIAL PRIMARY KEY,
+          memory_id        BIGINT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
+          owner_wallet     TEXT,
+          mode             TEXT NOT NULL DEFAULT 'shadow' CHECK (mode IN ('shadow','enforce')),
+          proposed_op      TEXT NOT NULL CHECK (proposed_op IN ('add','update','noop','needs_router','skip')),
+          target_memory_id BIGINT,
+          max_cosine       REAL,
+          band             TEXT CHECK (band IN ('hi','mid','lo','none')),
+          router_used      BOOLEAN NOT NULL DEFAULT false,
+          router_model     TEXT,
+          fact_key         TEXT,
+          reason           TEXT,
+          label            TEXT,
+          labeled_at       TIMESTAMPTZ,
+          gate_version     TEXT,
+          created_at       TIMESTAMPTZ NOT NULL DEFAULT NOW()
+        );
+        CREATE INDEX IF NOT EXISTS idx_reconcile_log_owner_created ON memory_reconciliation_log(owner_wallet, created_at);
+        CREATE INDEX IF NOT EXISTS idx_reconcile_log_op ON memory_reconciliation_log(proposed_op);
+        CREATE INDEX IF NOT EXISTS idx_reconcile_log_router ON memory_reconciliation_log(mode, router_used);
+
+        DO $do$
+        BEGIN
+          IF NOT EXISTS (
+            SELECT 1 FROM information_schema.columns
+            WHERE table_name = 'memories' AND column_name = 'ts_summary'
+          ) THEN
+            ALTER TABLE memories ADD COLUMN ts_summary tsvector GENERATED ALWAYS AS (
+              setweight(to_tsvector('english', COALESCE(summary, '')), 'A')
+            ) STORED;
+            CREATE INDEX IF NOT EXISTS idx_memories_ts_summary ON memories USING GIN(ts_summary);
+          END IF;
+        END $do$;
+
+        -- Semantic search across memory-level embeddings with metadata filtering (the always-on
+        -- recall vector lane). MIRROR of migration 028 / supabase-schema.sql \u2014 8-arg filter_tags form.
+        CREATE OR REPLACE FUNCTION match_memories(
+          query_embedding vector(1024),
+          match_threshold float DEFAULT 0.3,
+          match_count int DEFAULT 10,
+          filter_types text[] DEFAULT NULL,
+          filter_user text DEFAULT NULL,
+          min_decay float DEFAULT 0.1,
+          filter_owner text DEFAULT NULL,
+          filter_tags text[] DEFAULT NULL
+        )
+        RETURNS TABLE (id bigint, similarity float)
+        LANGUAGE plpgsql AS $$
+        BEGIN
+          RETURN QUERY
+          SELECT m.id, (1 - (m.embedding <=> query_embedding))::float AS similarity
+          FROM memories m
+          WHERE m.embedding IS NOT NULL
+            AND m.decay_factor >= min_decay
+            AND (filter_types IS NULL OR m.memory_type = ANY(filter_types))
+            AND (filter_user IS NULL OR m.related_user = filter_user)
+            AND (
+      filter_owner IS NULL
+      OR (filter_owner = '__BOT_OWN__' AND m.owner_wallet IS NULL)
+      OR m.owner_wallet = filter_owner
+    )
+            AND (filter_tags IS NULL OR m.tags && filter_tags)
+            AND (1 - (m.embedding <=> query_embedding)) > match_threshold
+          ORDER BY m.embedding <=> query_embedding
+          LIMIT match_count;
+        END;
+        $$;
+
         -- Temporal-aware semantic search RPC (Exp 9)
         CREATE OR REPLACE FUNCTION match_memories_temporal(
           query_embedding vector(1024),
@@ -686,7 +1057,11 @@ async function initDatabase() {
             AND m.decay_factor >= min_decay
             AND (filter_types IS NULL OR m.memory_type = ANY(filter_types))
             AND (filter_user IS NULL OR m.related_user = filter_user)
-            AND (filter_owner IS NULL OR m.owner_wallet = filter_owner)
+            AND (
+      filter_owner IS NULL
+      OR (filter_owner = '__BOT_OWN__' AND m.owner_wallet IS NULL)
+      OR m.owner_wallet = filter_owner
+    )
             AND (filter_tags IS NULL OR m.tags && filter_tags)
             AND (1 - (m.embedding <=> query_embedding)) > match_threshold
             AND (start_date IS NULL OR COALESCE(m.event_date, m.created_at) >= start_date)
@@ -696,8 +1071,124 @@ async function initDatabase() {
         END;
         $$;
 
-        -- BM25-ranked full-text search RPC (Exp 8)
-        -- Note: ts_summary column requires manual migration (GENERATED ALWAYS AS is not ALTER-able)
+        -- Fragment-level semantic search with deduplication to parent memory. Returns the highest
+        -- similarity fragment per memory (the non-skipExpansion recall lane). MIRROR of
+        -- supabase-schema.sql \u2014 6-arg migration-043 form; the 4-arg (migration 009) call still
+        -- resolves against it via parameter defaults, so a boot-provisioned box is never left on a
+        -- stale fragment signature.
+        CREATE OR REPLACE FUNCTION match_memory_fragments(
+          query_embedding vector(1024),
+          match_threshold float DEFAULT 0.3,
+          match_count int DEFAULT 10,
+          filter_owner text DEFAULT NULL,
+          min_decay float DEFAULT 0.0,
+          filter_types text[] DEFAULT NULL
+        )
+        RETURNS TABLE (memory_id bigint, max_similarity float)
+        LANGUAGE plpgsql AS $$
+        BEGIN
+          RETURN QUERY
+          SELECT f.memory_id, MAX((1 - (f.embedding <=> query_embedding))::float) AS max_similarity
+          FROM memory_fragments f
+          JOIN memories m ON m.id = f.memory_id
+          WHERE f.embedding IS NOT NULL
+            AND (1 - (f.embedding <=> query_embedding)) > match_threshold
+            AND m.decay_factor >= min_decay
+            AND (filter_types IS NULL OR m.memory_type = ANY(filter_types))
+            AND (
+      filter_owner IS NULL
+      OR (filter_owner = '__BOT_OWN__' AND m.owner_wallet IS NULL)
+      OR m.owner_wallet = filter_owner
+    )
+          GROUP BY f.memory_id
+          ORDER BY max_similarity DESC
+          LIMIT match_count;
+        END;
+        $$;
+
+        -- Encryption: owner key registry + per-memory wrapped DEKs (encryption \xA79, Plan 1 sync).
+        CREATE TABLE IF NOT EXISTS encryption_keys (
+          owner_wallet  TEXT PRIMARY KEY,
+          x25519_pubkey TEXT NOT NULL,
+          verifier_ct   TEXT NOT NULL,
+          created_at    TIMESTAMPTZ DEFAULT NOW(),
+          updated_at    TIMESTAMPTZ DEFAULT NOW()
+        );
+        CREATE TABLE IF NOT EXISTS memory_dek_wraps (
+          memory_id     BIGINT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
+          recipient     TEXT   NOT NULL,
+          wrapped_dek   TEXT   NOT NULL,
+          wrap_pubkey   TEXT   NOT NULL,
+          holder_wallet TEXT,                          -- (034) names the title_holder; NULL for owner/provider
+          created_at    TIMESTAMPTZ DEFAULT NOW(),
+          CONSTRAINT memory_dek_wraps_recipient_chk CHECK (recipient IN ('owner', 'provider', 'title_holder')),
+          CONSTRAINT memory_dek_wraps_holder_chk CHECK ((recipient = 'title_holder') = (holder_wallet IS NOT NULL))
+        );
+        -- (036) holder-aware uniqueness: one owner + one provider per memory (NULLS NOT DISTINCT),
+        -- and one title_holder per (memory, holder) so a sale's seller + buyer wraps coexist (RT7).
+        CREATE UNIQUE INDEX IF NOT EXISTS uq_dek_wraps_identity
+          ON memory_dek_wraps (memory_id, recipient, holder_wallet) NULLS NOT DISTINCT;
+        CREATE INDEX IF NOT EXISTS idx_dek_wraps_memory ON memory_dek_wraps(memory_id);
+
+        -- Populate content_tokens from a transient plaintext arg (PostgREST can't express to_tsvector inline).
+        -- setweight 'B' mirrors the old combined ts_summary weighting (summary 'A' > content 'B').
+        CREATE OR REPLACE FUNCTION set_memory_content_tokens(p_memory_id bigint, p_text text)
+        RETURNS void LANGUAGE sql AS $fn$
+          UPDATE memories
+          SET content_tokens = CASE
+                WHEN p_text IS NULL OR p_text = '' THEN NULL
+                ELSE setweight(to_tsvector('english', p_text), 'B')
+              END
+          WHERE id = p_memory_id;
+        $fn$;
+
+        -- Atomic revoke: clear plaintext + drop the provider wrap in one transaction (encryption \xA77).
+        CREATE OR REPLACE FUNCTION revoke_memory(p_memory_id bigint, p_summary_ct text, p_embedding_ct text)
+        RETURNS void LANGUAGE plpgsql AS $rev$
+        BEGIN
+          UPDATE memories SET
+            summary = '',
+            summary_ciphertext = p_summary_ct,
+            embedding = NULL,
+            embedding_ciphertext = NULLIF(p_embedding_ct, ''),
+            content_tokens = NULL,
+            provider_delegated = false
+          WHERE id = p_memory_id;
+          DELETE FROM memory_dek_wraps WHERE memory_id = p_memory_id AND recipient = 'provider';
+          -- Fragment parity (migration 043): fragments hold plaintext + live embeddings.
+          DELETE FROM memory_fragments WHERE memory_id = p_memory_id;
+        END;
+        $rev$;
+
+        -- Atomic re-delegate (encryption \xA77) \u2014 inverse of revoke_memory. Restores plaintext
+        -- summary/embedding, rebuilds content_tokens via the canonical builder, clears ciphertext
+        -- cols, sets provider_delegated=true, (re-)inserts the provider wrap.
+        CREATE OR REPLACE FUNCTION redelegate_memory(
+          p_memory_id   bigint,
+          p_summary     text,
+          p_embedding   text,
+          p_content     text,
+          p_wrapped_dek text,
+          p_wrap_pubkey text
+        )
+        RETURNS void LANGUAGE plpgsql AS $redel$
+        BEGIN
+          UPDATE memories SET
+            summary = p_summary,
+            summary_ciphertext = NULL,
+            embedding = NULLIF(p_embedding, '')::vector,
+            embedding_ciphertext = NULL,
+            provider_delegated = true
+          WHERE id = p_memory_id;
+          PERFORM set_memory_content_tokens(p_memory_id, p_content);
+          INSERT INTO memory_dek_wraps (memory_id, recipient, wrapped_dek, wrap_pubkey)
+          VALUES (p_memory_id, 'provider', p_wrapped_dek, p_wrap_pubkey)
+          ON CONFLICT (memory_id, recipient) DO UPDATE
+            SET wrapped_dek = EXCLUDED.wrapped_dek, wrap_pubkey = EXCLUDED.wrap_pubkey;
+        END;
+        $redel$;
+
+        -- BM25-ranked full-text search RPC (Exp 8) \u2014 dual-column (ts_summary + content_tokens)
         CREATE OR REPLACE FUNCTION bm25_search_memories(
           search_query text,
           match_count int DEFAULT 20,
@@ -716,11 +1207,17 @@ async function initDatabase() {
             RETURN;
           END IF;
           RETURN QUERY
-          SELECT m.id, ts_rank_cd(m.ts_summary, tsquery_val, 32)::float AS rank
+          SELECT m.id,
+            (ts_rank_cd(COALESCE(m.ts_summary, ''::tsvector), tsquery_val, 32)
+             + ts_rank_cd(COALESCE(m.content_tokens, ''::tsvector), tsquery_val, 32))::float AS rank
           FROM memories m
-          WHERE m.ts_summary @@ tsquery_val
+          WHERE (m.ts_summary @@ tsquery_val OR m.content_tokens @@ tsquery_val)
             AND m.decay_factor >= min_decay
-            AND (filter_owner IS NULL OR m.owner_wallet = filter_owner)
+            AND (
+      filter_owner IS NULL
+      OR (filter_owner = '__BOT_OWN__' AND m.owner_wallet IS NULL)
+      OR m.owner_wallet = filter_owner
+    )
             AND (filter_types IS NULL OR m.memory_type = ANY(filter_types))
             AND (filter_tags IS NULL OR m.tags && filter_tags)
           ORDER BY rank DESC
@@ -749,9 +1246,31 @@ async function initDatabase() {
           tokens_prompt INTEGER,
           tokens_completion INTEGER,
           memory_ids INTEGER[],
+          frontier_tokens INTEGER,
+          memories_used INTEGER,
+          tokens_saved INTEGER,
           created_at TIMESTAMPTZ DEFAULT NOW()
         );
         CREATE INDEX IF NOT EXISTS idx_chat_msg_conv ON chat_messages(conversation_id, created_at);
+        CREATE INDEX IF NOT EXISTS idx_chat_msg_saved ON chat_messages(created_at) WHERE tokens_saved IS NOT NULL;
+        -- Proof counter totals. "today" is UTC-based (resets 00:00 UTC). Full-table aggregate:
+        -- callers MUST use a server-side TTL cache (see proof.routes.ts). Mirror of migration 026.
+        CREATE OR REPLACE FUNCTION proof_tokens_saved_totals()
+        RETURNS TABLE(
+          measured_saved        bigint,
+          measured_today        bigint,
+          measured_frontier     bigint,
+          historical_prompt_sum bigint,
+          n                     bigint
+        ) LANGUAGE sql STABLE AS $$
+          SELECT
+            COALESCE(SUM(tokens_saved)    FILTER (WHERE tokens_saved IS NOT NULL), 0)::bigint,
+            COALESCE(SUM(tokens_saved)    FILTER (WHERE tokens_saved IS NOT NULL AND created_at >= date_trunc('day', now())), 0)::bigint,
+            COALESCE(SUM(frontier_tokens) FILTER (WHERE tokens_saved IS NOT NULL), 0)::bigint,
+            COALESCE(SUM(tokens_prompt)   FILTER (WHERE tokens_saved IS NULL), 0)::bigint,
+            COUNT(*)                      FILTER (WHERE tokens_saved IS NOT NULL)::bigint
+          FROM chat_messages;
+        $$;
 
         -- Chat billing: balances, top-ups, and per-message usage
         CREATE TABLE IF NOT EXISTS chat_balances (
@@ -806,6 +1325,50 @@ async function initDatabase() {
         );
         CREATE INDEX IF NOT EXISTS idx_wiki_pack_installations_owner
           ON wiki_pack_installations(owner_wallet);
+
+        -- Migration 019: corrected access-boost RPC (no importance mutation on read).
+        -- Re-asserted on every boot so the read->rank->read feedback loop can't return.
+        -- importance_boosts is kept for call-site signature compatibility and ignored.
+        -- Drop the stale single-arg overload (migration 003) so the two-arg version is
+        -- unambiguous and the lockdown below can't be bypassed via an unrevoked overload.
+        DROP FUNCTION IF EXISTS batch_boost_memory_access(bigint[]);
+        CREATE OR REPLACE FUNCTION batch_boost_memory_access(
+          memory_ids BIGINT[],
+          importance_boosts DOUBLE PRECISION[] DEFAULT NULL
+        ) RETURNS void LANGUAGE plpgsql AS $fn$
+        BEGIN
+          UPDATE memories
+          SET access_count = access_count + 1,
+              last_accessed = NOW(),
+              decay_factor = LEAST(1.0, decay_factor + 0.1)
+          WHERE id = ANY(memory_ids);
+        END;
+        $fn$;
+
+        -- Migration 020: lock down dangerous SECURITY DEFINER RPCs to service_role only.
+        -- exec_sql/boost RPCs must never be callable by anon/authenticated (the publishable
+        -- key ships in client apps). Wrapped so a not-yet-created function never aborts boot.
+        DO $do$ BEGIN
+          REVOKE EXECUTE ON FUNCTION exec_sql(text) FROM PUBLIC, anon, authenticated;
+          GRANT EXECUTE ON FUNCTION exec_sql(text) TO service_role;
+        EXCEPTION WHEN undefined_function THEN NULL; END $do$;
+
+        DO $do$ BEGIN
+          REVOKE EXECUTE ON FUNCTION batch_boost_memory_access(bigint[], double precision[]) FROM PUBLIC, anon, authenticated;
+          GRANT EXECUTE ON FUNCTION batch_boost_memory_access(bigint[], double precision[]) TO service_role;
+        EXCEPTION WHEN undefined_function THEN NULL; END $do$;
+
+        DO $do$ BEGIN
+          REVOKE EXECUTE ON FUNCTION boost_memory_importance(bigint, double precision, double precision) FROM PUBLIC, anon, authenticated;
+          GRANT EXECUTE ON FUNCTION boost_memory_importance(bigint, double precision, double precision) TO service_role;
+        EXCEPTION WHEN undefined_function THEN NULL; END $do$;
+
+        -- Migration 022 (guard portion): reject empty content on NEW writes in every env.
+        -- NOT VALID enforces on new INSERT/UPDATE without scanning existing rows; the
+        -- one-time cleanup of legacy blank rows + VALIDATE lives in the manual 022 file.
+        DO $do$ BEGIN
+          ALTER TABLE memories ADD CONSTRAINT memories_content_nonempty CHECK (length(btrim(content)) > 0) NOT VALID;
+        EXCEPTION WHEN duplicate_object THEN NULL; END $do$;
       `
     });
     if (error) {
@@ -814,7 +1377,75 @@ async function initDatabase() {
   } catch {
     log.warn("rpc exec_sql not available. Create tables via Supabase SQL editor.");
   }
-  log.info("Database initialized");
+}
+function getSchemaDriftReport() {
+  return lastSchemaReport;
+}
+async function verifyCoreSchema(db) {
+  const missingTables = [];
+  const probeErrors = [];
+  for (const table of CORE_TABLES) {
+    try {
+      const { error } = await db.from(table).select("id", { head: true, count: "exact" }).limit(1);
+      if (error) {
+        if (MISSING_RE.test(error.message ?? "")) missingTables.push(table);
+        else probeErrors.push(`${table}: ${error.message}`);
+      }
+    } catch (err) {
+      probeErrors.push(`${table}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  const brokenRpcs = [];
+  for (const probe of CORE_RPC_PROBES) {
+    try {
+      const { error } = await db.rpc(probe.name, probe.args);
+      if (error && MISSING_RE.test(error.message ?? "")) brokenRpcs.push(probe.name);
+    } catch (err) {
+      probeErrors.push(`${probe.name}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  return { missingTables, brokenRpcs, probeErrors };
+}
+async function initDatabase(dbOverride) {
+  const db = dbOverride ?? getDb();
+  const mode = process.env.INIT_DB_MODE ?? "auto";
+  if (mode === "replay") {
+    await runBootDdl(db);
+    lastSchemaReport = { at: (/* @__PURE__ */ new Date()).toISOString(), status: "replayed", missingTables: [], brokenRpcs: [] };
+    log.info("Database initialized (legacy replay mode)");
+    return;
+  }
+  let { missingTables, brokenRpcs, probeErrors } = await verifyCoreSchema(db);
+  if (mode === "auto" && missingTables.includes("memories")) {
+    log.info("Fresh database detected (no memories table) \u2014 running boot DDL");
+    await runBootDdl(db);
+    ({ missingTables, brokenRpcs, probeErrors } = await verifyCoreSchema(db));
+    const healthy2 = missingTables.length === 0 && brokenRpcs.length === 0;
+    lastSchemaReport = {
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      status: healthy2 ? "fresh-bootstrapped" : "drift",
+      missingTables,
+      brokenRpcs
+    };
+    if (healthy2) log.info("Database bootstrapped from boot DDL");
+    else log.error({ missingTables, brokenRpcs }, "SCHEMA DRIFT after fresh bootstrap \u2014 check exec_sql availability");
+    return;
+  }
+  if (probeErrors.length > 0 && missingTables.length === 0 && brokenRpcs.length === 0) {
+    lastSchemaReport = { at: (/* @__PURE__ */ new Date()).toISOString(), status: "unknown", missingTables, brokenRpcs };
+    log.warn({ probeErrors: probeErrors.slice(0, 3) }, "Schema verification inconclusive (probe errors); skipping");
+    return;
+  }
+  const healthy = missingTables.length === 0 && brokenRpcs.length === 0;
+  lastSchemaReport = { at: (/* @__PURE__ */ new Date()).toISOString(), status: healthy ? "ok" : "drift", missingTables, brokenRpcs };
+  if (healthy) {
+    log.info("Database schema verified (boot blob frozen; migrations are the single schema writer)");
+  } else {
+    log.error(
+      { missingTables, brokenRpcs },
+      "SCHEMA DRIFT \u2014 core objects missing on an established database; apply the corresponding migration by hand (the boot blob no longer auto-repairs)"
+    );
+  }
 }
 async function isAlreadyProcessed(tweetId) {
   const db = getDb();
@@ -847,14 +1478,44 @@ async function markProcessed(tweetId, feature, responseTweetId, extra) {
     processed_at: (/* @__PURE__ */ new Date()).toISOString()
   });
 }
-var import_supabase_js, log, supabase;
+var import_supabase_js, log, supabase, CORE_TABLES, CORE_RPC_PROBES, lastSchemaReport, MISSING_RE;
 var init_database = __esm({
   "packages/shared/src/core/database.ts"() {
     "use strict";
     import_supabase_js = require("@supabase/supabase-js");
     init_config();
     init_logger();
+    init_migration_profile();
     log = createChildLogger("database");
+    CORE_TABLES = [
+      "memories",
+      "memory_fragments",
+      "memory_links",
+      "agent_keys",
+      "dream_logs",
+      "rate_limits",
+      "chat_conversations",
+      "chat_messages"
+    ];
+    CORE_RPC_PROBES = [
+      { name: "get_linked_memories", args: { seed_ids: [], min_strength: 0.1, max_results: 1, filter_owner: null } },
+      { name: "bm25_search_memories", args: { search_query: "", match_count: 1, min_decay: 0.1, filter_owner: null } },
+      // Vector recall lanes (memory.ts recall). match_memories is the always-on memory-level lane;
+      // match_memory_fragments is the fragment lane (non-skipExpansion path). Both are silently absent
+      // from a stale boot blob, so probe them so the gap surfaces as drift instead of a dead lane.
+      // Vector-safe args (null embedding + match_count 0) make each a no-op read. filter_tags pins the
+      // migration-028 8-arg match_memories overload recall calls unconditionally (catches a pre-028 box
+      // where recall would break); the fragment probe stays the 4/6-arg common subset (min_decay +
+      // filter_types are opt-in via MEMORY_FRAGMENT_FILTERS) so it never false-drifts a pre-043 box
+      // still serving the migration-009 4-arg form.
+      { name: "match_memories", args: { query_embedding: null, match_count: 0, filter_owner: null, filter_tags: null } },
+      { name: "match_memory_fragments", args: { query_embedding: null, match_count: 0, filter_owner: null } },
+      // Memory 3.0 C2: probe the outbox claim RPC so a table-without-RPC state (the §6 hazard) is
+      // caught at boot as drift rather than silently never draining.
+      { name: "claim_memory_write_jobs", args: { p_limit: 0 } }
+    ];
+    lastSchemaReport = null;
+    MISSING_RE = /does not exist|could not find|schema cache/i;
   }
 });
 
@@ -967,6 +1628,17 @@ var init_guardrails = __esm({
   }
 });
 
+// packages/shared/src/core/model-capabilities.ts
+function modelRejectsSamplingParams(model) {
+  if (!model) return false;
+  return /opus[-_.]?4[-_.]?[789]\b|opus[-_.]?[5-9]\b/i.test(model);
+}
+var init_model_capabilities = __esm({
+  "packages/shared/src/core/model-capabilities.ts"() {
+    "use strict";
+  }
+});
+
 // packages/shared/src/core/openrouter-client.ts
 function getModelForFunction(fn) {
   return COGNITIVE_MODEL_MAP[fn] || OPENROUTER_MODELS["llama-70b"];
@@ -1033,7 +1705,8 @@ async function generateOpenRouterResponse(opts) {
         model,
         messages,
         max_tokens: maxTokens,
-        temperature: opts.temperature ?? 0.7
+        // Opus 4.7+ via OpenRouter rejects temperature/top_p — strip for those models.
+        ...modelRejectsSamplingParams(model) ? {} : { temperature: opts.temperature ?? 0.7 }
       })
     });
     if (!response.ok) {
@@ -1064,6 +1737,7 @@ var init_openrouter_client = __esm({
   "packages/shared/src/core/openrouter-client.ts"() {
     "use strict";
     init_logger();
+    init_model_capabilities();
     log3 = createChildLogger("openrouter");
     OPENROUTER_API_URL = "https://openrouter.ai/api/v1";
     OPENROUTER_MODELS = {
@@ -1126,7 +1800,7 @@ var init_openrouter_client = __esm({
 });
 
 // packages/shared/src/utils/constants.ts
-var MEMO_PROGRAM_ID, SOLSCAN_TX_BASE_URL, TWEET_MAX_LENGTH, BOT_X_HANDLE, MEMORY_MIN_DECAY, MEMORY_MAX_CONTENT_LENGTH, MEMORY_MAX_SUMMARY_LENGTH, DECAY_RATES, RECENCY_DECAY_BASE, RETRIEVAL_WEIGHT_RECENCY, RETRIEVAL_WEIGHT_RELEVANCE, RETRIEVAL_WEIGHT_IMPORTANCE, RETRIEVAL_WEIGHT_VECTOR, KNOWLEDGE_TYPE_BOOST, VECTOR_MATCH_THRESHOLD, BOND_TYPE_WEIGHTS, RETRIEVAL_WEIGHT_GRAPH, RETRIEVAL_WEIGHT_COOCCURRENCE, LINK_SIMILARITY_THRESHOLD, MAX_AUTO_LINKS, LINK_CO_RETRIEVAL_BOOST, INTERNAL_MEMORY_SOURCES, INTERNAL_IMPORTANCE_BOOST, REFLECTION_IMPORTANCE_THRESHOLD, REFLECTION_MIN_INTERVAL_MS, WHALE_SELL_COOLDOWN_MS, MEMO_MAX_LENGTH;
+var MEMO_PROGRAM_ID, SOLSCAN_TX_BASE_URL, TWEET_MAX_LENGTH, BOT_X_HANDLE, MEMORY_MIN_DECAY, MEMORY_MAX_CONTENT_LENGTH, MEMORY_MAX_SUMMARY_LENGTH, DECAY_RATES, RECENCY_DECAY_BASE, RETRIEVAL_WEIGHT_RECENCY, RETRIEVAL_WEIGHT_RELEVANCE, RETRIEVAL_WEIGHT_IMPORTANCE, RETRIEVAL_WEIGHT_VECTOR, RETRIEVAL_WEIGHT_BM25, KNOWLEDGE_TYPE_BOOST, VECTOR_MATCH_THRESHOLD, BOND_TYPE_WEIGHTS, RETRIEVAL_WEIGHT_GRAPH, RETRIEVAL_WEIGHT_COOCCURRENCE, LINK_SIMILARITY_THRESHOLD, MAX_AUTO_LINKS, LINK_CO_RETRIEVAL_BOOST, INTERNAL_MEMORY_SOURCES, EMBEDDING_FRAGMENT_MAX_LENGTH, REFLECTION_IMPORTANCE_THRESHOLD, REFLECTION_MIN_INTERVAL_MS, WHALE_SELL_COOLDOWN_MS, MEMO_MAX_LENGTH;
 var init_constants = __esm({
   "packages/shared/src/utils/constants.ts"() {
     "use strict";
@@ -1150,10 +1824,11 @@ var init_constants = __esm({
       // Journal entries persist like knowledge
     };
     RECENCY_DECAY_BASE = 0.995;
-    RETRIEVAL_WEIGHT_RECENCY = 1;
-    RETRIEVAL_WEIGHT_RELEVANCE = 2;
-    RETRIEVAL_WEIGHT_IMPORTANCE = 2;
-    RETRIEVAL_WEIGHT_VECTOR = 4;
+    RETRIEVAL_WEIGHT_RECENCY = Number(process.env.RETRIEVAL_WEIGHT_RECENCY ?? "1.0");
+    RETRIEVAL_WEIGHT_RELEVANCE = Number(process.env.RETRIEVAL_WEIGHT_RELEVANCE ?? "2.0");
+    RETRIEVAL_WEIGHT_IMPORTANCE = Number(process.env.RETRIEVAL_WEIGHT_IMPORTANCE ?? "2.0");
+    RETRIEVAL_WEIGHT_VECTOR = Number(process.env.RETRIEVAL_WEIGHT_VECTOR ?? "4.0");
+    RETRIEVAL_WEIGHT_BM25 = Number(process.env.RETRIEVAL_WEIGHT_BM25 ?? "0.15");
     KNOWLEDGE_TYPE_BOOST = {
       semantic: 0.15,
       // Distilled knowledge gets meaningful boost
@@ -1170,6 +1845,8 @@ var init_constants = __esm({
     BOND_TYPE_WEIGHTS = {
       causes: 1,
       supports: 0.9,
+      supersedes: 0.85,
+      // decisive replacement: new fact overrides an older one (Memory 3.0 C1)
       concurrent_with: 0.8,
       resolves: 0.8,
       happens_before: 0.7,
@@ -1194,7 +1871,7 @@ var init_constants = __esm({
       "dream-cycle",
       "meditation"
     ]);
-    INTERNAL_IMPORTANCE_BOOST = 5e-3;
+    EMBEDDING_FRAGMENT_MAX_LENGTH = 2e3;
     REFLECTION_IMPORTANCE_THRESHOLD = 2;
     REFLECTION_MIN_INTERVAL_MS = 30 * 60 * 1e3;
     WHALE_SELL_COOLDOWN_MS = 30 * 60 * 1e3;
@@ -1291,10 +1968,12 @@ ${userContent || "(no message, just a mention)"}`;
       cognitiveFunction: options.cognitiveFunction
     });
   } else {
+    const directModel = getModel();
     const response = await getClient().messages.create({
-      model: getModel(),
+      model: directModel,
       max_tokens: options.maxTokens || 1024,
-      temperature: 0.9,
+      // Opus 4.7+ rejects temperature/top_p (HTTP 400) — strip for those models.
+      ...modelRejectsSamplingParams(directModel) ? {} : { temperature: 0.9 },
       system: systemPrompt,
       messages: [{ role: "user", content: userContent }]
     });
@@ -1321,10 +2000,11 @@ ${userContent || "(no message, just a mention)"}`;
 }
 async function generateImportanceScore(description) {
   const importancePrompt = process.env.CLUDE_IMPORTANCE_PROMPT || "You rate the importance of events for an AI agent. Respond with ONLY a single integer from 1 to 10. 1 = purely mundane. 5 = moderately important. 10 = extremely significant.";
+  const scoreModel = getModel();
   const response = await getClient().messages.create({
-    model: getModel(),
+    model: scoreModel,
     max_tokens: 10,
-    temperature: 0,
+    ...modelRejectsSamplingParams(scoreModel) ? {} : { temperature: 0 },
     system: importancePrompt,
     messages: [{
       role: "user",
@@ -1353,6 +2033,7 @@ var init_claude_client = __esm({
     init_guardrails();
     init_openrouter_client();
     init_constants();
+    init_model_capabilities();
     log4 = createChildLogger("claude-client");
     _systemPromptProvider = () => "You are an AI assistant with persistent memory.";
     _responsePostProcessor = (t) => t;
@@ -1373,11 +2054,18 @@ var init_claude_client = __esm({
 var embeddings_exports = {};
 __export(embeddings_exports, {
   _configureEmbeddings: () => _configureEmbeddings,
+  _fetchMetadataToken: () => _fetchMetadataToken,
+  _resetVertexAuthCache: () => _resetVertexAuthCache,
   generateEmbedding: () => generateEmbedding,
+  generateEmbeddingForSpace: () => generateEmbeddingForSpace,
   generateEmbeddings: () => generateEmbeddings,
   generateQueryEmbedding: () => generateQueryEmbedding,
+  generateQueryEmbeddingForSpace: () => generateQueryEmbeddingForSpace,
+  generateVertexEmbedding: () => generateVertexEmbedding,
+  generateVertexEmbeddings: () => generateVertexEmbeddings,
   getCachedEmbedding: () => getCachedEmbedding,
   isEmbeddingEnabled: () => isEmbeddingEnabled,
+  isVertexConfigured: () => isVertexConfigured,
   setCachedEmbedding: () => setCachedEmbedding
 });
 function getCachedEmbedding(text) {
@@ -1521,7 +2209,80 @@ async function generateEmbeddings(texts) {
     return texts.map(() => null);
   }
 }
-var log5, PROVIDERS, _enabled, _overrideConfig, EMBEDDING_CACHE_MAX, EMBEDDING_CACHE_TTL_MS, _embeddingCache;
+function _resetVertexAuthCache() {
+  _vertexToken = null;
+}
+async function _fetchMetadataToken() {
+  const res = await fetch(METADATA_TOKEN_URL, { headers: { "Metadata-Flavor": "Google" } });
+  if (!res.ok) throw new Error(`Vertex metadata token fetch failed: ${res.status}`);
+  const j = await res.json();
+  return { token: j.access_token, expiresInSec: j.expires_in };
+}
+async function getVertexAccessToken() {
+  const override = config.vertex.accessToken;
+  if (override) return override;
+  const now = Date.now();
+  if (_vertexToken && _vertexToken.expiresAtMs > now + 6e4) return _vertexToken.token;
+  const { token, expiresInSec } = await _fetchMetadataToken();
+  _vertexToken = { token, expiresAtMs: now + expiresInSec * 1e3 };
+  return token;
+}
+function vertexPredictUrl(model) {
+  const { project, location } = config.vertex;
+  return `https://${location}-aiplatform.googleapis.com/v1/projects/${project}/locations/${location}/publishers/google/models/${model}:predict`;
+}
+function isVertexConfigured() {
+  return !!config.vertex.project;
+}
+async function generateVertexEmbeddings(texts, dimensions) {
+  if (texts.length === 0) return [];
+  const { project, model, dimensions: defaultDims } = config.vertex;
+  if (!project) {
+    log5.warn("Vertex embeddings requested but VERTEX_PROJECT is unset");
+    return texts.map(() => null);
+  }
+  const outputDimensionality = dimensions ?? defaultDims;
+  const startMs = Date.now();
+  try {
+    const token = await getVertexAccessToken();
+    const res = await fetch(vertexPredictUrl(model), {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${token}`
+      },
+      body: JSON.stringify({
+        instances: texts.map((t) => ({ content: t.slice(0, 8e3) })),
+        parameters: { outputDimensionality }
+      })
+    });
+    if (!res.ok) {
+      const errText = await res.text();
+      log5.error({ status: res.status, body: errText.slice(0, 200), provider: "vertex" }, "Vertex embedding API error");
+      return texts.map(() => null);
+    }
+    const data = await res.json();
+    const preds = data.predictions ?? [];
+    log5.debug({ provider: "vertex", model, count: texts.length, elapsed: Date.now() - startMs }, "Vertex embeddings generated");
+    return texts.map((_, i) => preds[i]?.embeddings?.values ?? null);
+  } catch (err) {
+    log5.error({ err, provider: "vertex" }, "Vertex embedding generation failed");
+    return texts.map(() => null);
+  }
+}
+async function generateVertexEmbedding(text, dimensions) {
+  const [vec] = await generateVertexEmbeddings([text], dimensions);
+  return vec ?? null;
+}
+async function generateEmbeddingForSpace(space, text) {
+  if (space === "vertex") return generateVertexEmbedding(text);
+  return generateEmbedding(text);
+}
+async function generateQueryEmbeddingForSpace(space, text) {
+  if (space === "vertex") return generateVertexEmbedding(text);
+  return generateQueryEmbedding(text);
+}
+var log5, PROVIDERS, _enabled, _overrideConfig, EMBEDDING_CACHE_MAX, EMBEDDING_CACHE_TTL_MS, _embeddingCache, _vertexToken, METADATA_TOKEN_URL;
 var init_embeddings = __esm({
   "packages/shared/src/core/embeddings.ts"() {
     "use strict";
@@ -1554,6 +2315,8 @@ var init_embeddings = __esm({
     EMBEDDING_CACHE_MAX = 200;
     EMBEDDING_CACHE_TTL_MS = 30 * 60 * 1e3;
     _embeddingCache = /* @__PURE__ */ new Map();
+    _vertexToken = null;
+    METADATA_TOKEN_URL = "http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/token";
   }
 });
 
@@ -1860,6 +2623,39 @@ var init_solana_client = __esm({
   }
 });
 
+// packages/shared/src/core/memory-grounding.ts
+function byMemoryDateAsc(a, b) {
+  const ta = a.created_at ? Date.parse(a.created_at) : NaN;
+  const tb = b.created_at ? Date.parse(b.created_at) : NaN;
+  if (Number.isNaN(ta) && Number.isNaN(tb)) return 0;
+  if (Number.isNaN(ta)) return 1;
+  if (Number.isNaN(tb)) return -1;
+  return ta - tb;
+}
+function renderGroundedLine(m, suffix = "") {
+  const date = m.created_at ? new Date(m.created_at).toISOString().slice(0, 10) : "";
+  const stamp = date ? `[${date}] ` : "";
+  const summary = (m.summary || "").trim();
+  const content = (m.content || "").trim();
+  let body;
+  if (!content || content === summary) {
+    body = summary || content;
+  } else if (content.length <= GROUNDED_CONTENT_MAX) {
+    body = summary ? `${summary} \u2014 ${content}` : content;
+  } else {
+    const slice = content.slice(0, GROUNDED_CONTENT_MAX);
+    body = summary ? `${summary} \u2014 ${slice}\u2026` : `${slice}\u2026`;
+  }
+  return `- ${stamp}${body}${suffix}`;
+}
+var GROUNDED_CONTENT_MAX;
+var init_memory_grounding = __esm({
+  "packages/shared/src/core/memory-grounding.ts"() {
+    "use strict";
+    GROUNDED_CONTENT_MAX = 600;
+  }
+});
+
 // packages/shared/src/utils/format.ts
 function timeAgo(dateStr) {
   const ms = Date.now() - new Date(dateStr).getTime();
@@ -1921,7 +2717,7 @@ function stableStringify(value) {
   }
   if (typeof value === "object") {
     const obj = value;
-    const keys = Object.keys(obj).sort();
+    const keys = Object.keys(obj).filter((k) => obj[k] !== void 0).sort();
     const pairs = keys.map((k) => JSON.stringify(k) + ":" + stableStringify(obj[k]));
     return "{" + pairs.join(",") + "}";
   }
@@ -1964,9 +2760,12 @@ var init_content_hash = __esm({
 });
 
 // packages/tokenization/src/pack-merkle.ts
+var LEAF_PREFIX, INNER_PREFIX;
 var init_pack_merkle = __esm({
   "packages/tokenization/src/pack-merkle.ts"() {
     "use strict";
+    LEAF_PREFIX = Buffer.from([0]);
+    INNER_PREFIX = Buffer.from([1]);
   }
 });
 
@@ -2324,6 +3123,489 @@ var init_bm25_search = __esm({
   }
 });
 
+// packages/brain/src/memory/content-tokens.ts
+async function setContentTokens(db, memoryId, plaintext) {
+  try {
+    const { error } = await db.rpc("set_memory_content_tokens", {
+      p_memory_id: memoryId,
+      p_text: plaintext
+    });
+    if (error) {
+      log8.warn({ memoryId, error: error.message }, "set_memory_content_tokens failed (keyword recall degraded)");
+    }
+  } catch (err) {
+    log8.warn({ memoryId, err }, "set_memory_content_tokens threw (keyword recall degraded)");
+  }
+}
+var log8;
+var init_content_tokens = __esm({
+  "packages/brain/src/memory/content-tokens.ts"() {
+    "use strict";
+    init_logger();
+    log8 = createChildLogger("content-tokens");
+  }
+});
+
+// packages/brain/src/memory/reconcile-router.ts
+function shortReason(x) {
+  return typeof x === "string" ? x.slice(0, 200) : "";
+}
+function parseRouterReply(raw, candidateIds, model) {
+  const fail = (reason) => ({ op: "add", targetId: null, reason, model });
+  let obj;
+  try {
+    obj = JSON.parse(raw);
+  } catch {
+    const m = raw.match(/\{[\s\S]*\}/);
+    if (!m) return fail("router_parse_error");
+    try {
+      obj = JSON.parse(m[0]);
+    } catch {
+      return fail("router_parse_error");
+    }
+  }
+  if (obj === null || typeof obj !== "object" || Array.isArray(obj)) return fail("router_invalid_shape");
+  const rec = obj;
+  const op = rec.op;
+  if (op !== "add" && op !== "update" && op !== "noop") return fail("router_invalid_op");
+  if (op === "add") return { op: "add", targetId: null, reason: shortReason(rec.reason), model };
+  const rawTarget = rec.targetId ?? rec.target_id;
+  const targetId = typeof rawTarget === "number" ? rawTarget : Number(rawTarget);
+  if (!Number.isInteger(targetId) || !candidateIds.has(targetId)) return fail("router_invalid_target");
+  return { op, targetId, reason: shortReason(rec.reason), model };
+}
+function buildPayload(newFact, candidates) {
+  const lines = candidates.map(
+    (c) => `[id ${c.id}] date: ${c.eventDate ?? "unknown"} \u2014 ${c.summary}`
+  );
+  return `NEW fact:
+  date: ${newFact.eventDate ?? "unknown"} \u2014 ${newFact.summary}
+
+Candidate facts:
+${lines.join("\n")}`;
+}
+function isRouterConfigured() {
+  return config.memory.reconcileRouter && !!config.memory.reconcileModel && isOpenRouterEnabled();
+}
+function utcDay() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function rollDay() {
+  const d = utcDay();
+  if (d !== budgetDay) {
+    budgetDay = d;
+    budgetByOwner.clear();
+  }
+}
+function budgetKey(owner) {
+  return owner ?? "__BOT_OWN__";
+}
+function routerBudgetAvailable(owner) {
+  rollDay();
+  return (budgetByOwner.get(budgetKey(owner)) ?? 0) < config.memory.reconcileBudget;
+}
+function noteRouterCall(owner) {
+  rollDay();
+  const k = budgetKey(owner);
+  budgetByOwner.set(k, (budgetByOwner.get(k) ?? 0) + 1);
+}
+async function routeReconcile(newFact, candidates) {
+  const model = config.memory.reconcileModel;
+  const candidateIds = new Set(candidates.map((c) => c.id));
+  try {
+    const raw = await generateOpenRouterResponse({
+      systemPrompt: ROUTER_SYSTEM,
+      messages: [{ role: "user", content: buildPayload(newFact, candidates) }],
+      model,
+      // explicit — never cognitiveFunction (which overrides model with the fast llama slot)
+      maxTokens: 150,
+      temperature: 0
+    });
+    return parseRouterReply(raw, candidateIds, model);
+  } catch (err) {
+    log9.warn({ err: err?.message }, "reconcile router call failed \u2014 defaulting to add");
+    return { op: "add", targetId: null, reason: "router_error", model };
+  }
+}
+var log9, ROUTER_SYSTEM, budgetDay, budgetByOwner;
+var init_reconcile_router = __esm({
+  "packages/brain/src/memory/reconcile-router.ts"() {
+    "use strict";
+    init_config();
+    init_logger();
+    init_openrouter_client();
+    log9 = createChildLogger("reconcile-router");
+    ROUTER_SYSTEM = 'You are a memory reconciliation classifier. Given a NEW fact and a list of EXISTING candidate facts that all belong to the SAME user, decide the relationship of the NEW fact to the candidates. Respond with ONLY a single JSON object, no prose, no markdown.\nFormat: {"op":"add"|"update"|"noop","targetId":<candidate id or null>,"reason":"<short>"}\n- "noop": NEW states the SAME thing as candidate <targetId> (a duplicate). Set targetId.\n- "update": NEW corrects or SUPERSEDES candidate <targetId> \u2014 same underlying fact, changed value or a newer date. Set targetId to that candidate id.\n- "add": NEW is distinct from every candidate. targetId must be null.\nWhen unsure, choose "add". NEVER invent a targetId that is not in the candidate list.';
+    budgetDay = "";
+    budgetByOwner = /* @__PURE__ */ new Map();
+  }
+});
+
+// packages/brain/src/memory/reconcile-shadow.ts
+function logReconcileDegradeOnce(err, memoryId) {
+  if (reconcileDegradeLogged) return;
+  reconcileDegradeLogged = true;
+  const e = err;
+  log10.warn(
+    { code: e?.code, message: e?.message, memoryId },
+    "Reconcile shadow degraded (migration 046 unapplied?) \u2014 skipping; write unaffected"
+  );
+}
+function gateVersion() {
+  const { reconcileFloor: f, reconcileLo: lo, reconcileHi: hi } = config.memory;
+  return `c1-shadow-v1:floor=${f}:lo=${lo}:hi=${hi}`;
+}
+async function insertShadowRow(row) {
+  try {
+    const { error } = await getDb().from("memory_reconciliation_log").insert(row);
+    if (error) logReconcileDegradeOnce(error, row.memory_id);
+  } catch (err) {
+    logReconcileDegradeOnce(err, row.memory_id);
+  }
+}
+async function runReconcileShadow(memoryId, scope) {
+  if (process.env.BENCH_MODE === "true") return;
+  const ownerWalletForRow = scope === SCOPE_BOT_OWN ? null : scope;
+  const gv = gateVersion();
+  const db = getDb();
+  const skip = (reason) => insertShadowRow({
+    memory_id: memoryId,
+    owner_wallet: ownerWalletForRow,
+    mode: "shadow",
+    proposed_op: "skip",
+    target_memory_id: null,
+    max_cosine: null,
+    band: "none",
+    router_used: false,
+    fact_key: null,
+    reason,
+    gate_version: gv
+  });
+  const add = (reason, maxCosine2, band2) => insertShadowRow({
+    memory_id: memoryId,
+    owner_wallet: ownerWalletForRow,
+    mode: "shadow",
+    proposed_op: "add",
+    target_memory_id: null,
+    max_cosine: maxCosine2,
+    band: band2,
+    router_used: false,
+    fact_key: null,
+    reason,
+    gate_version: gv
+  });
+  let embedding;
+  let newSummary = "";
+  let newEventDate = null;
+  try {
+    const { data, error } = await db.from("memories").select("embedding, summary, event_date, created_at").eq("id", memoryId).maybeSingle();
+    if (error) {
+      logReconcileDegradeOnce(error, memoryId);
+      return;
+    }
+    const row = data;
+    embedding = row?.embedding ?? null;
+    newSummary = row?.summary ?? "";
+    newEventDate = row?.event_date ?? row?.created_at ?? null;
+  } catch (err) {
+    logReconcileDegradeOnce(err, memoryId);
+    return;
+  }
+  if (!embedding) {
+    await skip("no_embedding");
+    return;
+  }
+  const queryEmbedding = typeof embedding === "string" ? embedding : JSON.stringify(embedding);
+  let candidates;
+  try {
+    const { data, error } = await db.rpc("match_memories_temporal", {
+      query_embedding: queryEmbedding,
+      match_threshold: config.memory.reconcileFloor,
+      match_count: K_CANDIDATES,
+      start_date: null,
+      end_date: null,
+      filter_types: null,
+      filter_user: null,
+      min_decay: 0,
+      filter_owner: scope,
+      filter_tags: null
+    });
+    if (error) {
+      logReconcileDegradeOnce(error, memoryId);
+      return;
+    }
+    candidates = data ?? [];
+  } catch (err) {
+    logReconcileDegradeOnce(err, memoryId);
+    return;
+  }
+  candidates = candidates.filter((c) => c.id !== memoryId);
+  if (candidates.length === 0) {
+    await add("no_candidate", null, "none");
+    return;
+  }
+  const ids = candidates.map((c) => c.id);
+  let validIds;
+  const hydratedById = /* @__PURE__ */ new Map();
+  try {
+    const base = db.from("memories").select("id, owner_wallet, invalid_at, summary, event_date, created_at").in("id", ids);
+    const scoped = scope === SCOPE_BOT_OWN ? base.is("owner_wallet", null) : base.eq("owner_wallet", scope);
+    const { data, error } = await scoped;
+    if (error) {
+      logReconcileDegradeOnce(error, memoryId);
+      return;
+    }
+    const rows = data ?? [];
+    const valid = rows.filter((r) => r.invalid_at == null).filter((r) => scope === SCOPE_BOT_OWN ? r.owner_wallet == null : r.owner_wallet === scope);
+    validIds = new Set(valid.map((r) => r.id));
+    for (const r of valid) hydratedById.set(r.id, { summary: r.summary ?? "", eventDate: r.event_date ?? r.created_at ?? null });
+  } catch (err) {
+    logReconcileDegradeOnce(err, memoryId);
+    return;
+  }
+  const surviving = candidates.filter((c) => validIds.has(c.id));
+  if (surviving.length === 0) {
+    await add("no_valid_candidate", null, "none");
+    return;
+  }
+  const maxCosine = surviving[0].similarity;
+  const { reconcileLo: LO, reconcileHi: HI } = config.memory;
+  if (maxCosine < LO) {
+    await add("below_lo", maxCosine, "lo");
+    return;
+  }
+  const band = maxCosine >= HI ? "hi" : "mid";
+  const top = surviving[0];
+  if (isRouterConfigured() && routerBudgetAvailable(ownerWalletForRow)) {
+    noteRouterCall(ownerWalletForRow);
+    const routerCandidates = surviving.map((c) => ({
+      id: c.id,
+      summary: hydratedById.get(c.id)?.summary ?? "",
+      eventDate: hydratedById.get(c.id)?.eventDate ?? null
+    }));
+    const decision = await routeReconcile({ summary: newSummary, eventDate: newEventDate }, routerCandidates);
+    await insertShadowRow({
+      memory_id: memoryId,
+      owner_wallet: ownerWalletForRow,
+      mode: "shadow",
+      proposed_op: decision.op,
+      target_memory_id: decision.op === "add" ? null : decision.targetId,
+      max_cosine: maxCosine,
+      band,
+      router_used: true,
+      router_model: decision.model,
+      fact_key: null,
+      reason: decision.reason || "router",
+      gate_version: gv
+    });
+    return;
+  }
+  await insertShadowRow({
+    memory_id: memoryId,
+    owner_wallet: ownerWalletForRow,
+    mode: "shadow",
+    proposed_op: "needs_router",
+    target_memory_id: top.id,
+    max_cosine: maxCosine,
+    band,
+    router_used: false,
+    fact_key: null,
+    reason: "similar_prior_fact",
+    gate_version: gv
+  });
+}
+var log10, SCOPE_BOT_OWN, K_CANDIDATES, reconcileDegradeLogged;
+var init_reconcile_shadow = __esm({
+  "packages/brain/src/memory/reconcile-shadow.ts"() {
+    "use strict";
+    init_database();
+    init_config();
+    init_logger();
+    init_reconcile_router();
+    log10 = createChildLogger("reconcile-shadow");
+    SCOPE_BOT_OWN = "__BOT_OWN__";
+    K_CANDIDATES = 6;
+    reconcileDegradeLogged = false;
+  }
+});
+
+// packages/shared/src/core/owner-key-constants.ts
+var HKDF_SALT, HKDF_INFO;
+var init_owner_key_constants = __esm({
+  "packages/shared/src/core/owner-key-constants.ts"() {
+    "use strict";
+    HKDF_SALT = "clude-cortex-v1";
+    HKDF_INFO = "memory-encryption-x25519-v2";
+  }
+});
+
+// packages/shared/src/core/memory-envelope.ts
+function generateDek() {
+  return import_tweetnacl2.default.randomBytes(import_tweetnacl2.default.secretbox.keyLength);
+}
+function encryptField(plaintext, dek) {
+  const nonce = import_tweetnacl2.default.randomBytes(NONCE_LENGTH);
+  const message = new TextEncoder().encode(plaintext);
+  const ct = import_tweetnacl2.default.secretbox(message, nonce, dek);
+  const combined = new Uint8Array(NONCE_LENGTH + ct.length);
+  combined.set(nonce, 0);
+  combined.set(ct, NONCE_LENGTH);
+  return Buffer.from(combined).toString("base64");
+}
+function decryptField(encrypted, dek) {
+  try {
+    const combined = Buffer.from(encrypted, "base64");
+    if (combined.length < NONCE_LENGTH + 1) return null;
+    const nonce = combined.subarray(0, NONCE_LENGTH);
+    const ct = combined.subarray(NONCE_LENGTH);
+    const pt = import_tweetnacl2.default.secretbox.open(ct, nonce, dek);
+    if (!pt) return null;
+    return new TextDecoder().decode(pt);
+  } catch {
+    return null;
+  }
+}
+function wrapDek(dek, recipientPubkey) {
+  const ephemeral = import_tweetnacl2.default.box.keyPair();
+  const nonce = import_tweetnacl2.default.randomBytes(BOX_NONCE_LENGTH);
+  const boxed = import_tweetnacl2.default.box(dek, nonce, recipientPubkey, ephemeral.secretKey);
+  const combined = new Uint8Array(BOX_NONCE_LENGTH + boxed.length);
+  combined.set(nonce, 0);
+  combined.set(boxed, BOX_NONCE_LENGTH);
+  return {
+    wrapped: Buffer.from(combined).toString("base64"),
+    wrapPubkey: Buffer.from(ephemeral.publicKey).toString("base64")
+  };
+}
+function unwrapDek(wrapped, wrapPubkey, recipientSecretKey) {
+  try {
+    const combined = Buffer.from(wrapped, "base64");
+    if (combined.length < BOX_NONCE_LENGTH + 1) return null;
+    const nonce = combined.subarray(0, BOX_NONCE_LENGTH);
+    const boxed = combined.subarray(BOX_NONCE_LENGTH);
+    const ephemeralPub = Buffer.from(wrapPubkey, "base64");
+    if (ephemeralPub.length !== import_tweetnacl2.default.box.publicKeyLength) return null;
+    const out = import_tweetnacl2.default.box.open(boxed, nonce, ephemeralPub, recipientSecretKey);
+    return out ?? null;
+  } catch {
+    return null;
+  }
+}
+async function deriveOwnerEncryptionKeypair(signature) {
+  const seed = await hkdfAsync("sha256", signature, HKDF_SALT, HKDF_INFO, 32);
+  return import_tweetnacl2.default.box.keyPair.fromSecretKey(new Uint8Array(seed));
+}
+var import_tweetnacl2, import_crypto, import_util, hkdfAsync, NONCE_LENGTH, BOX_NONCE_LENGTH;
+var init_memory_envelope = __esm({
+  "packages/shared/src/core/memory-envelope.ts"() {
+    "use strict";
+    import_tweetnacl2 = __toESM(require("tweetnacl"));
+    import_crypto = require("crypto");
+    import_util = require("util");
+    init_owner_key_constants();
+    hkdfAsync = (0, import_util.promisify)(import_crypto.hkdf);
+    NONCE_LENGTH = import_tweetnacl2.default.secretbox.nonceLength;
+    BOX_NONCE_LENGTH = import_tweetnacl2.default.box.nonceLength;
+  }
+});
+
+// packages/shared/src/core/encryption-keys.ts
+function loadProviderKeypair() {
+  if (providerKeypair) return providerKeypair;
+  const b64 = process.env.PMP_PROVIDER_ENC_SECRET;
+  if (!b64) throw new Error("PMP_PROVIDER_ENC_SECRET is not set");
+  const secret = Buffer.from(b64, "base64");
+  if (secret.length !== import_tweetnacl3.default.box.secretKeyLength) {
+    throw new Error(`PMP_PROVIDER_ENC_SECRET must decode to 32 bytes (got ${secret.length})`);
+  }
+  providerKeypair = import_tweetnacl3.default.box.keyPair.fromSecretKey(new Uint8Array(secret));
+  log11.info("Provider encryption keypair loaded");
+  return providerKeypair;
+}
+async function getOwnerEncryptionKey(ownerWallet) {
+  const { data, error } = await getDb().from("encryption_keys").select("x25519_pubkey, verifier_ct").eq("owner_wallet", ownerWallet).maybeSingle();
+  if (error) throw new Error(`getOwnerEncryptionKey failed: ${error.message}`);
+  if (!data) return null;
+  return { x25519_pubkey: data.x25519_pubkey, verifier_ct: data.verifier_ct };
+}
+var import_tweetnacl3, log11, providerKeypair;
+var init_encryption_keys = __esm({
+  "packages/shared/src/core/encryption-keys.ts"() {
+    "use strict";
+    import_tweetnacl3 = __toESM(require("tweetnacl"));
+    init_database();
+    init_logger();
+    log11 = createChildLogger("encryption-keys");
+    providerKeypair = null;
+  }
+});
+
+// packages/brain/src/memory/memory-encryption.ts
+function isMemoryEncryptionEnabled() {
+  if (process.env.PMP_ENCRYPTION_ENABLED !== "true") return false;
+  try {
+    loadProviderKeypair();
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getBotOwnerKeypair() {
+  if (botKeypair) return botKeypair;
+  const wallet = getBotWallet();
+  if (!wallet) return null;
+  const sig = import_tweetnacl4.default.sign.detached(new TextEncoder().encode(DERIVE_MESSAGE), wallet.secretKey);
+  botKeypair = await deriveOwnerEncryptionKeypair(sig);
+  return botKeypair;
+}
+async function resolveOwnerPublicKey(ownerWallet) {
+  const botWallet2 = getBotWallet();
+  const botAddr = botWallet2?.publicKey.toBase58();
+  if (!ownerWallet || botAddr && ownerWallet === botAddr) {
+    const kp = await getBotOwnerKeypair();
+    return kp ? Buffer.from(kp.publicKey).toString("base64") : null;
+  }
+  const row = await getOwnerEncryptionKey(ownerWallet);
+  return row?.x25519_pubkey ?? null;
+}
+async function encryptForStorage(plaintext, ownerWallet) {
+  if (!isMemoryEncryptionEnabled()) return null;
+  const ownerPubkey = await resolveOwnerPublicKey(ownerWallet);
+  if (!ownerPubkey) {
+    log12.warn("No owner encryption key resolvable \u2014 storing plaintext (encrypted:false)");
+    return null;
+  }
+  const dek = generateDek();
+  const ciphertext = encryptField(plaintext, dek);
+  const ownerWrap = wrapDek(dek, Buffer.from(ownerPubkey, "base64"));
+  const provWrap = wrapDek(dek, loadProviderKeypair().publicKey);
+  return {
+    ciphertext,
+    ownerPubkey,
+    wraps: [
+      { recipient: "owner", wrapped_dek: ownerWrap.wrapped, wrap_pubkey: ownerWrap.wrapPubkey },
+      { recipient: "provider", wrapped_dek: provWrap.wrapped, wrap_pubkey: provWrap.wrapPubkey }
+    ]
+  };
+}
+function delegationStateForWrite(hasEnvelope) {
+  return hasEnvelope ? true : null;
+}
+var import_tweetnacl4, log12, DERIVE_MESSAGE, botKeypair;
+var init_memory_encryption = __esm({
+  "packages/brain/src/memory/memory-encryption.ts"() {
+    "use strict";
+    import_tweetnacl4 = __toESM(require("tweetnacl"));
+    init_memory_envelope();
+    init_encryption_keys();
+    init_solana_client();
+    init_logger();
+    log12 = createChildLogger("memory-encryption");
+    DERIVE_MESSAGE = "clude-memory-encryption-v1";
+    botKeypair = null;
+  }
+});
+
 // packages/shared/src/core/encryption.ts
 var encryption_exports = {};
 __export(encryption_exports, {
@@ -2339,11 +3621,11 @@ async function configureEncryption(solanaSecretKey) {
     throw new Error("Encryption requires a 64-byte Ed25519 secret key");
   }
   const seed = solanaSecretKey.slice(0, 32);
-  const derived = await hkdfAsync("sha256", seed, HKDF_SALT, HKDF_INFO, 32);
+  const derived = await hkdfAsync2("sha256", seed, HKDF_SALT2, HKDF_INFO2, 32);
   encryptionKey = new Uint8Array(derived);
-  const keypair = import_tweetnacl2.default.sign.keyPair.fromSecretKey(solanaSecretKey);
+  const keypair = import_tweetnacl5.default.sign.keyPair.fromSecretKey(solanaSecretKey);
   encryptionPubkey = Buffer.from(keypair.publicKey).toString("base64");
-  log8.info({ pubkey: encryptionPubkey.slice(0, 12) + "..." }, "Encryption configured");
+  log13.info({ pubkey: encryptionPubkey.slice(0, 12) + "..." }, "Encryption configured");
 }
 function isEncryptionEnabled() {
   return encryptionKey !== null;
@@ -2355,12 +3637,12 @@ function encryptContent(plaintext) {
   if (!encryptionKey) {
     throw new Error("Encryption not configured. Call configureEncryption() first.");
   }
-  const nonce = import_tweetnacl2.default.randomBytes(NONCE_LENGTH);
+  const nonce = import_tweetnacl5.default.randomBytes(NONCE_LENGTH2);
   const messageBytes = new TextEncoder().encode(plaintext);
-  const ciphertext = import_tweetnacl2.default.secretbox(messageBytes, nonce, encryptionKey);
-  const combined = new Uint8Array(NONCE_LENGTH + ciphertext.length);
+  const ciphertext = import_tweetnacl5.default.secretbox(messageBytes, nonce, encryptionKey);
+  const combined = new Uint8Array(NONCE_LENGTH2 + ciphertext.length);
   combined.set(nonce, 0);
-  combined.set(ciphertext, NONCE_LENGTH);
+  combined.set(ciphertext, NONCE_LENGTH2);
   return Buffer.from(combined).toString("base64");
 }
 function decryptContent(encrypted) {
@@ -2369,12 +3651,12 @@ function decryptContent(encrypted) {
   }
   try {
     const combined = Buffer.from(encrypted, "base64");
-    if (combined.length < NONCE_LENGTH + 1) {
+    if (combined.length < NONCE_LENGTH2 + 1) {
       return null;
     }
-    const nonce = combined.subarray(0, NONCE_LENGTH);
-    const ciphertext = combined.subarray(NONCE_LENGTH);
-    const plaintext = import_tweetnacl2.default.secretbox.open(ciphertext, nonce, encryptionKey);
+    const nonce = combined.subarray(0, NONCE_LENGTH2);
+    const ciphertext = combined.subarray(NONCE_LENGTH2);
+    const plaintext = import_tweetnacl5.default.secretbox.open(ciphertext, nonce, encryptionKey);
     if (!plaintext) {
       return null;
     }
@@ -2388,36 +3670,94 @@ function decryptMemoryBatch(memories) {
   for (const mem of memories) {
     if (!mem.encrypted) continue;
     if (mem.encryption_pubkey && mem.encryption_pubkey !== encryptionPubkey) {
-      log8.debug({ memPubkey: mem.encryption_pubkey?.slice(0, 12) }, "Skipping memory encrypted by different key");
+      log13.debug({ memPubkey: mem.encryption_pubkey?.slice(0, 12) }, "Skipping memory encrypted by different key");
       continue;
     }
     const decrypted = decryptContent(mem.content);
     if (decrypted !== null) {
       mem.content = decrypted;
     } else {
-      log8.warn("Failed to decrypt memory content \u2014 wrong key or corrupted data");
+      log13.warn("Failed to decrypt memory content \u2014 wrong key or corrupted data");
     }
   }
   return memories;
 }
-var import_tweetnacl2, import_crypto, import_util, log8, hkdfAsync, HKDF_SALT, HKDF_INFO, NONCE_LENGTH, encryptionKey, encryptionPubkey;
+var import_tweetnacl5, import_crypto2, import_util2, log13, hkdfAsync2, HKDF_SALT2, HKDF_INFO2, NONCE_LENGTH2, encryptionKey, encryptionPubkey;
 var init_encryption = __esm({
   "packages/shared/src/core/encryption.ts"() {
     "use strict";
-    import_tweetnacl2 = __toESM(require("tweetnacl"));
-    import_crypto = require("crypto");
-    import_util = require("util");
+    import_tweetnacl5 = __toESM(require("tweetnacl"));
+    import_crypto2 = require("crypto");
+    import_util2 = require("util");
     init_logger();
-    log8 = createChildLogger("encryption");
-    hkdfAsync = (0, import_util.promisify)(import_crypto.hkdf);
-    HKDF_SALT = "clude-cortex-v1";
-    HKDF_INFO = "memory-encryption";
-    NONCE_LENGTH = import_tweetnacl2.default.secretbox.nonceLength;
+    log13 = createChildLogger("encryption");
+    hkdfAsync2 = (0, import_util2.promisify)(import_crypto2.hkdf);
+    HKDF_SALT2 = "clude-cortex-v1";
+    HKDF_INFO2 = "memory-encryption";
+    NONCE_LENGTH2 = import_tweetnacl5.default.secretbox.nonceLength;
     encryptionKey = null;
     encryptionPubkey = null;
   }
 });
 
+// packages/brain/src/memory/memory-decryption.ts
+async function fetchProviderWraps(ids) {
+  const map = /* @__PURE__ */ new Map();
+  if (ids.length === 0) return map;
+  const { data, error } = await getDb().from("memory_dek_wraps").select("memory_id, wrapped_dek, wrap_pubkey").eq("recipient", "provider").in("memory_id", ids);
+  if (error || !data) return map;
+  for (const r of data) {
+    map.set(r.memory_id, { wrapped_dek: r.wrapped_dek, wrap_pubkey: r.wrap_pubkey });
+  }
+  return map;
+}
+async function decryptMemories(memories) {
+  if (!memories || memories.length === 0) return memories;
+  const encryptedRows = memories.filter((m) => m.encrypted === true);
+  if (encryptedRows.length === 0) return memories;
+  let providerSecret = null;
+  try {
+    providerSecret = loadProviderKeypair().secretKey;
+  } catch {
+    providerSecret = null;
+  }
+  const wraps = providerSecret ? await fetchProviderWraps(encryptedRows.map((m) => m.id)) : /* @__PURE__ */ new Map();
+  const legacyRows = [];
+  for (const mem of encryptedRows) {
+    const wrap = wraps.get(mem.id);
+    if (providerSecret && wrap) {
+      const dek = unwrapDek(wrap.wrapped_dek, wrap.wrap_pubkey, providerSecret);
+      const plain = dek ? decryptField(mem.content, dek) : null;
+      if (plain !== null) {
+        mem.content = plain;
+        continue;
+      }
+      log14.debug({ id: mem.id }, "Envelope decrypt failed \u2014 leaving ciphertext");
+      continue;
+    }
+    legacyRows.push(mem);
+  }
+  if (legacyRows.length > 0) decryptMemoryBatch(legacyRows);
+  return memories;
+}
+async function decryptOneContent(row) {
+  if (row.encrypted !== true) return row.content;
+  const [out] = await decryptMemories([{ ...row }]);
+  return out.content !== row.content ? out.content : null;
+}
+var log14;
+var init_memory_decryption = __esm({
+  "packages/brain/src/memory/memory-decryption.ts"() {
+    "use strict";
+    init_database();
+    init_memory_envelope();
+    init_encryption_keys();
+    init_encryption();
+    init_logger();
+    log14 = createChildLogger("memory-decryption");
+  }
+});
+
 // packages/brain/src/events/event-bus.ts
 var event_bus_exports = {};
 __export(event_bus_exports, {
@@ -2470,16 +3810,16 @@ async function findOrCreateEntity(name, entityType, opts) {
       mention_count: 1
     }).select().single();
     if (error) {
-      log9.error({ error: error.message, name }, "Failed to create entity");
+      log15.error({ error: error.message, name }, "Failed to create entity");
       return null;
     }
-    log9.debug({ id: newEntity.id, name, type: entityType }, "Entity created");
+    log15.debug({ id: newEntity.id, name, type: entityType }, "Entity created");
     embedEntity(newEntity.id, name, opts?.description).catch(
-      (err) => log9.debug({ err }, "Entity embedding failed")
+      (err) => log15.debug({ err }, "Entity embedding failed")
     );
     return newEntity;
   } catch (err) {
-    log9.error({ err, name }, "Entity findOrCreate failed");
+    log15.error({ err, name }, "Entity findOrCreate failed");
     return null;
   }
 }
@@ -2501,7 +3841,7 @@ async function createEntityMention(entityId, memoryId, context, salience = 0.5)
     salience: Math.max(0, Math.min(1, salience))
   }, { onConflict: "entity_id,memory_id" });
   if (error) {
-    log9.debug({ error: error.message, entityId, memoryId }, "Entity mention failed");
+    log15.debug({ error: error.message, entityId, memoryId }, "Entity mention failed");
   }
 }
 async function getMemoriesByEntity(entityId, opts) {
@@ -2513,12 +3853,12 @@ async function getMemoriesByEntity(entityId, opts) {
     `).eq("entity_id", entityId).order("salience", { ascending: false }).limit(opts?.limit || 20);
   const { data, error } = await query;
   if (error) {
-    log9.error({ error: error.message, entityId }, "Failed to get memories by entity");
+    log15.error({ error: error.message, entityId }, "Failed to get memories by entity");
     return [];
   }
   const { getOwnerWallet: getOwnerWallet4 } = (init_memory(), __toCommonJS(memory_exports));
   const ownerWallet = getOwnerWallet4();
-  const memories = (data || []).map((d) => d.memories).filter((m) => m !== null).filter((m) => !opts?.memoryTypes || opts.memoryTypes.includes(m.memory_type)).filter((m) => !ownerWallet || m.owner_wallet === ownerWallet);
+  const memories = (data || []).map((d) => d.memories).filter((m) => m !== null).filter((m) => m.provider_delegated !== false).filter((m) => !opts?.memoryTypes || opts.memoryTypes.includes(m.memory_type)).filter((m) => !ownerWallet || m.owner_wallet === ownerWallet);
   return memories;
 }
 async function getEntityCooccurrences(entityId, opts) {
@@ -2530,33 +3870,27 @@ async function getEntityCooccurrences(entityId, opts) {
       max_results: opts?.maxResults ?? 10
     });
     if (error || !data) {
-      log9.debug({ error: error?.message, entityId }, "Entity co-occurrence lookup failed");
+      log15.debug({ error: error?.message, entityId }, "Entity co-occurrence lookup failed");
       return [];
     }
     return data;
   } catch (err) {
-    log9.debug({ err, entityId }, "Entity co-occurrence skipped (RPC unavailable)");
+    log15.debug({ err, entityId }, "Entity co-occurrence skipped (RPC unavailable)");
     return [];
   }
 }
 async function createEntityRelation(sourceEntityId, targetEntityId, relationType, evidenceMemoryId, strength = 0.5) {
   if (sourceEntityId === targetEntityId) return;
   const db = getDb();
-  const { data: existing } = await db.from("entity_relations").select("id, strength, evidence_memory_ids").eq("source_entity_id", sourceEntityId).eq("target_entity_id", targetEntityId).eq("relation_type", relationType).single();
-  if (existing) {
-    const newEvidence = evidenceMemoryId && !existing.evidence_memory_ids.includes(evidenceMemoryId) ? [...existing.evidence_memory_ids, evidenceMemoryId] : existing.evidence_memory_ids;
-    await db.from("entity_relations").update({
-      strength: Math.min(1, existing.strength + 0.1),
-      evidence_memory_ids: newEvidence
-    }).eq("id", existing.id);
-  } else {
-    await db.from("entity_relations").insert({
-      source_entity_id: sourceEntityId,
-      target_entity_id: targetEntityId,
-      relation_type: relationType,
-      strength,
-      evidence_memory_ids: evidenceMemoryId ? [evidenceMemoryId] : []
-    });
+  const { error } = await db.rpc("upsert_entity_relation", {
+    p_src: sourceEntityId,
+    p_tgt: targetEntityId,
+    p_type: relationType,
+    p_evidence: evidenceMemoryId ?? null,
+    p_strength: strength
+  });
+  if (error) {
+    log15.warn({ err: error.message, sourceEntityId, targetEntityId, relationType }, "upsert_entity_relation failed");
   }
 }
 function extractEntitiesFromText(text) {
@@ -2636,11 +3970,11 @@ async function extractAndLinkEntities(memoryId, content, summary, relatedUser) {
           // base co-occurrence strength
         );
       } catch (err) {
-        log9.debug({ err, source: entityIds[i].name, target: entityIds[j].name }, "Failed to create entity relation");
+        log15.debug({ err, source: entityIds[i].name, target: entityIds[j].name }, "Failed to create entity relation");
       }
     }
   }
-  log9.debug({ memoryId, entityCount: extracted.length, relations: Math.max(0, entityIds.length * (entityIds.length - 1) / 2) }, "Entities extracted, linked, and related");
+  log15.debug({ memoryId, entityCount: extracted.length, relations: Math.max(0, entityIds.length * (entityIds.length - 1) / 2) }, "Entities extracted, linked, and related");
 }
 async function findSimilarEntities(query, opts) {
   if (!isEmbeddingEnabled()) return [];
@@ -2654,7 +3988,7 @@ async function findSimilarEntities(query, opts) {
     filter_types: opts?.entityTypes || null
   });
   if (error) {
-    log9.debug({ error: error.message }, "Entity vector search failed");
+    log15.debug({ error: error.message }, "Entity vector search failed");
     return [];
   }
   const ids = (data || []).map((d) => d.id);
@@ -2662,14 +3996,14 @@ async function findSimilarEntities(query, opts) {
   const { data: entities } = await db.from("entities").select("*").in("id", ids);
   return entities || [];
 }
-var log9;
+var log15;
 var init_graph = __esm({
   "packages/brain/src/memory/graph.ts"() {
     "use strict";
     init_database();
     init_logger();
     init_embeddings();
-    log9 = createChildLogger("memory-graph");
+    log15 = createChildLogger("memory-graph");
   }
 });
 
@@ -2697,8 +4031,11 @@ var init_owner_context = __esm({
 // packages/brain/src/memory/memory.ts
 var memory_exports = {};
 __export(memory_exports, {
-  SCOPE_BOT_OWN: () => SCOPE_BOT_OWN,
+  SCOPE_BOT_OWN: () => SCOPE_BOT_OWN2,
+  _resetOutboxDegradeLog: () => _resetOutboxDegradeLog,
   _setOwnerWallet: () => _setOwnerWallet,
+  applyOwnerPostGuard: () => applyOwnerPostGuard,
+  buildFragmentRpcArgs: () => buildFragmentRpcArgs,
   calculateImportance: () => calculateImportance,
   createMemoryLink: () => createMemoryLink,
   createMemoryLinksBatch: () => createMemoryLinksBatch,
@@ -2709,12 +4046,15 @@ __export(memory_exports, {
   formatMemoryContext: () => formatMemoryContext,
   generateHashId: () => generateHashId,
   getMemoryStats: () => getMemoryStats,
+  getOwnerScope: () => getOwnerScope,
   getOwnerWallet: () => getOwnerWallet,
   getRecentMemories: () => getRecentMemories,
   getSelfModel: () => getSelfModel,
   hydrateMemories: () => hydrateMemories,
   inferConcepts: () => inferConcepts,
   invalidateInstalledPacksCache: () => invalidateInstalledPacksCache,
+  isBenchMode: () => isBenchMode,
+  isOwnerScopeFailClosed: () => isOwnerScopeFailClosed,
   isValidHashId: () => isValidHashId,
   listMemories: () => listMemories,
   markJepaQueried: () => markJepaQueried,
@@ -2722,11 +4062,15 @@ __export(memory_exports, {
   moodToValence: () => moodToValence,
   recallMemories: () => recallMemories,
   recallMemorySummaries: () => recallMemorySummaries,
+  runEnrichPipeline: () => runEnrichPipeline,
   scopeToOwner: () => scopeToOwner,
+  scoreImportanceOnWrite: () => scoreImportanceOnWrite,
   scoreImportanceWithLLM: () => scoreImportanceWithLLM,
   scoreMemory: () => scoreMemory,
+  shouldTrackAccess: () => shouldTrackAccess,
   storeDreamLog: () => storeDreamLog,
   storeMemory: () => storeMemory,
+  storeMemoryWithOutbox: () => storeMemoryWithOutbox,
   updateMemory: () => updateMemory
 });
 function getCachedEmbedding2(query) {
@@ -2755,18 +4099,51 @@ function getOwnerWallet() {
   if (contextWallet !== void 0) return contextWallet;
   return _ownerWallet;
 }
-function scopeToOwner(query) {
+function isOwnerScopeFailClosed() {
+  return process.env.OWNER_SCOPE_FAILCLOSED === "true";
+}
+function getOwnerScope() {
   const wallet = getOwnerWallet();
-  if (wallet === SCOPE_BOT_OWN) {
+  if (wallet) return wallet;
+  return isOwnerScopeFailClosed() ? SCOPE_BOT_OWN2 : null;
+}
+function scopeToOwner(query) {
+  const scope = getOwnerScope();
+  if (scope === SCOPE_BOT_OWN2) {
     return query.is("owner_wallet", null);
   }
-  if (wallet) {
-    return query.eq("owner_wallet", wallet);
+  if (scope) {
+    return query.eq("owner_wallet", scope);
   }
   return query;
 }
+function applyOwnerPostGuard(results, scope) {
+  if (!scope) return { kept: results, stripped: 0 };
+  const kept = scope === SCOPE_BOT_OWN2 ? results.filter((m) => m.owner_wallet == null) : results.filter((m) => m.owner_wallet === scope);
+  return { kept, stripped: results.length - kept.length };
+}
+function isBenchMode() {
+  return process.env.BENCH_MODE === "true";
+}
+function shouldTrackAccess(opts) {
+  if (isBenchMode()) return false;
+  return opts.trackAccess !== false;
+}
+function buildFragmentRpcArgs(opts) {
+  const args = {
+    query_embedding: opts.embeddingJson,
+    match_threshold: opts.matchThreshold,
+    match_count: opts.matchCount,
+    filter_owner: getOwnerScope()
+  };
+  if (process.env.MEMORY_FRAGMENT_FILTERS === "true") {
+    args.min_decay = opts.minDecay;
+    args.filter_types = opts.memoryTypes && opts.memoryTypes.length > 0 ? opts.memoryTypes : null;
+  }
+  return args;
+}
 function generateHashId() {
-  return `${HASH_ID_PREFIX}-${(0, import_crypto2.randomBytes)(4).toString("hex")}`;
+  return `${HASH_ID_PREFIX}-${(0, import_crypto3.randomBytes)(4).toString("hex")}`;
 }
 function isValidHashId(id) {
   return /^clude-[a-f0-9]{8}$/.test(id);
@@ -2801,6 +4178,23 @@ function inferConcepts(summary, source, tags) {
     concepts.push("identity_evolution");
   return [...new Set(concepts)];
 }
+function scoreImportanceOnWrite(opts) {
+  const base = {
+    self_model: 0.75,
+    semantic: 0.7,
+    procedural: 0.65,
+    introspective: 0.6,
+    episodic: 0.45
+  };
+  let score = base[opts.type] ?? 0.5;
+  const len = (opts.content ?? "").trim().length;
+  score += Math.min(len / 1e3, 0.15);
+  if (opts.tags && opts.tags.length) score += 0.05;
+  const concepts = opts.concepts ?? inferConcepts(opts.summary, opts.source, opts.tags || []);
+  if (concepts.length) score += 0.05;
+  if (INTERNAL_MEMORY_SOURCES.has(opts.source)) score -= 0.05;
+  return Math.max(0, Math.min(1, score));
+}
 function normalizeSummary(summary) {
   return summary.replace(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, "<id>").replace(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}[^\s]*/g, "<ts>").toLowerCase().trim();
 }
@@ -2832,7 +4226,7 @@ async function getInstalledPackIdsCached(ownerWallet) {
         ids = Array.from(/* @__PURE__ */ new Set([DEFAULT_PACK_ID, ...fromDb]));
       }
     } catch (err) {
-      log10.debug({ err }, "Failed to fetch installed packs (using default only)");
+      log16.debug({ err }, "Failed to fetch installed packs (using default only)");
     }
   }
   installedPacksCache.set(key, { ids, expiresAt: now + INSTALLED_PACKS_TTL_MS });
@@ -2869,7 +4263,7 @@ async function ensureTopicEmbeddings(installedPackIds) {
         if (emb) topicEmbeddingCache.set(s.topicId, emb);
       });
     } catch (err) {
-      log10.warn({ err }, "Failed to populate topic embeddings cache");
+      log16.warn({ err }, "Failed to populate topic embeddings cache");
     } finally {
       topicEmbeddingPopulationLock = null;
     }
@@ -2880,12 +4274,18 @@ async function ensureTopicEmbeddings(installedPackIds) {
   );
 }
 async function storeMemory(opts) {
+  const trimmedContent = (opts.content ?? "").trim();
+  if (!trimmedContent) {
+    log16.warn({ source: opts.source }, "Rejected empty-content memory");
+    return null;
+  }
   if (opts.source.startsWith("shiro_") && isDuplicateWrite(opts.source, opts.summary)) {
-    log10.debug({ source: opts.source, summary: opts.summary.slice(0, 60) }, "Skipping duplicate memory write");
+    log16.debug({ source: opts.source, summary: opts.summary.slice(0, 60) }, "Skipping duplicate memory write");
     return null;
   }
   const db = getDb();
   const ownerWallet = getOwnerWallet();
+  const importance = clamp(opts.importance ?? scoreImportanceOnWrite(opts), 0, 1);
   const concepts = opts.concepts || inferConcepts(opts.summary, opts.source, opts.tags || []);
   const installedPackIds = await getInstalledPackIdsCached(ownerWallet);
   const taggedTags = autoCategorizeTags({
@@ -2896,9 +4296,10 @@ async function storeMemory(opts) {
   });
   const hashId = generateHashId();
   try {
-    const plaintextContent = opts.content.slice(0, MEMORY_MAX_CONTENT_LENGTH);
-    const shouldEncrypt = isEncryptionEnabled();
-    const storedContent = shouldEncrypt ? encryptContent(plaintextContent) : plaintextContent;
+    const plaintextContent = trimmedContent.slice(0, MEMORY_MAX_CONTENT_LENGTH);
+    const envelope = await encryptForStorage(plaintextContent, ownerWallet || null);
+    const legacyEncrypt = !envelope && isEncryptionEnabled();
+    const storedContent = envelope ? envelope.ciphertext : legacyEncrypt ? encryptContent(plaintextContent) : plaintextContent;
     const { data, error } = await db.from("memories").insert({
       hash_id: hashId,
       memory_type: opts.type,
@@ -2907,7 +4308,7 @@ async function storeMemory(opts) {
       tags: taggedTags,
       concepts,
       emotional_valence: clamp(opts.emotionalValence ?? 0, -1, 1),
-      importance: clamp(opts.importance ?? 0.5, 0, 1),
+      importance,
       source: opts.source,
       source_id: opts.sourceId || null,
       related_user: opts.relatedUser || null,
@@ -2915,43 +4316,72 @@ async function storeMemory(opts) {
       metadata: opts.metadata || {},
       evidence_ids: opts.evidenceIds || [],
       compacted: false,
-      encrypted: shouldEncrypt,
-      encryption_pubkey: shouldEncrypt ? getEncryptionPubkey() : null,
+      encrypted: envelope !== null || legacyEncrypt,
+      encryption_pubkey: envelope ? envelope.ownerPubkey : legacyEncrypt ? getEncryptionPubkey() : null,
+      provider_delegated: delegationStateForWrite(envelope !== null),
+      // true|null at write; false is revoke-only (§7)
       owner_wallet: ownerWallet || null
     }).select("id, hash_id, content, memory_type, owner_wallet, created_at, tags, source, related_user, related_wallet").single();
     if (error) {
-      log10.error({ error: error.message }, "Failed to store memory");
+      log16.error({ error: error.message }, "Failed to store memory");
       return null;
     }
-    log10.debug({
+    log16.debug({
       id: data.id,
       hashId: data.hash_id,
       type: opts.type,
       summary: opts.summary.slice(0, 60),
-      importance: opts.importance,
+      importance,
       concepts
     }, "Memory stored");
+    await setContentTokens(db, data.id, plaintextContent);
+    if (envelope) {
+      const { error: wrapErr } = await db.from("memory_dek_wraps").insert(
+        envelope.wraps.map((w) => ({ memory_id: data.id, ...w }))
+      );
+      if (wrapErr) {
+        log16.error({ id: data.id, error: wrapErr.message }, "DEK wrap write failed \u2014 reverting memory to plaintext");
+        await db.from("memories").update({
+          content: plaintextContent,
+          encrypted: false,
+          encryption_pubkey: null,
+          provider_delegated: null
+        }).eq("id", data.id);
+      }
+    }
     eventBus.emit("memory:stored", {
-      importance: clamp(opts.importance ?? 0.5, 0, 1),
+      importance,
       memoryType: opts.type,
       source: opts.source
     });
-    commitMemoryToChain(data.id, opts, data).catch(
-      (err) => log10.warn({ err }, "On-chain memory commit failed")
+    commitMemoryToChain(data.id, opts, data, plaintextContent, envelope !== null || legacyEncrypt).catch(
+      (err) => log16.warn({ err }, "On-chain memory commit failed")
     );
-    embedMemory(data.id, opts).catch((err) => log10.warn({ err }, "Embedding generation failed"));
-    autoLinkMemory(data.id, opts).catch((err) => log10.warn({ err }, "Auto-linking failed"));
-    extractAndLinkEntitiesForMemory(data.id, opts).catch((err) => log10.debug({ err }, "Entity extraction failed"));
+    let enqueued = false;
+    if (config.memory.outboxEnabled) {
+      enqueued = await enqueueEnrichJob(db, data.id);
+    }
+    if (!enqueued) {
+      const embedP = embedMemory(data.id, opts);
+      embedP.catch((err) => log16.warn({ err }, "Embedding generation failed"));
+      autoLinkMemory(data.id, opts).catch((err) => log16.warn({ err }, "Auto-linking failed"));
+      extractAndLinkEntitiesForMemory(data.id, opts).catch((err) => log16.debug({ err }, "Entity extraction failed"));
+      if (config.memory.reconcileEnabled) {
+        const reconcileScope = ownerWallet || SCOPE_BOT_OWN2;
+        embedP.then(() => runReconcileShadow(data.id, reconcileScope)).catch(() => {
+        });
+      }
+    }
     return data.id;
   } catch (err) {
-    log10.error({ err }, "Memory store failed");
+    log16.error({ err }, "Memory store failed");
     return null;
   }
 }
-async function commitMemoryToChain(memoryId, opts, row) {
+async function commitMemoryToChain(memoryId, opts, row, plaintextContent, encrypted) {
   if (TOKENISATION_SKIP_SOURCES.has(opts.source)) return;
   const canonicalHash = memoryContentHash({
-    content: row.content,
+    content: plaintextContent,
     memory_type: row.memory_type,
     owner_wallet: row.owner_wallet,
     created_at: row.created_at,
@@ -2963,7 +4393,6 @@ async function commitMemoryToChain(memoryId, opts, row) {
   const contentHashBuf = Buffer.from(canonicalHash, "hex");
   let signature = null;
   if (isRegistryEnabled()) {
-    const encrypted = isEncryptionEnabled();
     signature = await registerMemoryOnChain(
       contentHashBuf,
       opts.type,
@@ -2992,18 +4421,101 @@ async function commitMemoryToChain(memoryId, opts, row) {
     tokenization_status: "minted",
     tokenized_at: (/* @__PURE__ */ new Date()).toISOString()
   }).eq("id", memoryId);
-  log10.debug({ memoryId, signature: signature.slice(0, 16) }, "Memory committed on-chain (PMP + legacy)");
+  log16.debug({ memoryId, signature: signature.slice(0, 16) }, "Memory committed on-chain (PMP + legacy)");
+}
+function logOutboxDegradeOnce(err, memoryId) {
+  if (outboxDegradeLogged) return;
+  outboxDegradeLogged = true;
+  const e = err;
+  log16.warn(
+    { code: e?.code, message: e?.message, memoryId },
+    "Outbox enqueue degraded \u2014 falling back to fire-and-forget (migration 044 unapplied?)"
+  );
+}
+async function enqueueEnrichJob(db, memoryId) {
+  try {
+    const { error } = await db.from("memory_write_jobs").insert({ memory_id: memoryId, job_type: "enrich" });
+    if (error) {
+      logOutboxDegradeOnce(error, memoryId);
+      return false;
+    }
+    return true;
+  } catch (err) {
+    logOutboxDegradeOnce(err, memoryId);
+    return false;
+  }
+}
+function _resetOutboxDegradeLog() {
+  outboxDegradeLogged = false;
+}
+async function runEnrichPipeline(memoryId, opts) {
+  await embedMemory(memoryId, opts, { replaceFragments: true });
+  await autoLinkMemory(memoryId, opts);
+  await extractAndLinkEntitiesForMemory(memoryId, opts);
+  if (config.memory.reconcileEnabled) {
+    await runReconcileShadow(memoryId, getOwnerWallet() || SCOPE_BOT_OWN2);
+  }
 }
-async function embedMemory(memoryId, opts) {
+async function storeMemoryWithOutbox(opts) {
+  const id = await storeMemory(opts);
+  if (id === null) return null;
+  const db = getDb();
+  const { data: row } = await db.from("memories").select("hash_id").eq("id", id).maybeSingle();
+  const { count } = await db.from("memory_write_jobs").select("id", { count: "exact", head: true }).eq("memory_id", id);
+  return { id, hash_id: row?.hash_id ?? "", jobs_queued: count ?? 0 };
+}
+async function embedMemory(memoryId, opts, embedOpts = {}) {
   if (!isEmbeddingEnabled()) return;
   const db = getDb();
-  const embeddings = await generateEmbeddings([opts.summary]);
+  const fragments = [];
+  fragments.push({ type: "summary", text: opts.summary });
+  const content = opts.content.slice(0, MEMORY_MAX_CONTENT_LENGTH);
+  if (content.length > EMBEDDING_FRAGMENT_MAX_LENGTH) {
+    const sentences = content.match(/[^.!?\n]+[.!?\n]+/g) || [content];
+    let chunk = "";
+    for (const sentence of sentences) {
+      if (chunk.length + sentence.length > EMBEDDING_FRAGMENT_MAX_LENGTH && chunk.length > 0) {
+        fragments.push({ type: "content_chunk", text: chunk.trim() });
+        chunk = "";
+      }
+      chunk += sentence;
+    }
+    if (chunk.trim()) fragments.push({ type: "content_chunk", text: chunk.trim() });
+  } else {
+    fragments.push({ type: "content_chunk", text: content });
+  }
+  const allLabels = [...opts.tags || [], ...opts.concepts || inferConcepts(opts.summary, opts.source, opts.tags || [])];
+  if (allLabels.length > 0) {
+    fragments.push({ type: "tag_context", text: `Context: ${allLabels.join(", ")}. ${opts.summary}` });
+  }
+  const embeddings = await generateEmbeddings(fragments.map((f) => f.text));
   const summaryEmbedding = embeddings[0];
   if (!summaryEmbedding) {
-    log10.debug({ memoryId }, "No embedding generated; skipping semantic tagging");
+    log16.debug({ memoryId }, "No embedding generated; skipping semantic tagging");
     return;
   }
-  await db.from("memories").update({ embedding: JSON.stringify(summaryEmbedding) }).eq("id", memoryId);
+  const vertexEmbeddings = isVertexConfigured() ? await generateVertexEmbeddings(fragments.map((f) => f.text)) : [];
+  const vertexSummary = vertexEmbeddings[0];
+  await db.from("memories").update({
+    embedding: JSON.stringify(summaryEmbedding),
+    ...vertexSummary ? { embedding_vertex: JSON.stringify(vertexSummary) } : {}
+  }).eq("id", memoryId);
+  const fragmentRows = fragments.map((f, i) => ({
+    memory_id: memoryId,
+    fragment_type: f.type,
+    content: f.text.slice(0, EMBEDDING_FRAGMENT_MAX_LENGTH),
+    embedding: embeddings[i] ? JSON.stringify(embeddings[i]) : null,
+    ...vertexEmbeddings[i] ? { embedding_vertex: JSON.stringify(vertexEmbeddings[i]) } : {}
+  })).filter((r) => r.embedding !== null);
+  if (fragmentRows.length > 0) {
+    if (embedOpts.replaceFragments) {
+      await db.from("memory_fragments").delete().eq("memory_id", memoryId);
+    }
+    const { error } = await db.from("memory_fragments").insert(fragmentRows);
+    if (error) {
+      log16.warn({ err: error.message, memoryId }, "Failed to store memory fragments (summary embedding intact)");
+    }
+  }
   try {
     const ownerWallet = getOwnerWallet();
     const installedPacks = await getInstalledPackIdsCached(ownerWallet);
@@ -3019,7 +4531,7 @@ async function embedMemory(memoryId, opts) {
         const merged = Array.from(/* @__PURE__ */ new Set([...existing, ...semantic]));
         if (merged.length !== existing.length) {
           await db.from("memories").update({ tags: merged }).eq("id", memoryId);
-          log10.debug({
+          log16.debug({
             memoryId,
             added: semantic.filter((t) => !existing.includes(t))
           }, "Semantic pack tags appended");
@@ -3027,9 +4539,9 @@ async function embedMemory(memoryId, opts) {
       }
     }
   } catch (err) {
-    log10.debug({ err, memoryId }, "Semantic tagging skipped");
+    log16.debug({ err, memoryId }, "Semantic tagging skipped");
   }
-  log10.debug({ memoryId }, "Memory embedded");
+  log16.debug({ memoryId }, "Memory embedded");
 }
 async function expandQuery(query) {
   if (!isOpenRouterEnabled()) return [query];
@@ -3047,10 +4559,10 @@ async function expandQuery(query) {
       new Promise((_, reject) => setTimeout(() => reject(new Error("timeout")), 3e3))
     ]);
     const expansions = response.split("\n").map((l) => l.trim()).filter((l) => l.length > 5 && l.length < 200).slice(0, 3);
-    log10.debug({ original: query, expansions: expansions.length }, "Query expanded");
+    log16.debug({ original: query, expansions: expansions.length }, "Query expanded");
     return [query, ...expansions];
   } catch (err) {
-    log10.debug({ err }, "Query expansion failed, using original");
+    log16.debug({ err }, "Query expansion failed, using original");
     return [query];
   }
 }
@@ -3063,11 +4575,12 @@ async function recallMemories(opts) {
     let vectorScores = opts._vectorScores || /* @__PURE__ */ new Map();
     let primaryQueryEmbedding = null;
     const vectorSearchPromise = queries.length > 0 && isEmbeddingEnabled() && !opts._vectorScores ? (async () => {
+      const space = activeEmbeddingSpace();
       const queryEmbeddings = await Promise.all(
         queries.map(async (q) => {
           const cached = getCachedEmbedding2(q);
           if (cached) return cached;
-          const emb = await generateQueryEmbedding(q);
+          const emb = await generateQueryEmbeddingForSpace(space, q);
           if (emb) setCachedEmbedding2(q, emb);
           return emb;
         })
@@ -3075,39 +4588,69 @@ async function recallMemories(opts) {
       const validEmbeddings = queryEmbeddings.filter((e) => e !== null);
       if (validEmbeddings.length > 0) primaryQueryEmbedding = validEmbeddings[0];
       if (validEmbeddings.length === 0) {
-        log10.debug("All query embeddings returned null, using keyword-only retrieval");
+        log16.debug("All query embeddings returned null, using keyword-only retrieval");
         return;
       }
       try {
-        const allSearches = validEmbeddings.map(
-          (emb) => Promise.resolve(db.rpc("match_memories", {
-            query_embedding: JSON.stringify(emb),
-            match_threshold: VECTOR_MATCH_THRESHOLD,
-            match_count: limit * (opts.skipExpansion ? 12 : 4),
-            filter_types: opts.memoryTypes || null,
-            filter_user: opts.relatedUser || null,
-            min_decay: minDecay,
-            filter_owner: getOwnerWallet() || null,
-            filter_tags: opts.tags && opts.tags.length > 0 ? opts.tags : null
-          })).then((r) => r.data || [])
-        );
+        const allSearches = validEmbeddings.flatMap((emb) => {
+          const searches = [
+            Promise.resolve(db.rpc(vectorRpcName("match_memories"), {
+              query_embedding: JSON.stringify(emb),
+              match_threshold: VECTOR_MATCH_THRESHOLD,
+              match_count: limit * (opts.skipExpansion ? 12 : 4),
+              filter_types: opts.memoryTypes || null,
+              filter_user: opts.relatedUser || null,
+              min_decay: minDecay,
+              filter_owner: getOwnerScope(),
+              filter_tags: opts.tags && opts.tags.length > 0 ? opts.tags : null
+            })).then((r) => r.data || [])
+          ];
+          if (!opts.skipExpansion) {
+            searches.push(
+              Promise.resolve(db.rpc(vectorRpcName("match_memory_fragments"), buildFragmentRpcArgs({
+                embeddingJson: JSON.stringify(emb),
+                matchThreshold: VECTOR_MATCH_THRESHOLD,
+                matchCount: limit * 2,
+                minDecay,
+                memoryTypes: opts.memoryTypes
+              }))).then((r) => r.data || [])
+            );
+          }
+          return searches;
+        });
         const results2 = await Promise.all(allSearches);
-        for (const batch of results2) {
-          for (const m of batch) {
-            const current = vectorScores.get(m.id) || 0;
-            vectorScores.set(m.id, Math.max(current, m.similarity));
+        let fragmentHits = 0;
+        if (opts.skipExpansion) {
+          for (const batch of results2) {
+            for (const m of batch) {
+              const current = vectorScores.get(m.id) || 0;
+              vectorScores.set(m.id, Math.max(current, m.similarity));
+            }
+          }
+        } else {
+          for (let i = 0; i < results2.length; i++) {
+            const isFragmentBatch = i % 2 === 1;
+            for (const r of results2[i]) {
+              const id = isFragmentBatch ? r.memory_id : r.id;
+              const sim = isFragmentBatch ? r.max_similarity : r.similarity;
+              if (!id) continue;
+              const current = vectorScores.get(id) || 0;
+              vectorScores.set(id, Math.max(current, sim));
+              if (isFragmentBatch) fragmentHits++;
+            }
           }
         }
-        log10.debug({
+        log16.debug({
           queryVariants: validEmbeddings.length,
           uniqueMemories: vectorScores.size,
+          fragmentHits,
           fastMode: !!opts.skipExpansion
         }, "Vector search completed");
       } catch (err) {
-        log10.warn({ err }, "Vector search RPC failed, falling back to keyword retrieval");
+        log16.warn({ err }, "Vector search RPC failed, falling back to keyword retrieval");
       }
     })() : Promise.resolve();
-    let importanceQuery = db.from("memories").select("*").gte("decay_factor", minDecay).not("source", "in", '("demo","demo-maas")').order("importance", { ascending: false }).order("created_at", { ascending: false }).limit(limit * 3);
+    let importanceQuery = db.from("memories").select("*").gte("decay_factor", minDecay).not("source", "in", '("demo","demo-maas")').not("provider_delegated", "is", false).order("importance", { ascending: false }).order("created_at", { ascending: false }).limit(limit * 3);
     importanceQuery = scopeToOwner(importanceQuery);
     if (opts.memoryTypes && opts.memoryTypes.length > 0) {
       importanceQuery = importanceQuery.in("memory_type", opts.memoryTypes);
@@ -3130,7 +4673,12 @@ async function recallMemories(opts) {
         return await bm25SearchMemories(opts.query, {
           limit: limit * 2,
           minDecay,
-          filterOwner: _ownerWallet || void 0,
+          // Use getOwnerWallet() (AsyncLocalStorage-aware), NOT the bare module-level
+          // _ownerWallet. withOwnerWallet() sets the async context, not the module var,
+          // so the bare var is null under hosted/wrapped calls and BM25 would search the
+          // ENTIRE table unscoped — burying the owner's exact-match facts. This is why
+          // BM25 silently never surfaced bench facts even after the RPC was fixed.
+          filterOwner: getOwnerScope() || void 0,
           filterTypes: opts.memoryTypes || void 0,
           filterTags: opts.tags || void 0
         });
@@ -3184,7 +4732,7 @@ async function recallMemories(opts) {
             }
           }
         }
-        if (seedsAdded > 0) log10.debug({ seedsAdded, seedsTotal: knowledgeSeeds.length }, "Knowledge seeds added to candidates");
+        if (seedsAdded > 0) log16.debug({ seedsAdded, seedsTotal: knowledgeSeeds.length }, "Knowledge seeds added to candidates");
       }
     }
     const bm25Scores = /* @__PURE__ */ new Map();
@@ -3205,18 +4753,18 @@ async function recallMemories(opts) {
           }
         }
       }
-      log10.debug({ bm25Hits: bm25Results.length, bm25New: bm25MissingIds.length }, "BM25 search added candidates");
+      log16.debug({ bm25Hits: bm25Results.length, bm25New: bm25MissingIds.length }, "BM25 search added candidates");
     }
     if (error) {
-      log10.error({ error: error.message }, "Memory recall query failed");
+      log16.error({ error: error.message }, "Memory recall query failed");
       return [];
     }
-    let candidates = decryptMemoryBatch(data || []);
+    let candidates = await decryptMemories(data || []);
     if (vectorScores.size > 0) {
       const metadataIds = new Set(candidates.map((m) => m.id));
       const missingIds = [...vectorScores.keys()].filter((id) => !metadataIds.has(id));
       if (missingIds.length > 0) {
-        let vectorQuery = db.from("memories").select("*").in("id", missingIds);
+        let vectorQuery = db.from("memories").select("*").in("id", missingIds).gte("decay_factor", minDecay).not("embedding", "is", null);
         vectorQuery = scopeToOwner(vectorQuery);
         if (opts.memoryTypes && opts.memoryTypes.length > 0) {
           vectorQuery = vectorQuery.in("memory_type", opts.memoryTypes);
@@ -3225,7 +4773,7 @@ async function recallMemories(opts) {
           vectorQuery = vectorQuery.overlaps("tags", opts.tags);
         }
         const { data: vectorOnly } = await vectorQuery;
-        if (vectorOnly) candidates = [...candidates, ...decryptMemoryBatch(vectorOnly)];
+        if (vectorOnly) candidates = [...candidates, ...await decryptMemories(vectorOnly)];
       }
     }
     if (candidates.length === 0) return [];
@@ -3249,10 +4797,10 @@ async function recallMemories(opts) {
         if (entities.length > 0) {
           const resultIdSet = new Set(results.map((m) => m.id));
           for (const entity of entities) {
-            const entityMemories = await getMemoriesByEntity(entity.id, {
+            const entityMemories = await decryptMemories(await getMemoriesByEntity(entity.id, {
               limit: Math.ceil(limit / 2),
               memoryTypes: opts.memoryTypes
-            });
+            }));
             for (const mem of entityMemories) {
               addLinkPath(mem.id, "entity");
               if (!resultIdSet.has(mem.id)) {
@@ -3264,17 +4812,17 @@ async function recallMemories(opts) {
               }
             }
           }
-          log10.debug({ entities: entities.map((e) => e.name) }, "Entity-aware recall applied");
+          log16.debug({ entities: entities.map((e) => e.name) }, "Entity-aware recall applied");
           let cooccurrenceAdded = 0;
           const cooccurrenceNames = [];
           for (const entity of entities) {
             const cooccurrences = await getEntityCooccurrences(entity.id, { minCooccurrence: 2, maxResults: 3 });
             for (const cooc of cooccurrences) {
               if (cooccurrenceAdded >= limit) break;
-              const coMems = await getMemoriesByEntity(cooc.related_entity_id, {
+              const coMems = await decryptMemories(await getMemoriesByEntity(cooc.related_entity_id, {
                 limit: 3,
                 memoryTypes: opts.memoryTypes
-              });
+              }));
               for (const mem of coMems) {
                 if (cooccurrenceAdded >= limit) break;
                 addLinkPath(mem.id, "entity");
@@ -3294,11 +4842,11 @@ async function recallMemories(opts) {
             }
           }
           if (cooccurrenceAdded > 0) {
-            log10.debug({ cooccurrenceAdded, cooccurrenceEntities: cooccurrenceNames.length }, "Entity co-occurrence recall applied");
+            log16.debug({ cooccurrenceAdded, cooccurrenceEntities: cooccurrenceNames.length }, "Entity co-occurrence recall applied");
           }
         }
       } catch (err) {
-        log10.debug({ err }, "Entity-aware recall skipped");
+        log16.debug({ err }, "Entity-aware recall skipped");
       }
     }
     if (results.length > 0) {
@@ -3308,17 +4856,17 @@ async function recallMemories(opts) {
           seed_ids: seedIds,
           min_strength: 0.2,
           max_results: limit,
-          filter_owner: getOwnerWallet() || null
+          filter_owner: getOwnerScope()
         });
         if (linked && linked.length > 0) {
           const resultIdSet = new Set(seedIds);
           const graphCandidateIds = linked.filter((l) => !resultIdSet.has(l.memory_id)).map((l) => l.memory_id);
           if (graphCandidateIds.length > 0) {
-            let graphQuery = db.from("memories").select("*").in("id", graphCandidateIds);
+            let graphQuery = db.from("memories").select("*").in("id", graphCandidateIds).not("provider_delegated", "is", false);
             graphQuery = scopeToOwner(graphQuery);
             const { data: graphMemories } = await graphQuery;
             if (graphMemories && graphMemories.length > 0) {
-              decryptMemoryBatch(graphMemories);
+              await decryptMemories(graphMemories);
               const linkBoostMap = /* @__PURE__ */ new Map();
               for (const l of linked) {
                 const bondWeight = BOND_TYPE_WEIGHTS[l.link_type] ?? 0.4;
@@ -3332,7 +4880,7 @@ async function recallMemories(opts) {
                 _score: scoreMemory(mem, scoredOpts) + RETRIEVAL_WEIGHT_GRAPH * (linkBoostMap.get(mem.id) || 0)
               }));
               results = [...results, ...graphScored].sort((a, b) => b._score - a._score).slice(0, limit);
-              log10.debug({
+              log16.debug({
                 graphExpanded: graphMemories.length,
                 linkedTotal: linked.length,
                 bondTypes: [...new Set(linked.map((l) => l.link_type))]
@@ -3341,7 +4889,7 @@ async function recallMemories(opts) {
           }
         }
       } catch (err) {
-        log10.debug({ err }, "Graph expansion skipped (RPC unavailable)");
+        log16.debug({ err }, "Graph expansion skipped (RPC unavailable)");
       }
     }
     if (results.length >= 3) {
@@ -3357,23 +4905,23 @@ async function recallMemories(opts) {
             ...results.slice(0, results.length - replaceCount),
             ...diverseCandidates.slice(0, replaceCount)
           ].sort((a, b) => b._score - a._score).slice(0, limit);
-          log10.debug({ injectedTypes: diverseCandidates.map((m) => m.memory_type) }, "Type diversity applied");
+          log16.debug({ injectedTypes: diverseCandidates.map((m) => m.memory_type) }, "Type diversity applied");
         }
       }
     }
-    const finalOwner = getOwnerWallet();
-    if (finalOwner) {
-      const beforeCount = results.length;
-      results = results.filter((m) => m.owner_wallet === finalOwner);
-      if (results.length < beforeCount) {
-        log10.warn({ stripped: beforeCount - results.length, owner: finalOwner }, "Owner guard stripped foreign memories from recall results");
+    const finalScope = getOwnerScope();
+    {
+      const { kept, stripped } = applyOwnerPostGuard(results, finalScope);
+      if (stripped > 0) {
+        log16.warn({ stripped, botOwn: finalScope === SCOPE_BOT_OWN2 }, "Owner guard stripped foreign memories from recall results");
       }
+      results = kept;
     }
-    if (opts.trackAccess !== false) {
+    if (shouldTrackAccess(opts)) {
       const ids = results.map((m) => m.id);
       const sources = results.map((m) => m.source || "");
-      updateMemoryAccess(ids, sources).catch((err) => log10.warn({ err }, "Memory access tracking failed"));
-      reinforceCoRetrievedLinks(ids).catch((err) => log10.debug({ err }, "Link reinforcement failed"));
+      updateMemoryAccess(ids, sources).catch((err) => log16.warn({ err }, "Memory access tracking failed"));
+      reinforceCoRetrievedLinks(ids).catch((err) => log16.debug({ err }, "Link reinforcement failed"));
     }
     for (const m of results) {
       const paths = linkPathMap.get(m.id);
@@ -3381,7 +4929,7 @@ async function recallMemories(opts) {
         m.link_path = [...paths];
       }
     }
-    log10.debug({
+    log16.debug({
       recalled: results.length,
       topScore: results[0]?._score?.toFixed(3),
       query: opts.query?.slice(0, 40),
@@ -3391,7 +4939,7 @@ async function recallMemories(opts) {
     }, "Memories recalled");
     return results;
   } catch (err) {
-    log10.error({ err }, "Memory recall failed");
+    log16.error({ err }, "Memory recall failed");
     return [];
   }
 }
@@ -3405,7 +4953,7 @@ function extractQueryTerms(query) {
 }
 function scoreMemory(mem, opts) {
   const now = Date.now();
-  const hoursSinceAccess = (now - new Date(mem.last_accessed).getTime()) / (1e3 * 60 * 60);
+  const hoursSinceAccess = Math.max(0, (now - new Date(mem.last_accessed).getTime()) / (1e3 * 60 * 60));
   const recency = Math.pow(RECENCY_DECAY_BASE, hoursSinceAccess);
   let textScore = 0.5;
   if (opts.query) {
@@ -3441,7 +4989,7 @@ function scoreMemory(mem, opts) {
   }
   const bm25Rank = opts._bm25Scores?.get(mem.id) || 0;
   if (bm25Rank > 0) {
-    rawScore += 0.15 * Math.min(bm25Rank, 1);
+    rawScore += RETRIEVAL_WEIGHT_BM25 * Math.min(bm25Rank, 1);
   }
   const typeBoost = KNOWLEDGE_TYPE_BOOST[mem.memory_type] || 0;
   rawScore += typeBoost;
@@ -3462,7 +5010,7 @@ async function recallMemorySummaries(opts) {
   const limit = opts.limit || 10;
   const minDecay = opts.minDecay ?? 0.1;
   try {
-    let query = db.from("memories").select("id, memory_type, summary, tags, concepts, importance, decay_factor, created_at, source").gte("decay_factor", minDecay).not("source", "in", '("demo","demo-maas")').order("importance", { ascending: false }).order("created_at", { ascending: false }).limit(limit);
+    let query = db.from("memories").select("id, memory_type, summary, tags, concepts, importance, decay_factor, created_at, source").gte("decay_factor", minDecay).not("source", "in", '("demo","demo-maas")').not("provider_delegated", "is", false).order("importance", { ascending: false }).order("created_at", { ascending: false }).limit(limit);
     query = scopeToOwner(query);
     if (opts.memoryTypes && opts.memoryTypes.length > 0) {
       query = query.in("memory_type", opts.memoryTypes);
@@ -3481,12 +5029,12 @@ async function recallMemorySummaries(opts) {
     }
     const { data, error } = await query;
     if (error) {
-      log10.error({ error: error.message }, "Memory summary recall failed");
+      log16.error({ error: error.message }, "Memory summary recall failed");
       return [];
     }
     return data || [];
   } catch (err) {
-    log10.error({ err }, "Memory summary recall failed");
+    log16.error({ err }, "Memory summary recall failed");
     return [];
   }
 }
@@ -3498,28 +5046,23 @@ async function hydrateMemories(ids) {
     query = scopeToOwner(query);
     const { data, error } = await query;
     if (error) {
-      log10.error({ error: error.message }, "Memory hydration failed");
+      log16.error({ error: error.message }, "Memory hydration failed");
       return [];
     }
-    return decryptMemoryBatch(data || []);
+    return await decryptMemories(data || []);
   } catch (err) {
-    log10.error({ err }, "Memory hydration failed");
+    log16.error({ err }, "Memory hydration failed");
     return [];
   }
 }
-async function updateMemoryAccess(ids, sources = []) {
+async function updateMemoryAccess(ids, _sources = []) {
   if (ids.length === 0) return;
   const db = getDb();
-  const importanceBoosts = ids.map((_, i) => {
-    const source = sources[i] || "";
-    return INTERNAL_MEMORY_SOURCES.has(source) ? INTERNAL_IMPORTANCE_BOOST : 0.02;
-  });
   const { error } = await db.rpc("batch_boost_memory_access", {
-    memory_ids: ids,
-    importance_boosts: importanceBoosts
+    memory_ids: ids
   });
   if (error) {
-    log10.warn({ error: error.message, ids }, "Batch memory access update failed");
+    log16.warn({ error: error.message, ids }, "Batch memory access update failed");
   }
 }
 async function createMemoryLink(sourceId, targetId, linkType, strength = 0.5) {
@@ -3532,7 +5075,7 @@ async function createMemoryLink(sourceId, targetId, linkType, strength = 0.5) {
     strength: clamp(strength, 0, 1)
   }, { onConflict: "source_id,target_id,link_type" });
   if (error) {
-    log10.debug({ error: error.message, sourceId, targetId, linkType }, "Link creation failed");
+    log16.debug({ error: error.message, sourceId, targetId, linkType }, "Link creation failed");
   }
 }
 async function createMemoryLinksBatch(links) {
@@ -3554,7 +5097,7 @@ async function createMemoryLinksBatch(links) {
   const db = getDb();
   const { error } = await db.from("memory_links").upsert(rows, { onConflict: "source_id,target_id,link_type" });
   if (error) {
-    log10.debug({ error: error.message, count: rows.length }, "Batch link creation failed");
+    log16.debug({ error: error.message, count: rows.length }, "Batch link creation failed");
   }
 }
 async function autoLinkMemory(memoryId, opts) {
@@ -3573,7 +5116,7 @@ async function autoLinkMemory(memoryId, opts) {
         query_embedding: JSON.stringify(embedding),
         match_threshold: LINK_SIMILARITY_THRESHOLD,
         match_count: MAX_AUTO_LINKS * 2,
-        filter_owner: getOwnerWallet() || null
+        filter_owner: getOwnerScope()
       });
       if (similar) {
         const similarIds = similar.map((s) => s.id).filter((id) => id !== memoryId);
@@ -3622,7 +5165,7 @@ async function autoLinkMemory(memoryId, opts) {
   }
   if (pendingLinks.length > 0) {
     await createMemoryLinksBatch(pendingLinks);
-    log10.debug({ memoryId, linksCreated: pendingLinks.length }, "Auto-linked memory");
+    log16.debug({ memoryId, linksCreated: pendingLinks.length }, "Auto-linked memory");
   }
 }
 function classifyLinkType(newMem, candidate, newConcepts) {
@@ -3644,16 +5187,16 @@ async function reinforceCoRetrievedLinks(ids) {
     boost_amount: LINK_CO_RETRIEVAL_BOOST
   });
   if (error) {
-    log10.debug({ error: error.message }, "Link reinforcement RPC failed");
+    log16.debug({ error: error.message }, "Link reinforcement RPC failed");
   } else if (data && data > 0) {
-    log10.debug({ boosted: data }, "Co-retrieval link reinforcement applied");
+    log16.debug({ boosted: data }, "Co-retrieval link reinforcement applied");
   }
 }
 async function extractAndLinkEntitiesForMemory(memoryId, opts) {
   try {
     await extractAndLinkEntities(memoryId, opts.content, opts.summary, opts.relatedUser);
   } catch (err) {
-    log10.debug({ err, memoryId }, "Entity extraction failed");
+    log16.debug({ err, memoryId }, "Entity extraction failed");
   }
 }
 async function decayMemories() {
@@ -3669,17 +5212,17 @@ async function decayMemories() {
         cutoff
       });
       if (error) {
-        log10.warn({ error: error.message, memType }, "Batch decay failed for type");
+        log16.warn({ error: error.message, memType }, "Batch decay failed for type");
         continue;
       }
       totalDecayed += data || 0;
     }
     if (totalDecayed > 0) {
-      log10.info({ decayed: totalDecayed }, "Type-specific memory decay applied");
+      log16.info({ decayed: totalDecayed }, "Type-specific memory decay applied");
     }
     return totalDecayed;
   } catch (err) {
-    log10.error({ err }, "Memory decay failed");
+    log16.error({ err }, "Memory decay failed");
     return 0;
   }
 }
@@ -3689,7 +5232,7 @@ async function deleteMemory(id) {
   query = scopeToOwner(query);
   const { error } = await query;
   if (error) {
-    log10.error({ error: error.message, id }, "Failed to delete memory");
+    log16.error({ error: error.message, id }, "Failed to delete memory");
     return false;
   }
   return true;
@@ -3707,7 +5250,7 @@ async function updateMemory(id, patches) {
   query = scopeToOwner(query);
   const { error } = await query;
   if (error) {
-    log10.error({ error: error.message, id }, "Failed to update memory");
+    log16.error({ error: error.message, id }, "Failed to update memory");
     return false;
   }
   return true;
@@ -3728,10 +5271,10 @@ async function listMemories(opts) {
   if (opts.min_importance !== void 0) dataQ = dataQ.gte("importance", opts.min_importance);
   const { data, error } = await dataQ;
   if (error) {
-    log10.error({ error: error.message }, "Failed to list memories");
+    log16.error({ error: error.message }, "Failed to list memories");
     return { memories: [], total: 0 };
   }
-  return { memories: decryptMemoryBatch(data || []), total: count ?? 0 };
+  return { memories: await decryptMemories(data || []), total: count ?? 0 };
 }
 async function getMemoryStats() {
   const db = getDb();
@@ -3768,7 +5311,7 @@ async function getMemoryStats() {
     const MAX_PAGES = 20;
     let allMemories = [];
     for (let page = 0; page < MAX_PAGES; page++) {
-      let pageQuery = db.from("memories").select("importance, decay_factor, created_at, related_user, tags, concepts").order("id", { ascending: true }).range(page * PAGE_SIZE, (page + 1) * PAGE_SIZE - 1);
+      let pageQuery = db.from("memories").select("importance, decay_factor, created_at, related_user, owner_wallet, tags, concepts").order("id", { ascending: true }).range(page * PAGE_SIZE, (page + 1) * PAGE_SIZE - 1);
       pageQuery = scopeToOwner(pageQuery);
       const { data: pageData } = await pageQuery;
       if (!pageData || pageData.length === 0) break;
@@ -3785,6 +5328,7 @@ async function getMemoryStats() {
         impSum += m.importance;
         decaySum += m.decay_factor;
         if (m.related_user) users.add(m.related_user);
+        if (m.owner_wallet) users.add(m.owner_wallet);
         if (m.tags) {
           for (const tag of m.tags) {
             tagCounts[tag] = (tagCounts[tag] || 0) + 1;
@@ -3805,13 +5349,15 @@ async function getMemoryStats() {
       stats.oldestMemory = sorted[0] || null;
       stats.newestMemory = sorted[sorted.length - 1] || null;
     }
-    const { count, error: dreamError } = await db.from("dream_logs").select("id", { count: "exact", head: true });
+    let dreamQuery = db.from("dream_logs").select("id", { count: "exact", head: true });
+    dreamQuery = scopeToOwner(dreamQuery);
+    const { count, error: dreamError } = await dreamQuery;
     if (dreamError) {
-      log10.warn({ error: dreamError.message }, "Failed to count dream logs");
+      log16.warn({ error: dreamError.message }, "Failed to count dream logs");
     }
     stats.totalDreamSessions = count || 0;
   } catch (err) {
-    log10.error({ err }, "Failed to get memory stats");
+    log16.error({ err }, "Failed to get memory stats");
   }
   return stats;
 }
@@ -3825,10 +5371,10 @@ async function getRecentMemories(hours, types, limit) {
   }
   const { data, error } = await query;
   if (error) {
-    log10.error({ error: error.message }, "Failed to get recent memories");
+    log16.error({ error: error.message }, "Failed to get recent memories");
     return [];
   }
-  return decryptMemoryBatch(data || []);
+  return await decryptMemories(data || []);
 }
 async function getSelfModel() {
   const db = getDb();
@@ -3836,10 +5382,10 @@ async function getSelfModel() {
   query = scopeToOwner(query);
   const { data, error } = await query;
   if (error) {
-    log10.error({ error: error.message }, "Failed to get self model");
+    log16.error({ error: error.message }, "Failed to get self model");
     return [];
   }
-  return decryptMemoryBatch(data || []);
+  return await decryptMemories(data || []);
 }
 async function storeDreamLog(sessionType, inputMemoryIds, output, newMemoryIds) {
   const db = getDb();
@@ -3847,54 +5393,48 @@ async function storeDreamLog(sessionType, inputMemoryIds, output, newMemoryIds)
     session_type: sessionType,
     input_memory_ids: inputMemoryIds,
     output: output.slice(0, MEMORY_MAX_CONTENT_LENGTH),
-    new_memories_created: newMemoryIds
+    new_memories_created: newMemoryIds,
+    // Stamp owner so getMemoryStats can scope the dream count (migration 021).
+    owner_wallet: getOwnerWallet() === SCOPE_BOT_OWN2 ? null : getOwnerWallet()
   });
   if (error) {
-    log10.error({ error: error.message }, "Failed to store dream log");
+    log16.error({ error: error.message }, "Failed to store dream log");
   }
 }
 function formatMemoryContext(memories) {
   if (memories.length === 0) return "";
   const lines = ["## Memory Recall"];
-  const episodic = memories.filter((m) => m.memory_type === "episodic");
-  const semantic = memories.filter((m) => m.memory_type === "semantic");
-  const procedural = memories.filter((m) => m.memory_type === "procedural");
-  const selfModel = memories.filter((m) => m.memory_type === "self_model");
-  const introspective = memories.filter((m) => m.memory_type === "introspective");
+  const episodic = memories.filter((m) => m.memory_type === "episodic").sort(byMemoryDateAsc);
+  const semantic = memories.filter((m) => m.memory_type === "semantic").sort(byMemoryDateAsc);
+  const procedural = memories.filter((m) => m.memory_type === "procedural").sort(byMemoryDateAsc);
+  const selfModel = memories.filter((m) => m.memory_type === "self_model").sort(byMemoryDateAsc);
+  const introspective = memories.filter((m) => m.memory_type === "introspective").sort(byMemoryDateAsc);
   if (episodic.length > 0) {
     lines.push("### Past Interactions");
-    for (const m of episodic) {
-      lines.push(`- [${timeAgo(m.created_at)}] ${m.summary}`);
-    }
+    for (const m of episodic) lines.push(renderGroundedLine(m));
   }
   if (semantic.length > 0) {
     lines.push("### Things You Know");
-    for (const m of semantic) {
-      lines.push(`- ${m.summary}`);
-    }
+    for (const m of semantic) lines.push(renderGroundedLine(m));
   }
   if (procedural.length > 0) {
     lines.push("### Learned Strategies (from past outcomes)");
     for (const m of procedural) {
       const meta = m.metadata;
       const confidence = meta?.positiveRate != null ? ` [${Math.round(meta.positiveRate * 100)}% success rate, based on ${meta.basedOn || "?"} interactions]` : "";
-      lines.push(`- ${m.summary}${confidence}`);
+      lines.push(renderGroundedLine(m, confidence));
     }
   }
   if (introspective.length > 0) {
     lines.push("### Your Own Reflections");
-    for (const m of introspective) {
-      lines.push(`- [${timeAgo(m.created_at)}] ${m.summary}`);
-    }
+    for (const m of introspective) lines.push(renderGroundedLine(m));
   }
   if (selfModel.length > 0) {
     lines.push("### Self-Observations");
-    for (const m of selfModel) {
-      lines.push(`- ${m.summary}`);
-    }
+    for (const m of selfModel) lines.push(renderGroundedLine(m));
   }
   lines.push("");
-  lines.push("You REMEMBER these interactions and facts. Reference them naturally if relevant.");
+  lines.push(CONTEXT_GROUNDING_RULES);
   if (procedural.length > 0) {
     lines.push("");
     lines.push("IMPORTANT: You MUST follow the Learned Strategies above. They are behavioral rules you derived from analyzing your own past successes and failures. Apply them to this response.");
@@ -3919,10 +5459,10 @@ async function scoreImportanceWithLLM(description, fallbackOpts) {
     if (!isNaN(parsed) && parsed >= 1 && parsed <= 10) {
       return parsed / 10;
     }
-    log10.warn({ response }, "LLM importance score unparseable, using fallback");
+    log16.warn({ response }, "LLM importance score unparseable, using fallback");
     return calculateImportance(fallbackOpts || {});
   } catch (err) {
-    log10.warn({ err }, "LLM importance scoring failed, using fallback");
+    log16.warn({ err }, "LLM importance scoring failed, using fallback");
     return calculateImportance(fallbackOpts || {});
   }
 }
@@ -3946,7 +5486,8 @@ async function matchByEmbedding(opts) {
     query_embedding: JSON.stringify(opts.embedding),
     match_threshold: opts.threshold,
     match_count: opts.limit,
-    filter_owner: opts.ownerWallet ?? null
+    // Explicit ownerWallet wins; otherwise the ambient scope (sentinel-aware, C0).
+    filter_owner: opts.ownerWallet ?? getOwnerScope()
   });
   return (data ?? []).map((r) => ({
     id: r.id,
@@ -3969,32 +5510,39 @@ function moodToValence(mood) {
       return 0;
   }
 }
-var import_crypto2, EMBED_CACHE_MAX, embeddingCache, _ownerWallet, SCOPE_BOT_OWN, HASH_ID_PREFIX, log10, DEDUP_TTL_MS, dedupCache, installedPacksCache, INSTALLED_PACKS_TTL_MS, topicEmbeddingCache, topicEmbeddingPopulationLock, TOKENISATION_SKIP_SOURCES, STOPWORDS;
+var import_crypto3, EMBED_CACHE_MAX, embeddingCache, _ownerWallet, SCOPE_BOT_OWN2, HASH_ID_PREFIX, log16, DEDUP_TTL_MS, dedupCache, installedPacksCache, INSTALLED_PACKS_TTL_MS, topicEmbeddingCache, topicEmbeddingPopulationLock, TOKENISATION_SKIP_SOURCES, outboxDegradeLogged, STOPWORDS, CONTEXT_GROUNDING_RULES;
 var init_memory = __esm({
   "packages/brain/src/memory/memory.ts"() {
     "use strict";
     init_database();
+    init_config();
     init_logger();
+    init_memory_grounding();
     init_utils();
     init_claude_client();
     init_solana_client();
     init_src();
     init_embeddings();
+    init_migration_profile();
     init_wiki_packs();
     init_config2();
     init_bm25_search();
+    init_content_tokens();
+    init_reconcile_shadow();
+    init_memory_encryption();
     init_openrouter_client();
     init_encryption();
+    init_memory_decryption();
     init_event_bus();
-    import_crypto2 = require("crypto");
+    import_crypto3 = require("crypto");
     init_graph();
     init_owner_context();
     EMBED_CACHE_MAX = 200;
     embeddingCache = /* @__PURE__ */ new Map();
     _ownerWallet = null;
-    SCOPE_BOT_OWN = "__BOT_OWN__";
+    SCOPE_BOT_OWN2 = "__BOT_OWN__";
     HASH_ID_PREFIX = "clude";
-    log10 = createChildLogger("memory");
+    log16 = createChildLogger("memory");
     DEDUP_TTL_MS = 10 * 60 * 1e3;
     dedupCache = /* @__PURE__ */ new Map();
     installedPacksCache = /* @__PURE__ */ new Map();
@@ -4007,6 +5555,7 @@ var init_memory = __esm({
       "locomo-benchmark",
       "longmemeval-benchmark"
     ]);
+    outboxDegradeLogged = false;
     STOPWORDS = /* @__PURE__ */ new Set([
       "the",
       "a",
@@ -4091,18 +5640,92 @@ var init_memory = __esm({
       "our",
       "their"
     ]);
+    CONTEXT_GROUNDING_RULES = `Ground specific claims \u2014 facts, preferences, history, dates, numbers, names \u2014 in the memories above; if a detail isn't written here, say you don't remember it rather than guessing. Each line is dated: when two memories disagree, read them as a timeline \u2014 use the most recent value for a question about now, and the value that was in effect at the time for a question about a specific past date ("as of \u2026"); never blend conflicting values. Don't invent memories or details that aren't above. General knowledge is unaffected \u2014 answer those normally.`;
+  }
+});
+
+// packages/brain/src/memory/memory-revoke.ts
+async function revokeMemory(db, memoryId) {
+  const { data: mem } = await db.from("memories").select("summary, embedding, encrypted, provider_delegated").eq("id", memoryId).maybeSingle();
+  if (!mem || mem.encrypted !== true || mem.provider_delegated === false) {
+    return { revoked: false, reason: "not_delegated" };
+  }
+  const { data: wrap } = await db.from("memory_dek_wraps").select("wrapped_dek, wrap_pubkey").eq("memory_id", memoryId).eq("recipient", "provider").maybeSingle();
+  if (!wrap) return { revoked: false, reason: "no_provider_wrap" };
+  let providerSecret;
+  try {
+    providerSecret = loadProviderKeypair().secretKey;
+  } catch {
+    return { revoked: false, reason: "no_provider_key" };
+  }
+  const dek = unwrapDek(wrap.wrapped_dek, wrap.wrap_pubkey, providerSecret);
+  if (!dek) return { revoked: false, reason: "unwrap_failed" };
+  const summaryCt = encryptField(String(mem.summary ?? ""), dek);
+  const embeddingCt = mem.embedding != null ? encryptField(String(mem.embedding), dek) : "";
+  const { error } = await db.rpc("revoke_memory", {
+    p_memory_id: memoryId,
+    p_summary_ct: summaryCt,
+    p_embedding_ct: embeddingCt
+  });
+  if (error) {
+    log17.error({ memoryId, error: error.message }, "revoke_memory RPC failed");
+    return { revoked: false, reason: "rpc_failed" };
+  }
+  log17.info({ memoryId }, "Memory revoked \u2014 provider access destroyed");
+  return { revoked: true };
+}
+async function redelegateMemory(db, memoryId, providerWrap) {
+  const { data: mem } = await db.from("memories").select("content, summary_ciphertext, embedding_ciphertext, encrypted").eq("id", memoryId).maybeSingle();
+  if (!mem || mem.encrypted !== true) return { redelegated: false, reason: "not_encrypted" };
+  let providerSecret;
+  try {
+    providerSecret = loadProviderKeypair().secretKey;
+  } catch {
+    return { redelegated: false, reason: "no_provider_key" };
+  }
+  const dek = unwrapDek(providerWrap.wrapped_dek, providerWrap.wrap_pubkey, providerSecret);
+  if (!dek) return { redelegated: false, reason: "invalid_wrap" };
+  const content = decryptField(String(mem.content ?? ""), dek);
+  if (content === null) return { redelegated: false, reason: "invalid_wrap" };
+  const summary = mem.summary_ciphertext ? decryptField(mem.summary_ciphertext, dek) : "";
+  const embedding = mem.embedding_ciphertext ? decryptField(mem.embedding_ciphertext, dek) : "";
+  const { error } = await db.rpc("redelegate_memory", {
+    p_memory_id: memoryId,
+    p_summary: summary ?? "",
+    p_embedding: embedding ?? "",
+    p_content: content,
+    p_wrapped_dek: providerWrap.wrapped_dek,
+    p_wrap_pubkey: providerWrap.wrap_pubkey
+  });
+  if (error) {
+    log17.error({ memoryId, error: error.message }, "redelegate_memory RPC failed");
+    return { redelegated: false, reason: "rpc_failed" };
+  }
+  log17.info({ memoryId }, "Memory re-delegated \u2014 provider access restored");
+  return { redelegated: true };
+}
+var log17;
+var init_memory_revoke = __esm({
+  "packages/brain/src/memory/memory-revoke.ts"() {
+    "use strict";
+    init_memory_envelope();
+    init_encryption_keys();
+    init_logger();
+    log17 = createChildLogger("memory-revoke");
   }
 });
 
 // packages/brain/src/memory/index.ts
 var memory_exports2 = {};
 __export(memory_exports2, {
-  SCOPE_BOT_OWN: () => SCOPE_BOT_OWN,
+  SCOPE_BOT_OWN: () => SCOPE_BOT_OWN2,
   _setOwnerWallet: () => _setOwnerWallet,
   calculateImportance: () => calculateImportance,
   createMemoryLink: () => createMemoryLink,
   createMemoryLinksBatch: () => createMemoryLinksBatch,
   decayMemories: () => decayMemories,
+  decryptMemories: () => decryptMemories,
+  decryptOneContent: () => decryptOneContent,
   deleteMemory: () => deleteMemory,
   formatMemoryContext: () => formatMemoryContext,
   generateHashId: () => generateHashId,
@@ -4118,6 +5741,8 @@ __export(memory_exports2, {
   moodToValence: () => moodToValence,
   recallMemories: () => recallMemories,
   recallMemorySummaries: () => recallMemorySummaries,
+  redelegateMemory: () => redelegateMemory,
+  revokeMemory: () => revokeMemory,
   scopeToOwner: () => scopeToOwner,
   scoreImportanceWithLLM: () => scoreImportanceWithLLM,
   scoreMemory: () => scoreMemory,
@@ -4129,6 +5754,8 @@ var init_memory2 = __esm({
   "packages/brain/src/memory/index.ts"() {
     "use strict";
     init_memory();
+    init_memory_decryption();
+    init_memory_revoke();
   }
 });
 
@@ -4258,7 +5885,7 @@ function shuffle(arr) {
 async function runDeepConnectionPhase(ownerWallet) {
   const SKIPPED = { linksCreated: 0, skipped: true, topLinks: [] };
   if (process.env.JEPA_ENABLED !== "true") {
-    log11.debug("JEPA disabled \u2014 skipping deep connection phase");
+    log18.debug("JEPA disabled \u2014 skipping deep connection phase");
     return SKIPPED;
   }
   const jepaClient = getJepaClient();
@@ -4281,16 +5908,16 @@ async function runDeepConnectionPhase(ownerWallet) {
     }
   }
   if (candidates.length === 0) {
-    log11.debug("No candidate memories \u2014 skipping deep connection phase");
+    log18.debug("No candidate memories \u2014 skipping deep connection phase");
     return SKIPPED;
   }
   const queriedRecently = await fetchJepaQueriedSince(Date.now() - TWENTY_FOUR_HOURS_MS);
   const toProcess = candidates.filter((m) => !queriedRecently.has(m.id));
   if (toProcess.length === 0) {
-    log11.debug("All candidates JEPA-queried in last 24 h \u2014 skipping");
+    log18.debug("All candidates JEPA-queried in last 24 h \u2014 skipping");
     return SKIPPED;
   }
-  log11.info({ total: candidates.length, toProcess: toProcess.length }, "Deep connection phase: processing memories");
+  log18.info({ total: candidates.length, toProcess: toProcess.length }, "Deep connection phase: processing memories");
   const allLinks = [];
   const topLinks = [];
   for (const mem of toProcess) {
@@ -4376,16 +6003,16 @@ async function runDeepConnectionPhase(ownerWallet) {
       new_memories_created: []
     });
   } catch (err) {
-    log11.warn({ err }, "Failed to write deep_connection dream log");
+    log18.warn({ err }, "Failed to write deep_connection dream log");
   }
-  log11.info({ linksCreated: allLinks.length, topLinks: topLinks.length }, "Deep connection phase complete");
+  log18.info({ linksCreated: allLinks.length, topLinks: topLinks.length }, "Deep connection phase complete");
   return {
     linksCreated: allLinks.length,
     skipped: false,
     topLinks
   };
 }
-var log11, TWENTY_FOUR_HOURS_MS, RECENT_SAMPLE, HIGH_IMPORTANCE_SAMPLE, HIGH_IMPORTANCE_THRESHOLD, EMBEDDING_SIMILARITY_THRESHOLD, MATCH_LIMIT, TOP_LINKS_PER_MEMORY, _jepaClient;
+var log18, TWENTY_FOUR_HOURS_MS, RECENT_SAMPLE, HIGH_IMPORTANCE_SAMPLE, HIGH_IMPORTANCE_THRESHOLD, EMBEDDING_SIMILARITY_THRESHOLD, MATCH_LIMIT, TOP_LINKS_PER_MEMORY, _jepaClient;
 var init_deep_connection = __esm({
   "packages/brain/src/memory/dream/deep-connection.ts"() {
     "use strict";
@@ -4393,7 +6020,7 @@ var init_deep_connection = __esm({
     init_logger();
     init_memory();
     init_jepa();
-    log11 = createChildLogger("dream-deep-connection");
+    log18 = createChildLogger("dream-deep-connection");
     TWENTY_FOUR_HOURS_MS = 24 * 60 * 60 * 1e3;
     RECENT_SAMPLE = 15;
     HIGH_IMPORTANCE_SAMPLE = 5;
@@ -4428,7 +6055,7 @@ async function throttlePost() {
   const elapsed = now - lastPostTime;
   if (elapsed < MIN_POST_GAP_MS) {
     const wait = MIN_POST_GAP_MS - elapsed;
-    log12.debug({ waitMs: wait }, "Throttling post");
+    log19.debug({ waitMs: wait }, "Throttling post");
     await new Promise((r) => setTimeout(r, wait));
   }
   lastPostTime = Date.now();
@@ -4440,7 +6067,7 @@ async function withRetry(fn) {
     if (err?.code === 429 || err?.data?.status === 429) {
       const retryAfter = Number(err?.rateLimit?.reset || 0) * 1e3 - Date.now();
       const wait = Math.max(retryAfter, 6e4);
-      log12.warn({ waitMs: wait }, "X API 429 \u2014 backing off");
+      log19.warn({ waitMs: wait }, "X API 429 \u2014 backing off");
       await new Promise((r) => setTimeout(r, wait));
       return fn();
     }
@@ -4461,20 +6088,20 @@ function smartTruncate(text, maxLength = MAX_TWEET_LENGTH) {
 }
 async function postReply(tweetId, text) {
   const truncated = smartTruncate(stripEmDashes(text));
-  log12.info({ tweetId, originalLength: text.length, length: truncated.length }, "Posting reply");
+  log19.info({ tweetId, originalLength: text.length, length: truncated.length }, "Posting reply");
   await throttlePost();
   const result = await withRetry(() => rwClient.v2.reply(truncated, tweetId));
   return result.data.id;
 }
 async function postTweet(text) {
   const truncated = smartTruncate(stripEmDashes(text));
-  log12.info({ originalLength: text.length, length: truncated.length }, "Posting tweet");
+  log19.info({ originalLength: text.length, length: truncated.length }, "Posting tweet");
   await throttlePost();
   const result = await withRetry(() => rwClient.v2.tweet(truncated));
   return result.data.id;
 }
 async function postThread(texts) {
-  log12.info({ count: texts.length }, "Posting thread");
+  log19.info({ count: texts.length }, "Posting thread");
   const tweetIds = [];
   let previousId;
   for (const text of texts) {
@@ -4528,7 +6155,7 @@ function getUsernameOrId(userId) {
   return _usernameCache.get(userId) || userId;
 }
 async function getMentions(sinceId) {
-  log12.debug({ sinceId }, "Fetching mentions");
+  log19.debug({ sinceId }, "Fetching mentions");
   const params = {
     "tweet.fields": "created_at,author_id,conversation_id,text",
     "expansions": "author_id",
@@ -4567,12 +6194,12 @@ async function getTweetWithContext(tweetId, depth = 3) {
     }
     return { tweet, parents };
   } catch (err) {
-    log12.warn({ tweetId, err }, "Failed to fetch tweet context");
+    log19.warn({ tweetId, err }, "Failed to fetch tweet context");
     return { tweet: { id: tweetId, text: "" }, parents: [] };
   }
 }
 async function searchHashtagTweets(sinceId, maxResults = 100) {
-  log12.info({ sinceId, maxResults }, "Searching campaign tweets");
+  log19.info({ sinceId, maxResults }, "Searching campaign tweets");
   try {
     const query = `(@${BOT_X_HANDLE} OR #CludeHackathon OR ($CLUDE (hackathon OR "10 days" OR "growing a brain" OR "blockchain brain"))) -is:retweet`;
     const params = {
@@ -4605,15 +6232,15 @@ async function searchHashtagTweets(sinceId, maxResults = 100) {
         } : void 0
       });
     }
-    log12.info({ found: tweets.length }, "Campaign tweet search complete");
+    log19.info({ found: tweets.length }, "Campaign tweet search complete");
     return tweets;
   } catch (err) {
-    log12.error({ err }, "Failed to search campaign tweets");
+    log19.error({ err }, "Failed to search campaign tweets");
     return [];
   }
 }
 async function searchTokenMentions(sinceId, maxResults = 50) {
-  log12.info({ sinceId, maxResults }, "Searching $CLUDE mentions");
+  log19.info({ sinceId, maxResults }, "Searching $CLUDE mentions");
   try {
     const query = `($CLUDE OR @${BOT_X_HANDLE}) -is:retweet`;
     const params = {
@@ -4646,15 +6273,15 @@ async function searchTokenMentions(sinceId, maxResults = 50) {
         } : void 0
       });
     }
-    log12.info({ found: tweets.length }, "Token mention search complete");
+    log19.info({ found: tweets.length }, "Token mention search complete");
     return tweets;
   } catch (err) {
-    log12.error({ err }, "Failed to search token mentions");
+    log19.error({ err }, "Failed to search token mentions");
     return [];
   }
 }
 async function getUserTweets(userId, sinceId, maxResults = 10) {
-  log12.debug({ userId, sinceId }, "Fetching user tweets");
+  log19.debug({ userId, sinceId }, "Fetching user tweets");
   try {
     const params = {
       "tweet.fields": "created_at,author_id,public_metrics",
@@ -4680,7 +6307,7 @@ async function getUserTweets(userId, sinceId, maxResults = 10) {
     }
     return tweets;
   } catch (err) {
-    log12.warn({ userId, err }, "Failed to fetch user tweets");
+    log19.warn({ userId, err }, "Failed to fetch user tweets");
     return [];
   }
 }
@@ -4707,7 +6334,7 @@ async function refreshTweetMetrics(tweetIds) {
         }
       }
     } catch (err) {
-      log12.warn({ err, batchSize: batch.length }, "Failed to refresh tweet metrics batch");
+      log19.warn({ err, batchSize: batch.length }, "Failed to refresh tweet metrics batch");
     }
   }
   return metricsMap;
@@ -4723,11 +6350,11 @@ async function getUserById(userId) {
     });
     return result.data;
   } catch (err) {
-    log12.warn({ userId, err }, "Failed to fetch user");
+    log19.warn({ userId, err }, "Failed to fetch user");
     return null;
   }
 }
-var import_twitter_api_v2, log12, client, rwClient, MIN_POST_GAP_MS, lastPostTime, MAX_TWEET_LENGTH, _usernameCache;
+var import_twitter_api_v2, log19, client, rwClient, MIN_POST_GAP_MS, lastPostTime, MAX_TWEET_LENGTH, _usernameCache;
 var init_x_client = __esm({
   "packages/shared/src/core/x-client.ts"() {
     "use strict";
@@ -4735,7 +6362,7 @@ var init_x_client = __esm({
     init_config();
     init_logger();
     init_constants();
-    log12 = createChildLogger("x-client");
+    log19 = createChildLogger("x-client");
     client = new import_twitter_api_v2.TwitterApi({
       appKey: config.x.apiKey,
       appSecret: config.x.apiSecret,
@@ -4781,10 +6408,10 @@ Trigger: "${record.trigger.slice(0, 200)}"` : "");
         ...record.metadata
       }
     });
-    log13.info({ actionId: record.actionId, feature: record.feature, memoryId }, "Action logged");
+    log20.info({ actionId: record.actionId, feature: record.feature, memoryId }, "Action logged");
     return memoryId;
   } catch (err) {
-    log13.error({ err, actionId: record.actionId }, "Failed to log action");
+    log20.error({ err, actionId: record.actionId }, "Failed to log action");
     return null;
   }
 }
@@ -4814,10 +6441,10 @@ Original action: ${record.actionId}`;
       }
     });
     await updateActionImportance(record.actionId, record.sentiment);
-    log13.info({ actionId: record.actionId, sentiment: record.sentiment, memoryId }, "Outcome logged");
+    log20.info({ actionId: record.actionId, sentiment: record.sentiment, memoryId }, "Outcome logged");
     return memoryId;
   } catch (err) {
-    log13.error({ err, actionId: record.actionId }, "Failed to log outcome");
+    log20.error({ err, actionId: record.actionId }, "Failed to log outcome");
     return null;
   }
 }
@@ -4835,9 +6462,9 @@ async function updateActionImportance(actionId, sentiment) {
     tags.push(`outcome:${sentiment}`);
     const newImportance = sentiment === "positive" ? Math.min(1, currentImportance + 0.15) : sentiment === "negative" ? Math.min(1, currentImportance + 0.2) : currentImportance;
     await db.from("memories").update({ importance: newImportance, tags }).eq("id", mem.id);
-    log13.debug({ actionId, oldImportance: currentImportance, newImportance }, "Action importance updated");
+    log20.debug({ actionId, oldImportance: currentImportance, newImportance }, "Action importance updated");
   } catch (err) {
-    log13.error({ err, actionId }, "Failed to update action importance");
+    log20.error({ err, actionId }, "Failed to update action importance");
   }
 }
 async function refineStrategies() {
@@ -4850,7 +6477,7 @@ async function refineStrategies() {
     if (ownerWallet) recentQuery = recentQuery.eq("owner_wallet", ownerWallet);
     const { data: recentActions } = await recentQuery;
     if (!recentActions || recentActions.length === 0) {
-      log13.debug("No recent actions to analyze");
+      log20.debug("No recent actions to analyze");
       return lessons;
     }
     const withOutcome = recentActions.filter(
@@ -4863,7 +6490,7 @@ async function refineStrategies() {
       (m) => (m.tags || []).includes("outcome:negative")
     );
     if (withOutcome.length < 3) {
-      log13.debug({ total: recentActions.length, withOutcome: withOutcome.length }, "Not enough outcome data for strategy refinement");
+      log20.debug({ total: recentActions.length, withOutcome: withOutcome.length }, "Not enough outcome data for strategy refinement");
       return lessons;
     }
     const byFeature = /* @__PURE__ */ new Map();
@@ -4908,7 +6535,7 @@ async function refineStrategies() {
           }
         });
         lessons.push(lesson);
-        log13.info({ feature, lesson: lesson.slice(0, 100) }, "New strategy learned");
+        log20.info({ feature, lesson: lesson.slice(0, 100) }, "New strategy learned");
       }
     }
     if (positive.length > 0) {
@@ -4916,7 +6543,7 @@ async function refineStrategies() {
     }
     return lessons;
   } catch (err) {
-    log13.error({ err }, "Strategy refinement failed");
+    log20.error({ err }, "Strategy refinement failed");
     return lessons;
   }
 }
@@ -4940,7 +6567,7 @@ Write a concise procedural rule (1-2 sentences) that captures this successful st
     });
     return response.trim();
   } catch (err) {
-    log13.error({ err, feature }, "Failed to generate lesson");
+    log20.error({ err, feature }, "Failed to generate lesson");
     return null;
   }
 }
@@ -4962,11 +6589,11 @@ async function reinforceSuccessfulStrategies(positiveActions) {
       if (relevantPositive.length > 0) {
         const newImportance = Math.min(1, (strategy.importance || 0.5) + 0.05 * relevantPositive.length);
         await db.from("memories").update({ importance: newImportance, access_count: (strategy.access_count || 0) + 1 }).eq("id", strategy.id);
-        log13.debug({ strategyId: strategy.id, feature, boost: relevantPositive.length }, "Strategy reinforced");
+        log20.debug({ strategyId: strategy.id, feature, boost: relevantPositive.length }, "Strategy reinforced");
       }
     }
   } catch (err) {
-    log13.error({ err }, "Failed to reinforce strategies");
+    log20.error({ err }, "Failed to reinforce strategies");
   }
 }
 async function trackSocialOutcomes() {
@@ -5020,16 +6647,16 @@ async function trackSocialOutcomes() {
           tracked++;
         }
       } catch {
-        log13.debug({ replyId }, "Could not fetch tweet metrics");
+        log20.debug({ replyId }, "Could not fetch tweet metrics");
       }
     }
-    log13.info({ tracked }, "Social outcomes tracked");
+    log20.info({ tracked }, "Social outcomes tracked");
   } catch (err) {
-    log13.error({ err }, "Social outcome tracking failed");
+    log20.error({ err }, "Social outcome tracking failed");
   }
   return tracked;
 }
-var log13;
+var log20;
 var init_action_learning = __esm({
   "packages/brain/src/memory/action-learning.ts"() {
     "use strict";
@@ -5037,7 +6664,7 @@ var init_action_learning = __esm({
     init_logger();
     init_database();
     init_claude_client();
-    log13 = createChildLogger("action-learning");
+    log20 = createChildLogger("action-learning");
   }
 });
 
@@ -5064,7 +6691,7 @@ function accumulateImportance(importance) {
   const timeSinceLastReflection = Date.now() - lastReflectionTime;
   const pastMinInterval = timeSinceLastReflection >= REFLECTION_MIN_INTERVAL_MS;
   if (importanceAccumulator >= REFLECTION_IMPORTANCE_THRESHOLD && pastMinInterval && !reflectionInProgress) {
-    log14.info({
+    log21.info({
       accumulator: importanceAccumulator.toFixed(2),
       threshold: REFLECTION_IMPORTANCE_THRESHOLD,
       minutesSinceLast: Math.round(timeSinceLastReflection / 6e4)
@@ -5074,7 +6701,7 @@ function accumulateImportance(importance) {
       try {
         await triggerReflection();
       } catch (err) {
-        log14.error({ err }, "Event-driven reflection failed");
+        log21.error({ err }, "Event-driven reflection failed");
       }
     });
   }
@@ -5082,7 +6709,7 @@ function accumulateImportance(importance) {
 async function triggerReflection() {
   reflectionInProgress = true;
   try {
-    log14.info({ accumulator: importanceAccumulator.toFixed(2) }, "=== DREAM CYCLE TRIGGERED ===");
+    log21.info({ accumulator: importanceAccumulator.toFixed(2) }, "=== DREAM CYCLE TRIGGERED ===");
     await Promise.race([
       (async () => {
         await runConsolidation();
@@ -5097,9 +6724,9 @@ async function triggerReflection() {
         await sleep(3e3);
         try {
           const deepResult = await runDeepConnectionPhase();
-          log14.info({ linksCreated: deepResult.linksCreated }, "JEPA deep connection complete");
+          log21.info({ linksCreated: deepResult.linksCreated }, "JEPA deep connection complete");
         } catch (err) {
-          log14.warn({ err }, "JEPA deep connection phase failed, continuing");
+          log21.warn({ err }, "JEPA deep connection phase failed, continuing");
         }
         await sleep(3e3);
         await runEmergence();
@@ -5111,9 +6738,9 @@ async function triggerReflection() {
     importanceAccumulator = 0;
     lastReflectionTime = Date.now();
     await saveAccumulator();
-    log14.info("=== DREAM CYCLE COMPLETE ===");
+    log21.info("=== DREAM CYCLE COMPLETE ===");
   } catch (err) {
-    log14.error({ err }, "Dream cycle failed or timed out");
+    log21.error({ err }, "Dream cycle failed or timed out");
   } finally {
     reflectionInProgress = false;
   }
@@ -5125,7 +6752,7 @@ async function loadAccumulator() {
     if (data) {
       importanceAccumulator = (data.count || 0) / 100;
       lastReflectionTime = new Date(data.window_start).getTime();
-      log14.debug({
+      log21.debug({
         accumulator: importanceAccumulator.toFixed(2),
         lastReflection: new Date(lastReflectionTime).toISOString()
       }, "Loaded reflection accumulator");
@@ -5142,7 +6769,7 @@ async function saveAccumulator() {
       window_start: new Date(lastReflectionTime).toISOString()
     });
   } catch (err) {
-    log14.warn({ err }, "Failed to save reflection accumulator");
+    log21.warn({ err }, "Failed to save reflection accumulator");
   }
 }
 function parseEvidenceCitations(text, sourceMemories) {
@@ -5186,14 +6813,14 @@ ${memoryDump}`,
   return response.split("\n").map((l) => l.trim()).filter((l) => l.length > 10 && l.includes("?")).slice(0, 3);
 }
 async function runConsolidation() {
-  log14.info("Dream phase 1: CONSOLIDATION starting");
+  log21.info("Dream phase 1: CONSOLIDATION starting");
   const recentSummaries = await recallMemorySummaries({
     memoryTypes: ["episodic"],
     limit: 20,
     trackAccess: false
   });
   if (recentSummaries.length < 3) {
-    log14.info({ count: recentSummaries.length }, "Too few recent memories for consolidation");
+    log21.info({ count: recentSummaries.length }, "Too few recent memories for consolidation");
     return;
   }
   const recentEpisodic = await getRecentMemories(6, ["episodic"], 20);
@@ -5201,14 +6828,14 @@ async function runConsolidation() {
   try {
     focalPoints = await generateFocalPoints(recentEpisodic);
   } catch (err) {
-    log14.warn({ err }, "Focal point generation failed, using direct consolidation");
+    log21.warn({ err }, "Focal point generation failed, using direct consolidation");
     focalPoints = [];
   }
   if (focalPoints.length === 0) {
     await runDirectConsolidation(recentEpisodic);
     return;
   }
-  log14.info({ focalPoints }, "Focal points generated");
+  log21.info({ focalPoints }, "Focal points generated");
   const allNewIds = [];
   const allInputIds = new Set(recentEpisodic.map((m) => m.id));
   for (const question of focalPoints) {
@@ -5233,7 +6860,7 @@ ${numberedMemories}`,
     });
     const { text, evidenceIds } = parseEvidenceCitations(response, relevant);
     if (isCopoutResponse(text)) {
-      log14.warn({ question }, "Consolidation produced cop-out response \u2014 discarding");
+      log21.warn({ question }, "Consolidation produced cop-out response \u2014 discarding");
       continue;
     }
     const id = await storeMemory({
@@ -5264,7 +6891,7 @@ Semantic insights: ${allNewIds.length - proceduralIds.length}
 Procedural patterns: ${proceduralIds.length}`,
     allNewIds
   );
-  log14.info({ focalPoints: focalPoints.length, insights: allNewIds.length, procedural: proceduralIds.length }, "Focal-point consolidation complete");
+  log21.info({ focalPoints: focalPoints.length, insights: allNewIds.length, procedural: proceduralIds.length }, "Focal-point consolidation complete");
 }
 async function runDirectConsolidation(recentEpisodic) {
   const memoryDump = recentEpisodic.map(
@@ -5285,7 +6912,7 @@ Total interactions: ${recentEpisodic.length}`,
   for (const obs of observations.slice(0, 3)) {
     const { text, evidenceIds } = parseEvidenceCitations(obs, recentEpisodic);
     if (isCopoutResponse(text)) {
-      log14.warn("Direct consolidation produced cop-out response \u2014 discarding");
+      log21.warn("Direct consolidation produced cop-out response \u2014 discarding");
       continue;
     }
     const id = await storeMemory({
@@ -5308,24 +6935,24 @@ Total interactions: ${recentEpisodic.length}`,
     response,
     newIds
   );
-  log14.info({ observations: newIds.length, procedural: proceduralIds.length }, "Direct consolidation complete");
+  log21.info({ observations: newIds.length, procedural: proceduralIds.length }, "Direct consolidation complete");
 }
 async function runCompaction() {
-  log14.info("Dream phase 1.5: COMPACTION starting");
+  log21.info("Dream phase 1.5: COMPACTION starting");
   const db = getDb();
   let compactionQuery = db.from("memories").select("id, hash_id, memory_type, summary, tags, concepts, importance, decay_factor, created_at").eq("memory_type", "episodic").eq("compacted", false).lt("decay_factor", 0.3).lt("importance", 0.5).lt("created_at", new Date(Date.now() - 7 * 24 * 60 * 60 * 1e3).toISOString()).order("created_at", { ascending: true }).limit(30);
   const ownerWallet = getOwnerWallet();
   if (ownerWallet) compactionQuery = compactionQuery.eq("owner_wallet", ownerWallet);
   const { data: candidates, error } = await compactionQuery;
   if (error) {
-    log14.error({ error: error.message }, "Failed to fetch compaction candidates");
+    log21.error({ error: error.message }, "Failed to fetch compaction candidates");
     return;
   }
   if (!candidates || candidates.length < 5) {
-    log14.debug({ count: candidates?.length || 0 }, "Too few candidates for compaction");
+    log21.debug({ count: candidates?.length || 0 }, "Too few candidates for compaction");
     return;
   }
-  log14.info({ count: candidates.length }, "Found compaction candidates");
+  log21.info({ count: candidates.length }, "Found compaction candidates");
   const groups = /* @__PURE__ */ new Map();
   for (const mem of candidates) {
     const concept = mem.concepts?.[0] || "general";
@@ -5369,10 +6996,10 @@ ${memoryDump}`,
           });
         }
         compactedCount += memories.length;
-        log14.debug({ concept, count: memories.length }, "Memory group compacted");
+        log21.debug({ concept, count: memories.length }, "Memory group compacted");
       }
     } catch (err) {
-      log14.warn({ err, concept }, "Failed to compact memory group");
+      log21.warn({ err, concept }, "Failed to compact memory group");
     }
   }
   if (compactedCount > 0) {
@@ -5383,10 +7010,10 @@ ${memoryDump}`,
       summaryIds
     );
   }
-  log14.info({ compacted: compactedCount, summaries: summaryIds.length }, "Compaction complete");
+  log21.info({ compacted: compactedCount, summaries: summaryIds.length }, "Compaction complete");
 }
 async function runReflection() {
-  log14.info("Dream phase 2: REFLECTION starting");
+  log21.info("Dream phase 2: REFLECTION starting");
   const selfModel = await getSelfModel();
   const recentSemantic = await getRecentMemories(48, ["semantic"], 10);
   const stats = await getMemoryStats();
@@ -5409,7 +7036,7 @@ async function runReflection() {
   });
   const { text, evidenceIds } = parseEvidenceCitations(response, allInputMemories);
   if (isCopoutResponse(text)) {
-    log14.warn("Reflection produced cop-out response \u2014 discarding");
+    log21.warn("Reflection produced cop-out response \u2014 discarding");
     await storeDreamLog("reflection", allInputMemories.map((m) => m.id), "(discarded \u2014 cop-out)", []);
     return;
   }
@@ -5441,10 +7068,10 @@ async function runReflection() {
     response,
     id ? [id] : []
   );
-  log14.info({ evidenceCount: evidenceIds.length }, "Reflection complete (progressive disclosure enabled)");
+  log21.info({ evidenceCount: evidenceIds.length }, "Reflection complete (progressive disclosure enabled)");
 }
 async function runContradictionResolution() {
-  log14.info("Dream phase 2.5: CONTRADICTION RESOLUTION starting");
+  log21.info("Dream phase 2.5: CONTRADICTION RESOLUTION starting");
   const db = getDb();
   let pairs;
   try {
@@ -5453,22 +7080,22 @@ async function runContradictionResolution() {
       filter_owner: getOwnerWallet() || null
     });
     if (error || !data || data.length === 0) {
-      log14.debug({ error: error?.message }, "No unresolved contradictions found \u2014 skipping phase");
+      log21.debug({ error: error?.message }, "No unresolved contradictions found \u2014 skipping phase");
       return;
     }
     pairs = data;
   } catch (err) {
-    log14.debug({ err }, "Contradiction resolution skipped (RPC unavailable)");
+    log21.debug({ err }, "Contradiction resolution skipped (RPC unavailable)");
     return;
   }
-  log14.info({ pairCount: pairs.length }, "Found unresolved contradictions");
+  log21.info({ pairCount: pairs.length }, "Found unresolved contradictions");
   const allIds = [...new Set(pairs.flatMap((p) => [p.source_id, p.target_id]))];
   let memFetchQuery = db.from("memories").select("*").in("id", allIds);
   const ownerWallet = getOwnerWallet();
   if (ownerWallet) memFetchQuery = memFetchQuery.eq("owner_wallet", ownerWallet);
   const { data: memories } = await memFetchQuery;
   if (!memories || memories.length === 0) {
-    log14.warn("Could not fetch contradiction memories \u2014 skipping phase");
+    log21.warn("Could not fetch contradiction memories \u2014 skipping phase");
     return;
   }
   const memoryMap = new Map(memories.map((m) => [m.id, m]));
@@ -5496,7 +7123,7 @@ ${numberedContext}`,
     });
     const { text, evidenceIds } = parseEvidenceCitations(response, sourceMemories);
     if (isCopoutResponse(text)) {
-      log14.warn({ memA: memA.id, memB: memB.id }, "Contradiction resolution produced cop-out \u2014 skipping pair");
+      log21.warn({ memA: memA.id, memB: memB.id }, "Contradiction resolution produced cop-out \u2014 skipping pair");
       continue;
     }
     outputs.push(text);
@@ -5520,9 +7147,9 @@ ${numberedContext}`,
       const newDecay = Math.max(0.05, weaker.decay_factor * 0.8);
       const { error: decayErr } = await db.from("memories").update({ decay_factor: newDecay }).eq("id", weaker.id);
       if (!decayErr) {
-        log14.debug({ memoryId: weaker.id, newDecay: newDecay.toFixed(3) }, "Accelerated decay on weaker contradicting memory");
+        log21.debug({ memoryId: weaker.id, newDecay: newDecay.toFixed(3) }, "Accelerated decay on weaker contradicting memory");
       } else {
-        log14.warn({ error: decayErr.message, memoryId: weaker.id }, "Failed to accelerate decay on contradicting memory");
+        log21.warn({ error: decayErr.message, memoryId: weaker.id }, "Failed to accelerate decay on contradicting memory");
       }
     }
   }
@@ -5534,29 +7161,29 @@ ${numberedContext}`,
       newMemoryIds
     );
   }
-  log14.info({ resolved: outputs.length, skipped: pairs.length - outputs.length }, "Contradiction resolution complete");
+  log21.info({ resolved: outputs.length, skipped: pairs.length - outputs.length }, "Contradiction resolution complete");
 }
 async function runLearning() {
-  log14.info("--- Learning phase: tracking outcomes & refining strategies ---");
+  log21.info("--- Learning phase: tracking outcomes & refining strategies ---");
   try {
     const { trackSocialOutcomes: trackSocialOutcomes2, refineStrategies: refineStrategies2 } = await Promise.resolve().then(() => (init_action_learning(), action_learning_exports));
     const tracked = await trackSocialOutcomes2();
     if (tracked > 0) {
-      log14.info({ tracked }, "Social outcomes tracked");
+      log21.info({ tracked }, "Social outcomes tracked");
     }
     const lessons = await refineStrategies2();
     if (lessons.length > 0) {
-      log14.info({ lessons: lessons.length }, "New strategies learned");
+      log21.info({ lessons: lessons.length }, "New strategies learned");
       for (const lesson of lessons) {
-        log14.info({ lesson: lesson.slice(0, 150) }, "Learned strategy");
+        log21.info({ lesson: lesson.slice(0, 150) }, "Learned strategy");
       }
     }
   } catch (err) {
-    log14.error({ err }, "Learning phase failed");
+    log21.error({ err }, "Learning phase failed");
   }
 }
 async function runEmergence() {
-  log14.info("Dream phase 3: EMERGENCE starting");
+  log21.info("Dream phase 3: EMERGENCE starting");
   const selfModel = await getSelfModel();
   const stats = await getMemoryStats();
   const randomMemories = await getRecentMemories(168, ["episodic"], 30);
@@ -5604,9 +7231,9 @@ async function runEmergence() {
   if (_emergenceHandler) {
     try {
       await _emergenceHandler(response);
-      log14.info("Emergence thought sent to SDK handler");
+      log21.info("Emergence thought sent to SDK handler");
     } catch (err) {
-      log14.error({ err }, "SDK emergence handler failed");
+      log21.error({ err }, "SDK emergence handler failed");
     }
   } else {
     const canPost = await checkRateLimit("global:emergence-tweet", 1, 720);
@@ -5614,15 +7241,15 @@ async function runEmergence() {
       try {
         const { postTweet: postTweet2 } = (init_x_client(), __toCommonJS(x_client_exports));
         await postTweet2(response);
-        log14.info("Emergence thought posted to X");
+        log21.info("Emergence thought posted to X");
       } catch (err) {
-        log14.error({ err }, "Failed to post emergence thought");
+        log21.error({ err }, "Failed to post emergence thought");
       }
     } else if (!hasDepth) {
-      log14.debug({ selfModelCount: selfModel.length }, "Emergence not deep enough to post \u2014 skipping tweet");
+      log21.debug({ selfModelCount: selfModel.length }, "Emergence not deep enough to post \u2014 skipping tweet");
     }
   }
-  log14.info("Emergence complete");
+  log21.info("Emergence complete");
 }
 async function extractProceduralInsights(recentEpisodic) {
   if (recentEpisodic.length < 3) return [];
@@ -5643,7 +7270,7 @@ ${numberedMemories}`,
     for (const pattern of patterns.slice(0, 2)) {
       const { text, evidenceIds } = parseEvidenceCitations(pattern, recentEpisodic);
       if (isCopoutResponse(text)) {
-        log14.warn("Procedural extraction produced cop-out response \u2014 discarding");
+        log21.warn("Procedural extraction produced cop-out response \u2014 discarding");
         continue;
       }
       const id = await storeMemory({
@@ -5658,10 +7285,10 @@ ${numberedMemories}`,
       });
       if (id) newIds.push(id);
     }
-    log14.info({ count: newIds.length }, "Procedural insights extracted");
+    log21.info({ count: newIds.length }, "Procedural insights extracted");
     return newIds;
   } catch (err) {
-    log14.warn({ err }, "Procedural extraction failed");
+    log21.warn({ err }, "Procedural extraction failed");
     return [];
   }
 }
@@ -5688,33 +7315,33 @@ function buildReflectionStats(stats) {
   return lines.join("\n");
 }
 async function startDreamCycle() {
-  log14.info("Starting dream cycle scheduler");
+  log21.info("Starting dream cycle scheduler");
   await loadAccumulator();
   const cron = require("node-cron");
   dreamCron = cron.schedule("0 */6 * * *", async () => {
     if (reflectionInProgress) {
-      log14.info("Scheduled dream cycle skipped \u2014 reflection already in progress");
+      log21.info("Scheduled dream cycle skipped \u2014 reflection already in progress");
       return;
     }
-    log14.info({
+    log21.info({
       accumulator: importanceAccumulator.toFixed(2)
     }, "=== SCHEDULED DREAM CYCLE (6h fallback) ===");
     await triggerReflection();
   });
   decayCron = cron.schedule("0 3 * * *", async () => {
-    log14.info("Running memory decay");
+    log21.info("Running memory decay");
     try {
       await decayMemories();
     } catch (err) {
-      log14.error({ err }, "Memory decay failed");
+      log21.error({ err }, "Memory decay failed");
     }
   });
   setTimeout(async () => {
-    log14.info("Running initial dream cycle");
+    log21.info("Running initial dream cycle");
     try {
       await triggerReflection();
     } catch (err) {
-      log14.error({ err }, "Initial dream cycle failed");
+      log21.error({ err }, "Initial dream cycle failed");
     }
   }, 12e4);
 }
@@ -5727,12 +7354,12 @@ function stopDreamCycle() {
     decayCron.stop();
     decayCron = null;
   }
-  log14.info("Dream cycle stopped");
+  log21.info("Dream cycle stopped");
 }
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
-var log14, COPOUT_PATTERNS, importanceAccumulator, lastReflectionTime, reflectionInProgress, REFLECTION_TIMEOUT_MS, _emergenceHandler, dreamCron, decayCron;
+var log21, COPOUT_PATTERNS, importanceAccumulator, lastReflectionTime, reflectionInProgress, REFLECTION_TIMEOUT_MS, _emergenceHandler, dreamCron, decayCron;
 var init_cycle = __esm({
   "packages/brain/src/memory/dream/cycle.ts"() {
     "use strict";
@@ -5744,7 +7371,7 @@ var init_cycle = __esm({
     init_constants();
     init_format();
     init_deep_connection();
-    log14 = createChildLogger("dream-cycle");
+    log21 = createChildLogger("dream-cycle");
     COPOUT_PATTERNS = [
       /^good question/i,
       /^let me think about that/i,
@@ -5769,7 +7396,7 @@ async function findClinamen(opts) {
   const limit = opts.limit || DEFAULT_LIMIT;
   const minImportance = opts.minImportance ?? MIN_IMPORTANCE;
   const maxRelevance = opts.maxRelevance ?? MAX_RELEVANCE_SIM;
-  log15.debug({ context: opts.context.slice(0, 60), limit }, "Searching for clinamen");
+  log22.debug({ context: opts.context.slice(0, 60), limit }, "Searching for clinamen");
   let contextEmbedding = null;
   if (isEmbeddingEnabled()) {
     const cached = getCachedEmbedding(opts.context);
@@ -5781,7 +7408,7 @@ async function findClinamen(opts) {
     }
   }
   if (!contextEmbedding) {
-    log15.debug("No embedding available \u2014 falling back to importance-only clinamen");
+    log22.debug("No embedding available \u2014 falling back to importance-only clinamen");
     return importanceOnlyClinamen(db, limit, minImportance, opts.memoryTypes);
   }
   const cutoff = new Date(Date.now() - MIN_AGE_HOURS * 60 * 60 * 1e3).toISOString();
@@ -5792,7 +7419,7 @@ async function findClinamen(opts) {
   }
   const { data: candidates, error } = await query;
   if (error || !candidates || candidates.length === 0) {
-    log15.debug({ error: error?.message }, "No clinamen candidates found");
+    log22.debug({ error: error?.message }, "No clinamen candidates found");
     return [];
   }
   const scored = [];
@@ -5818,7 +7445,7 @@ async function findClinamen(opts) {
   }
   scored.sort((a, b) => b._divergence - a._divergence);
   const results = scored.slice(0, limit);
-  log15.info({
+  log22.info({
     candidates: candidates.length,
     afterFilter: scored.length,
     returned: results.length,
@@ -5844,7 +7471,7 @@ async function importanceOnlyClinamen(db, limit, minImportance, memoryTypes) {
     _relevanceSim: 0
   }));
 }
-var log15, MIN_IMPORTANCE, MAX_RELEVANCE_SIM, MIN_AGE_HOURS, CANDIDATE_POOL_SIZE, DEFAULT_LIMIT;
+var log22, MIN_IMPORTANCE, MAX_RELEVANCE_SIM, MIN_AGE_HOURS, CANDIDATE_POOL_SIZE, DEFAULT_LIMIT;
 var init_clinamen = __esm({
   "packages/brain/src/memory/clinamen.ts"() {
     "use strict";
@@ -5852,7 +7479,7 @@ var init_clinamen = __esm({
     init_memory();
     init_embeddings();
     init_logger();
-    log15 = createChildLogger("clinamen");
+    log22 = createChildLogger("clinamen");
     MIN_IMPORTANCE = 0.6;
     MAX_RELEVANCE_SIM = 0.35;
     MIN_AGE_HOURS = 24;
@@ -5888,13 +7515,13 @@ async function selectSeeds() {
       memoryTypes: ["episodic", "semantic", "procedural"]
     });
     if (clinamenMemories.length > 0) {
-      log16.info({
+      log23.info({
         count: clinamenMemories.length,
         summaries: clinamenMemories.map((m) => m.summary.slice(0, 40))
       }, "Clinamen seeds selected (anomaly retrieval)");
     }
   } catch (err) {
-    log16.debug({ err }, "Clinamen retrieval failed \u2014 falling back to random");
+    log23.debug({ err }, "Clinamen retrieval failed \u2014 falling back to random");
     const older = await getRecentMemories(720, ["episodic", "semantic", "procedural"], 50);
     if (older.length > 0) {
       clinamenMemories = [older[Math.floor(Math.random() * older.length)]];
@@ -5927,18 +7554,18 @@ ${summaries}`,
 }
 async function runActiveReflection() {
   if (reflectionInProgress2) {
-    log16.info("Active reflection already in progress \u2014 skipping");
+    log23.info("Active reflection already in progress \u2014 skipping");
     return null;
   }
   reflectionInProgress2 = true;
   try {
-    log16.info("=== ACTIVE REFLECTION STARTING ===");
+    log23.info("=== ACTIVE REFLECTION STARTING ===");
     const { seeds, theme } = await selectSeeds();
     if (seeds.length < MIN_MEMORIES_FOR_REFLECTION) {
-      log16.info({ count: seeds.length }, "Too few memories for reflection \u2014 skipping");
+      log23.info({ count: seeds.length }, "Too few memories for reflection \u2014 skipping");
       return null;
     }
-    log16.info({ seedCount: seeds.length, theme }, "Reflection seeds selected");
+    log23.info({ seedCount: seeds.length, theme }, "Reflection seeds selected");
     const selfModel = await getSelfModel();
     const stats = await getMemoryStats();
     const previousReflections = await getRecentMemories(72, ["introspective"], 3);
@@ -5969,10 +7596,10 @@ async function runActiveReflection() {
       cognitiveFunction: "reflect"
     });
     if (!journal || journal.trim().length < 50) {
-      log16.warn("Reflection produced empty or trivial output \u2014 discarding");
+      log23.warn("Reflection produced empty or trivial output \u2014 discarding");
       return null;
     }
-    log16.info({ length: journal.length, theme }, "Journal entry generated");
+    log23.info({ length: journal.length, theme }, "Journal entry generated");
     const title = await generateTitle(journal);
     const memoryId = await storeMemory({
       type: "introspective",
@@ -6006,17 +7633,17 @@ ${journal}`,
     if (_reflectionHandler) {
       try {
         await _reflectionHandler(result);
-        log16.info("Reflection sent to SDK handler");
+        log23.info("Reflection sent to SDK handler");
       } catch (err) {
-        log16.error({ err }, "SDK reflection handler failed");
+        log23.error({ err }, "SDK reflection handler failed");
       }
     } else {
       await maybePostThread(result);
     }
-    log16.info({ memoryId, title }, "=== ACTIVE REFLECTION COMPLETE ===");
+    log23.info({ memoryId, title }, "=== ACTIVE REFLECTION COMPLETE ===");
     return result;
   } catch (err) {
-    log16.error({ err }, "Active reflection failed");
+    log23.error({ err }, "Active reflection failed");
     return null;
   } finally {
     reflectionInProgress2 = false;
@@ -6040,25 +7667,25 @@ async function maybePostThread(journal) {
   const hour = (/* @__PURE__ */ new Date()).getUTCHours();
   const isQuietHours = hour >= 23 || hour < 8;
   if (isQuietHours) {
-    log16.debug("Quiet hours \u2014 skipping thread post");
+    log23.debug("Quiet hours \u2014 skipping thread post");
     return;
   }
   if (journal.text.length < 300) {
-    log16.debug("Journal too short for thread \u2014 skipping post");
+    log23.debug("Journal too short for thread \u2014 skipping post");
     return;
   }
   const canPost = await checkRateLimit(THREAD_RATE_KEY, THREAD_RATE_LIMIT, THREAD_RATE_WINDOW);
   if (!canPost) {
-    log16.debug("Thread rate limit hit \u2014 skipping post");
+    log23.debug("Thread rate limit hit \u2014 skipping post");
     return;
   }
   try {
     const tweets = formatAsThread(journal);
     const { postThread: postThread2 } = (init_x_client(), __toCommonJS(x_client_exports));
     const ids = await postThread2(tweets);
-    log16.info({ tweetCount: ids.length, title: journal.title }, "Reflection thread posted to X");
+    log23.info({ tweetCount: ids.length, title: journal.title }, "Reflection thread posted to X");
   } catch (err) {
-    log16.error({ err }, "Failed to post reflection thread");
+    log23.error({ err }, "Failed to post reflection thread");
   }
 }
 function formatAsThread(journal) {
@@ -6081,29 +7708,29 @@ A reflection \u{1F9F5}`;
   return tweets.slice(0, MAX_THREAD_TWEETS);
 }
 async function startActiveReflection() {
-  log16.info("Starting active reflection scheduler");
+  log23.info("Starting active reflection scheduler");
   const cron = require("node-cron");
   reflectionCron = cron.schedule("30 1,4,7,10,13,16,19,22 * * *", async () => {
     if (reflectionInProgress2) {
-      log16.info("Scheduled reflection skipped \u2014 already in progress");
+      log23.info("Scheduled reflection skipped \u2014 already in progress");
       return;
     }
-    log16.info("=== SCHEDULED ACTIVE REFLECTION ===");
+    log23.info("=== SCHEDULED ACTIVE REFLECTION ===");
     await Promise.race([
       runActiveReflection(),
       new Promise(
         (_, reject) => setTimeout(() => reject(new Error("Active reflection timed out")), REFLECTION_TIMEOUT_MS2)
       )
     ]).catch((err) => {
-      log16.error({ err }, "Scheduled active reflection failed or timed out");
+      log23.error({ err }, "Scheduled active reflection failed or timed out");
     });
   });
   setTimeout(async () => {
-    log16.info("Running initial active reflection");
+    log23.info("Running initial active reflection");
     try {
       await runActiveReflection();
     } catch (err) {
-      log16.error({ err }, "Initial active reflection failed");
+      log23.error({ err }, "Initial active reflection failed");
     }
   }, 30 * 60 * 1e3);
 }
@@ -6112,9 +7739,9 @@ function stopActiveReflection() {
     reflectionCron.stop();
     reflectionCron = null;
   }
-  log16.info("Active reflection stopped");
+  log23.info("Active reflection stopped");
 }
-var log16, REFLECTION_INTERVAL_MS, MIN_MEMORIES_FOR_REFLECTION, MAX_JOURNAL_TOKENS, MAX_THREAD_TWEETS, THREAD_RATE_KEY, THREAD_RATE_LIMIT, THREAD_RATE_WINDOW, reflectionInProgress2, reflectionCron, REFLECTION_TIMEOUT_MS2, _reflectionHandler;
+var log23, REFLECTION_INTERVAL_MS, MIN_MEMORIES_FOR_REFLECTION, MAX_JOURNAL_TOKENS, MAX_THREAD_TWEETS, THREAD_RATE_KEY, THREAD_RATE_LIMIT, THREAD_RATE_WINDOW, reflectionInProgress2, reflectionCron, REFLECTION_TIMEOUT_MS2, _reflectionHandler;
 var init_active_reflection = __esm({
   "packages/brain/src/memory/active-reflection.ts"() {
     "use strict";
@@ -6124,7 +7751,7 @@ var init_active_reflection = __esm({
     init_logger();
     init_constants();
     init_clinamen();
-    log16 = createChildLogger("active-reflection");
+    log23 = createChildLogger("active-reflection");
     REFLECTION_INTERVAL_MS = 3 * 60 * 60 * 1e3;
     MIN_MEMORIES_FOR_REFLECTION = 5;
     MAX_JOURNAL_TOKENS = 1500;
@@ -6554,7 +8181,7 @@ var Cortex = class {
 };
 
 // packages/brain/src/sdk/cortex-v2.ts
-var import_crypto3 = __toESM(require("crypto"));
+var import_crypto4 = __toESM(require("crypto"));
 var DEFAULT_ROUTES = {
   routes: {
     embed: { provider: "voyage", model: "voyage-4-large" },
@@ -6615,7 +8242,7 @@ var CortexV2 = class extends Cortex {
       });
     }
     const pack = {
-      id: import_crypto3.default.randomUUID(),
+      id: import_crypto4.default.randomUUID(),
       name: opts.name,
       description: opts.description,
       memories: memories.map((m) => ({