@clude/sdk 3.0.4 → 3.3.0

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()
         );
 
@@ -348,13 +543,18 @@ async function initDatabase() {
           is_active BOOLEAN DEFAULT TRUE,
           metadata JSONB DEFAULT '{}',
           owner_wallet TEXT,
-          privy_did TEXT
+          privy_did TEXT,
+          email TEXT
         );
 
+        -- Backfill: older deployments may have agent_keys without the email column.
+        ALTER TABLE agent_keys ADD COLUMN IF NOT EXISTS email TEXT;
+
         CREATE INDEX IF NOT EXISTS idx_agent_keys_api_key ON agent_keys(api_key);
         CREATE INDEX IF NOT EXISTS idx_agent_keys_owner ON agent_keys(owner_wallet);
         CREATE UNIQUE INDEX IF NOT EXISTS idx_agent_keys_owner_unique ON agent_keys(owner_wallet) WHERE owner_wallet IS NOT NULL;
         CREATE UNIQUE INDEX IF NOT EXISTS idx_agent_keys_privy_did ON agent_keys(privy_did) WHERE privy_did IS NOT NULL;
+        CREATE UNIQUE INDEX IF NOT EXISTS idx_agent_keys_email ON agent_keys(email) WHERE email IS NOT NULL AND is_active = true;
 
         -- Cortex recall performance: owner_wallet scoped queries
         CREATE INDEX IF NOT EXISTS idx_cortex_owner_recall ON memories(owner_wallet, decay_factor DESC, created_at DESC);
@@ -402,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(),
@@ -437,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,
@@ -449,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;
         $$;
@@ -477,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
@@ -658,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),
@@ -681,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)
@@ -691,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,
@@ -711,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
@@ -744,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 (
@@ -788,6 +1312,63 @@ async function initDatabase() {
           created_at TIMESTAMPTZ DEFAULT NOW()
         );
         CREATE INDEX IF NOT EXISTS idx_chat_usage_wallet ON chat_usage(wallet_address, created_at DESC);
+
+        -- Wiki pack installations: which packs (Workspace, Compliance, Sales)
+        -- each wallet has installed. Drives the topic rail in /wiki and
+        -- the auto-categorisation rules applied to incoming memories.
+        CREATE TABLE IF NOT EXISTS wiki_pack_installations (
+          id BIGSERIAL PRIMARY KEY,
+          owner_wallet TEXT NOT NULL,
+          pack_id TEXT NOT NULL,
+          installed_at TIMESTAMPTZ DEFAULT NOW(),
+          UNIQUE (owner_wallet, pack_id)
+        );
+        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) {
@@ -796,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();
@@ -829,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;
   }
 });
 
@@ -949,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"];
@@ -1015,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) {
@@ -1046,15 +1737,18 @@ 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 = {
       // Frontier (Anthropic)
+      "claude-opus-4.7": "anthropic/claude-opus-4.7",
       "claude-opus-4.6": "anthropic/claude-opus-4.6",
       "claude-sonnet-4.6": "anthropic/claude-sonnet-4.6",
       "claude-opus-4.5": "anthropic/claude-opus-4.5",
       "claude-sonnet-4.5": "anthropic/claude-sonnet-4.5",
       // Frontier (Other providers)
+      "gpt-5.5": "openai/gpt-5.5",
       "gpt-5.4": "openai/gpt-5.4",
       "grok-4.1": "x-ai/grok-4.1-fast",
       "gemini-3-pro": "google/gemini-3-pro-preview",
@@ -1106,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";
@@ -1130,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
@@ -1150,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,
@@ -1174,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;
@@ -1271,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 }]
     });
@@ -1301,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",
@@ -1333,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;
@@ -1353,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) {
@@ -1501,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";
@@ -1534,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";
   }
 });
 
@@ -1674,8 +2457,8 @@ function deriveRegistryPDA(authority) {
   );
 }
 function anchorDiscriminator(name) {
-  const { createHash: createHash2 } = require("crypto");
-  const hash = createHash2("sha256").update(`global:${name}`).digest();
+  const { createHash: createHash3 } = require("crypto");
+  const hash = createHash3("sha256").update(`global:${name}`).digest();
   return hash.subarray(0, 8);
 }
 async function initializeRegistry() {
@@ -1840,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();
@@ -1890,6 +2706,338 @@ var init_utils = __esm({
   }
 });
 
+// packages/tokenization/src/content-hash.ts
+function stableStringify(value) {
+  if (value === null) return "null";
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return "[" + value.map(stableStringify).join(",") + "]";
+  }
+  if (typeof value === "object") {
+    const obj = value;
+    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(",") + "}";
+  }
+  throw new Error(`stableStringify: unsupported value of type ${typeof value}`);
+}
+function normaliseString(s) {
+  return s.normalize("NFC").trim();
+}
+function normaliseNullable(s) {
+  return s === null ? null : normaliseString(s);
+}
+function normaliseTags(tags) {
+  const trimmed = tags.map(normaliseString).filter((t) => t.length > 0);
+  return Array.from(new Set(trimmed)).sort();
+}
+function canonicaliseMemory(input) {
+  const normalised = {
+    algorithm: HASH_ALGORITHM,
+    content: normaliseString(input.content),
+    created_at: input.created_at,
+    memory_type: input.memory_type,
+    owner_wallet: normaliseNullable(input.owner_wallet),
+    related_user: normaliseNullable(input.related_user),
+    related_wallet: normaliseNullable(input.related_wallet),
+    source: normaliseNullable(input.source),
+    tags: normaliseTags(input.tags)
+  };
+  return stableStringify(normalised);
+}
+function memoryContentHash(input) {
+  return (0, import_node_crypto.createHash)("sha256").update(canonicaliseMemory(input), "utf8").digest("hex");
+}
+var import_node_crypto, HASH_ALGORITHM;
+var init_content_hash = __esm({
+  "packages/tokenization/src/content-hash.ts"() {
+    "use strict";
+    import_node_crypto = require("node:crypto");
+    HASH_ALGORITHM = "memory-hash-v1";
+  }
+});
+
+// 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]);
+  }
+});
+
+// packages/tokenization/src/mint-client.ts
+var init_mint_client = __esm({
+  "packages/tokenization/src/mint-client.ts"() {
+    "use strict";
+  }
+});
+
+// packages/tokenization/src/tokenize-memory.ts
+var init_tokenize_memory = __esm({
+  "packages/tokenization/src/tokenize-memory.ts"() {
+    "use strict";
+    init_content_hash();
+  }
+});
+
+// packages/tokenization/src/tokenize-batch.ts
+var init_tokenize_batch = __esm({
+  "packages/tokenization/src/tokenize-batch.ts"() {
+    "use strict";
+    init_content_hash();
+    init_pack_merkle();
+  }
+});
+
+// packages/tokenization/src/tokenize-pack.ts
+var init_tokenize_pack = __esm({
+  "packages/tokenization/src/tokenize-pack.ts"() {
+    "use strict";
+    init_pack_merkle();
+  }
+});
+
+// packages/tokenization/src/verify.ts
+var init_verify = __esm({
+  "packages/tokenization/src/verify.ts"() {
+    "use strict";
+    init_pack_merkle();
+  }
+});
+
+// packages/tokenization/src/index.ts
+var init_src = __esm({
+  "packages/tokenization/src/index.ts"() {
+    "use strict";
+    init_content_hash();
+    init_pack_merkle();
+    init_mint_client();
+    init_tokenize_memory();
+    init_tokenize_batch();
+    init_tokenize_pack();
+    init_verify();
+  }
+});
+
+// packages/shared/src/wiki-packs.ts
+function getPackManifest(id) {
+  return ALL_PACK_MANIFESTS.find((p) => p.id === id);
+}
+function matchesKeyword(text, phrase) {
+  if (!phrase) return false;
+  const escaped = phrase.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const re = new RegExp(`(?<![\\w-])${escaped}(?![\\w-])`, "i");
+  return re.test(text);
+}
+function autoCategorizeTags(opts) {
+  const haystack = [
+    opts.content || "",
+    opts.summary || "",
+    ...opts.existingTags || []
+  ].join(" ");
+  const matched = new Set(opts.existingTags || []);
+  const ids = /* @__PURE__ */ new Set([DEFAULT_PACK_ID, ...opts.installedPackIds]);
+  for (const packId of ids) {
+    const pack = getPackManifest(packId);
+    if (!pack) continue;
+    for (const rule of pack.rules) {
+      if (matched.has(rule.topicId)) continue;
+      const hasMatch = rule.keywords.some((kw) => matchesKeyword(haystack, kw));
+      if (!hasMatch) continue;
+      const isVetoed = (rule.excludeKeywords || []).some((kw) => matchesKeyword(haystack, kw));
+      if (isVetoed) continue;
+      matched.add(rule.topicId);
+    }
+  }
+  return Array.from(matched);
+}
+function topicEmbedSources(installedPackIds) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const ids = /* @__PURE__ */ new Set([DEFAULT_PACK_ID, ...installedPackIds]);
+  for (const packId of ids) {
+    const pack = getPackManifest(packId);
+    if (!pack) continue;
+    for (const t of pack.topics) {
+      if (seen.has(t.id)) continue;
+      seen.add(t.id);
+      const sectionTitles = (t.sectionTemplates || []).map((s) => s.title).join(". ");
+      const text = [t.name, t.summary, sectionTitles].filter(Boolean).join(" \u2014 ");
+      out.push({ topicId: t.id, packId, text });
+    }
+  }
+  return out;
+}
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length || a.length === 0) return 0;
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  return denom === 0 ? 0 : dot / denom;
+}
+function semanticTagMatches(memoryEmbedding, topicEmbeddings, threshold = EMBEDDING_TAG_THRESHOLD) {
+  const matched = [];
+  for (const { topicId, embedding } of topicEmbeddings) {
+    const sim = cosineSimilarity(memoryEmbedding, embedding);
+    if (sim >= threshold) matched.push(topicId);
+  }
+  return matched;
+}
+var WORKSPACE_PACK, COMPLIANCE_PACK, SALES_PACK, ALL_PACK_MANIFESTS, DEFAULT_PACK_ID, EMBEDDING_TAG_THRESHOLD;
+var init_wiki_packs = __esm({
+  "packages/shared/src/wiki-packs.ts"() {
+    "use strict";
+    WORKSPACE_PACK = {
+      id: "workspace",
+      name: "Workspace Essentials",
+      vendor: "Clude",
+      vertical: "General",
+      version: "1.0.0",
+      installedByDefault: true,
+      description: "The default knowledge-worker pack. Roadmaps, decisions, customer research, hiring, team process \u2014 everything you'd want a colleague to be able to skim.",
+      topics: [
+        { id: "q3-roadmap", name: "Q3 Roadmap", cluster: "architecture", color: "#2244FF", summary: "What ships this quarter, what got cut, and the calls behind those decisions." },
+        { id: "auth-migration", name: "Auth Migration", cluster: "architecture", color: "#2244FF", summary: "Moving from session cookies to JWT \u2014 incidents, fixes, and the rollback plan." },
+        { id: "customer-research", name: "Customer Research", cluster: "research", color: "#F59E0B", summary: "Patterns surfaced across customer calls." },
+        { id: "pricing-model", name: "Pricing Model", cluster: "product", color: "#10B981", summary: "Per-token vs per-seat \u2014 the active disagreement." },
+        { id: "demo-day-prep", name: "Demo Day Prep", cluster: "product", color: "#10B981", summary: "What works in the live demo, what breaks." },
+        { id: "hiring", name: "Hiring Pipeline", cluster: "product", color: "#10B981", summary: "Candidates in flight and interview-signal patterns." },
+        { id: "team-process", name: "Team Process", cluster: "self", color: "#8B5CF6", summary: "What's working in how the team operates and what isn't." },
+        { id: "design-decisions", name: "Design Decisions", cluster: "research", color: "#F59E0B", summary: "API shapes, naming choices, and the reasons behind them." }
+      ],
+      rules: [
+        { topicId: "q3-roadmap", keywords: ["roadmap", "q3", "quarter", "sprint plan", "priority"] },
+        { topicId: "auth-migration", keywords: ["auth", "jwt", "session cookie", "oauth", "sso", "token migration"] },
+        { topicId: "customer-research", keywords: ["customer call", "interview", "feedback", "user research", "persona"] },
+        { topicId: "pricing-model", keywords: ["pricing", "per-token", "per-seat", "subscription", "billing tier"] },
+        { topicId: "demo-day-prep", keywords: ["demo", "rehearsal", "investor", "pitch"] },
+        {
+          topicId: "hiring",
+          keywords: ["candidate", "interview", "hire", "phone screen", "onsite", "offer"],
+          // Suppress when "hire" is in the wrong context — got fired, rejected an offer,
+          // hire-purchase, etc. The classic substring-match false positive.
+          excludeKeywords: ["fired me", "i was fired", "hire purchase", "rejected my offer", "rejected the offer"]
+        },
+        { topicId: "team-process", keywords: ["standup", "retro", "sprint", "1:1", "process", "team"] },
+        { topicId: "design-decisions", keywords: ["api design", "schema", "naming", "rfc", "design doc"] }
+      ]
+    };
+    COMPLIANCE_PACK = {
+      id: "compliance",
+      name: "Clude Compliance",
+      vendor: "Clude",
+      vertical: "Compliance",
+      version: "1.0.0",
+      description: "Auto-organises every compliance-relevant decision your agents make into an audit-ready wiki. Audit logs, evidence collection, regulator asks, policy decisions \u2014 each with a cryptographic receipt anchored to Solana.",
+      topics: [
+        {
+          id: "audit-logs",
+          name: "Audit Logs",
+          cluster: "architecture",
+          color: "#0EA5E9",
+          summary: "Every flagged agent action with attribution, timestamp, and a Solana-anchored hash a regulator can verify without trusting us.",
+          sectionTemplates: [
+            { id: "recent-events", title: "Recent flagged events", kind: "overview" },
+            { id: "anomalies", title: "Anomalies & escalations", kind: "concern" },
+            { id: "retention", title: "Retention policy", kind: "decision" }
+          ]
+        },
+        {
+          id: "evidence",
+          name: "Evidence Collection",
+          cluster: "product",
+          color: "#06B6D4",
+          summary: "Documentation gathered for SOC2, HIPAA, and ISO 27001 \u2014 what we have, what we still need, and what auditors have already accepted.",
+          sectionTemplates: [
+            { id: "have", title: "What we have", kind: "highlight" },
+            { id: "gaps", title: "Gaps to fill", kind: "action" },
+            { id: "accepted", title: "What auditors accepted", kind: "decision" }
+          ]
+        },
+        {
+          id: "regulator-asks",
+          name: "Regulator Asks",
+          cluster: "research",
+          color: "#F59E0B",
+          summary: "Specific requests from regulators \u2014 owner, deadline, response status. Nothing falls through the cracks.",
+          sectionTemplates: [
+            { id: "open", title: "Open requests", kind: "action" },
+            { id: "responded", title: "Responded", kind: "decision" },
+            { id: "patterns", title: "Recurring patterns", kind: "highlight" }
+          ]
+        },
+        {
+          id: "policy-decisions",
+          name: "Policy Decisions",
+          cluster: "self",
+          color: "#8B5CF6",
+          summary: "Calls made about what the agents are allowed to do \u2014 data handling, escalation triggers, redaction rules \u2014 each anchored on-chain.",
+          sectionTemplates: [
+            { id: "standing", title: "Standing policy", kind: "decision" },
+            { id: "changes", title: "Recent changes", kind: "overview" },
+            { id: "open", title: "Open questions", kind: "question" }
+          ]
+        },
+        {
+          id: "soc2-status",
+          name: "SOC2 Status",
+          cluster: "product",
+          color: "#10B981",
+          summary: "Where we are in the SOC2 audit cycle, what controls are passing, what still needs evidence.",
+          sectionTemplates: [
+            { id: "controls", title: "Control status", kind: "overview" },
+            { id: "next", title: "Up next", kind: "action" }
+          ]
+        }
+      ],
+      rules: [
+        { topicId: "audit-logs", keywords: ["audit", "audit log", "trail", "attribution", "flagged"] },
+        { topicId: "evidence", keywords: ["evidence", "soc2", "hipaa", "iso 27001", "compliance evidence", "control"] },
+        { topicId: "regulator-asks", keywords: ["regulator", "subpoena", "compliance request", "data request"] },
+        { topicId: "policy-decisions", keywords: ["policy", "redaction", "pii", "escalation rule", "data handling"] },
+        { topicId: "soc2-status", keywords: ["soc2", "audit cycle", "control test"] }
+      ]
+    };
+    SALES_PACK = {
+      id: "sales",
+      name: "Sales Intelligence",
+      vendor: "Clude",
+      vertical: "Sales",
+      version: "1.0.0",
+      description: "Auto-organises pipeline conversations, deal blockers, objection patterns, and post-call follow-ups. Built for AEs who hate CRM data entry.",
+      topics: [
+        { id: "pipeline", name: "Pipeline", cluster: "product", color: "#10B981", summary: "Active deals, stages, blockers." },
+        { id: "objections", name: "Objections", cluster: "research", color: "#F59E0B", summary: "Patterns across discovery calls." },
+        { id: "follow-ups", name: "Follow-ups", cluster: "product", color: "#10B981", summary: "What you committed to send and to whom." },
+        { id: "champions", name: "Champions", cluster: "self", color: "#8B5CF6", summary: "Who is championing your product internally at each account." }
+      ],
+      rules: [
+        { topicId: "pipeline", keywords: ["deal", "opportunity", "stage", "close date", "mql", "sql"] },
+        { topicId: "objections", keywords: ["objection", "concern raised", "pushback", "competitor mentioned"] },
+        { topicId: "follow-ups", keywords: ["follow up", "send", "next step", "committed to"] },
+        { topicId: "champions", keywords: ["champion", "sponsor", "advocate", "introduced me to"] }
+      ]
+    };
+    ALL_PACK_MANIFESTS = [
+      WORKSPACE_PACK,
+      COMPLIANCE_PACK,
+      SALES_PACK
+    ];
+    DEFAULT_PACK_ID = "workspace";
+    EMBEDDING_TAG_THRESHOLD = 0.78;
+  }
+});
+
 // packages/brain/src/experimental/config.ts
 function envBool(key, fallback) {
   const val = process.env[key];
@@ -1975,26 +3123,509 @@ var init_bm25_search = __esm({
   }
 });
 
-// packages/shared/src/core/encryption.ts
-var encryption_exports = {};
-__export(encryption_exports, {
-  configureEncryption: () => configureEncryption,
-  decryptContent: () => decryptContent,
-  decryptMemoryBatch: () => decryptMemoryBatch,
-  encryptContent: () => encryptContent,
-  getEncryptionPubkey: () => getEncryptionPubkey,
-  isEncryptionEnabled: () => isEncryptionEnabled
-});
-async function configureEncryption(solanaSecretKey) {
-  if (solanaSecretKey.length !== 64) {
-    throw new Error("Encryption requires a 64-byte Ed25519 secret key");
+// 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)");
   }
-  const seed = solanaSecretKey.slice(0, 32);
-  const derived = await hkdfAsync("sha256", seed, HKDF_SALT, HKDF_INFO, 32);
-  encryptionKey = new Uint8Array(derived);
-  const keypair = import_tweetnacl2.default.sign.keyPair.fromSecretKey(solanaSecretKey);
+}
+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, {
+  configureEncryption: () => configureEncryption,
+  decryptContent: () => decryptContent,
+  decryptMemoryBatch: () => decryptMemoryBatch,
+  encryptContent: () => encryptContent,
+  getEncryptionPubkey: () => getEncryptionPubkey,
+  isEncryptionEnabled: () => isEncryptionEnabled
+});
+async function configureEncryption(solanaSecretKey) {
+  if (solanaSecretKey.length !== 64) {
+    throw new Error("Encryption requires a 64-byte Ed25519 secret key");
+  }
+  const seed = solanaSecretKey.slice(0, 32);
+  const derived = await hkdfAsync2("sha256", seed, HKDF_SALT2, HKDF_INFO2, 32);
+  encryptionKey = new Uint8Array(derived);
+  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;
@@ -2006,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) {
@@ -2020,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;
     }
@@ -2039,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, {
@@ -2121,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;
   }
 }
@@ -2152,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) {
@@ -2164,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) {
@@ -2181,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) {
@@ -2287,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 [];
@@ -2305,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);
@@ -2313,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");
   }
 });
 
@@ -2348,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,
@@ -2360,11 +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,
@@ -2372,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) {
@@ -2405,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);
@@ -2451,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();
 }
@@ -2467,27 +4211,104 @@ function isDuplicateWrite(source, summary) {
   }
   return false;
 }
+async function getInstalledPackIdsCached(ownerWallet) {
+  const key = ownerWallet ?? "__no_owner__";
+  const now = Date.now();
+  const cached = installedPacksCache.get(key);
+  if (cached && cached.expiresAt > now) return cached.ids;
+  let ids = [DEFAULT_PACK_ID];
+  if (ownerWallet) {
+    try {
+      const db = getDb();
+      const { data, error } = await db.from("wiki_pack_installations").select("pack_id").eq("owner_wallet", ownerWallet);
+      if (!error && data) {
+        const fromDb = data.map((r) => r.pack_id);
+        ids = Array.from(/* @__PURE__ */ new Set([DEFAULT_PACK_ID, ...fromDb]));
+      }
+    } catch (err) {
+      log16.debug({ err }, "Failed to fetch installed packs (using default only)");
+    }
+  }
+  installedPacksCache.set(key, { ids, expiresAt: now + INSTALLED_PACKS_TTL_MS });
+  if (installedPacksCache.size > 200) {
+    for (const [k, v] of installedPacksCache) {
+      if (v.expiresAt <= now) installedPacksCache.delete(k);
+    }
+  }
+  return ids;
+}
+function invalidateInstalledPacksCache(ownerWallet) {
+  if (ownerWallet) installedPacksCache.delete(ownerWallet);
+  else installedPacksCache.clear();
+}
+async function ensureTopicEmbeddings(installedPackIds) {
+  const sources = topicEmbedSources(installedPackIds);
+  const missing = sources.filter((s) => !topicEmbeddingCache.has(s.topicId));
+  if (missing.length === 0) {
+    return new Map(sources.map((s) => [s.topicId, topicEmbeddingCache.get(s.topicId)]));
+  }
+  if (topicEmbeddingPopulationLock) {
+    await topicEmbeddingPopulationLock;
+  }
+  const stillMissing = sources.filter((s) => !topicEmbeddingCache.has(s.topicId));
+  if (stillMissing.length === 0) {
+    return new Map(sources.map((s) => [s.topicId, topicEmbeddingCache.get(s.topicId)]));
+  }
+  topicEmbeddingPopulationLock = (async () => {
+    try {
+      const texts = stillMissing.map((s) => s.text);
+      const embeddings = await generateEmbeddings(texts);
+      stillMissing.forEach((s, i) => {
+        const emb = embeddings[i];
+        if (emb) topicEmbeddingCache.set(s.topicId, emb);
+      });
+    } catch (err) {
+      log16.warn({ err }, "Failed to populate topic embeddings cache");
+    } finally {
+      topicEmbeddingPopulationLock = null;
+    }
+  })();
+  await topicEmbeddingPopulationLock;
+  return new Map(
+    sources.filter((s) => topicEmbeddingCache.has(s.topicId)).map((s) => [s.topicId, topicEmbeddingCache.get(s.topicId)])
+  );
+}
 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({
+    content: opts.content,
+    summary: opts.summary,
+    existingTags: opts.tags || [],
+    installedPackIds
+  });
   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,
       content: storedContent,
       summary: opts.summary.slice(0, MEMORY_MAX_SUMMARY_LENGTH),
-      tags: opts.tags || [],
+      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,
@@ -2495,43 +4316,83 @@ async function storeMemory(opts) {
       metadata: opts.metadata || {},
       evidence_ids: opts.evidenceIds || [],
       compacted: false,
-      encrypted: shouldEncrypt,
-      encryption_pubkey: shouldEncrypt ? getEncryptionPubkey() : null,
-      owner_wallet: getOwnerWallet() || null
-    }).select("id, hash_id").single();
+      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).catch((err) => log10.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"));
+    commitMemoryToChain(data.id, opts, data, plaintextContent, envelope !== null || legacyEncrypt).catch(
+      (err) => log16.warn({ err }, "On-chain memory commit 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) {
-  if (opts.source === "demo" || opts.source === "demo-maas" || opts.source === "locomo-benchmark" || opts.source === "longmemeval-benchmark") return;
-  const contentHashBuf = (0, import_crypto2.createHash)("sha256").update(opts.content).digest();
+async function commitMemoryToChain(memoryId, opts, row, plaintextContent, encrypted) {
+  if (TOKENISATION_SKIP_SOURCES.has(opts.source)) return;
+  const canonicalHash = memoryContentHash({
+    content: plaintextContent,
+    memory_type: row.memory_type,
+    owner_wallet: row.owner_wallet,
+    created_at: row.created_at,
+    tags: row.tags ?? [],
+    source: row.source,
+    related_user: row.related_user,
+    related_wallet: row.related_wallet
+  });
+  const contentHashBuf = Buffer.from(canonicalHash, "hex");
   let signature = null;
   if (isRegistryEnabled()) {
-    const encrypted = isEncryptionEnabled();
     signature = await registerMemoryOnChain(
       contentHashBuf,
       opts.type,
@@ -2541,24 +4402,146 @@ async function commitMemoryToChain(memoryId, opts) {
     );
   }
   if (!signature) {
-    const contentHashHex = contentHashBuf.toString("hex");
-    const memo = `clude:v1:sha256:${contentHashHex}`;
+    const memo = `clude:v1:sha256:${canonicalHash}`;
     signature = await writeMemo(memo);
   }
-  if (!signature) return;
   const db = getDb();
-  await db.from("memories").update({ solana_signature: signature }).eq("id", memoryId);
-  log10.debug({ memoryId, signature: signature.slice(0, 16) }, "Memory committed on-chain");
+  if (!signature) {
+    await db.from("memories").update({ content_hash: canonicalHash, tokenization_status: "failed" }).eq("id", memoryId);
+    return;
+  }
+  await db.from("memories").update({
+    solana_signature: signature,
+    content_hash: canonicalHash,
+    cnft_address: signature,
+    // PDA-based v0.1 — assetId = tx sig; LightMintClient (v0.2) will use real cNFT mints
+    cnft_tx_sig: signature,
+    cnft_tree: null,
+    cnft_leaf_index: null,
+    tokenization_status: "minted",
+    tokenized_at: (/* @__PURE__ */ new Date()).toISOString()
+  }).eq("id", memoryId);
+  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 embedMemory(memoryId, opts) {
+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 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) {
-    await db.from("memories").update({ embedding: JSON.stringify(summaryEmbedding) }).eq("id", memoryId);
+  if (!summaryEmbedding) {
+    log16.debug({ memoryId }, "No embedding generated; skipping semantic tagging");
+    return;
+  }
+  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);
+    const topicEmbeddings = await ensureTopicEmbeddings(installedPacks);
+    if (topicEmbeddings.size > 0) {
+      const semantic = semanticTagMatches(
+        summaryEmbedding,
+        Array.from(topicEmbeddings, ([topicId, embedding]) => ({ topicId, embedding }))
+      );
+      if (semantic.length > 0) {
+        const { data: row } = await db.from("memories").select("tags").eq("id", memoryId).maybeSingle();
+        const existing = row?.tags ?? [];
+        const merged = Array.from(/* @__PURE__ */ new Set([...existing, ...semantic]));
+        if (merged.length !== existing.length) {
+          await db.from("memories").update({ tags: merged }).eq("id", memoryId);
+          log16.debug({
+            memoryId,
+            added: semantic.filter((t) => !existing.includes(t))
+          }, "Semantic pack tags appended");
+        }
+      }
+    }
+  } catch (err) {
+    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];
@@ -2576,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];
   }
 }
@@ -2592,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;
         })
@@ -2604,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);
@@ -2659,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
         });
@@ -2713,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();
@@ -2734,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);
@@ -2754,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 [];
@@ -2778,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)) {
@@ -2793,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");
@@ -2823,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) {
@@ -2837,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;
@@ -2861,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))]
@@ -2870,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) {
@@ -2886,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);
@@ -2910,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),
@@ -2920,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 [];
   }
 }
@@ -2934,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) {
@@ -2970,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;
@@ -2991,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);
@@ -3010,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 [];
   }
 }
@@ -3027,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) {
@@ -3061,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) {
@@ -3083,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) {
@@ -3102,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);
@@ -3151,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) {
@@ -3173,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() {
@@ -3198,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;
   }
 }
@@ -3218,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;
@@ -3236,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;
@@ -3257,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();
@@ -3278,25 +5292,31 @@ async function getMemoryStats() {
     embeddedCount: 0
   };
   try {
-    let countQuery = db.from("memories").select("id", { count: "exact", head: true }).gt("decay_factor", MEMORY_MIN_DECAY);
+    let countQuery = db.from("memories").select("id", { count: "exact", head: true });
     countQuery = scopeToOwner(countQuery);
     const { count: totalCount } = await countQuery;
     stats.total = totalCount || 0;
-    let embeddedQuery = db.from("memories").select("id", { count: "exact", head: true }).gt("decay_factor", MEMORY_MIN_DECAY).not("embedding", "is", null);
+    let embeddedQuery = db.from("memories").select("id", { count: "exact", head: true }).not("embedding", "is", null);
     embeddedQuery = scopeToOwner(embeddedQuery);
     const { count: embCount } = await embeddedQuery;
     stats.embeddedCount = embCount || 0;
-    const PAGE_SIZE = 5e3;
+    const TYPES = ["episodic", "semantic", "procedural", "self_model", "introspective"];
+    await Promise.all(TYPES.map(async (type) => {
+      let q = db.from("memories").select("id", { count: "exact", head: true }).eq("memory_type", type);
+      q = scopeToOwner(q);
+      const { count: count2 } = await q;
+      stats.byType[type] = count2 || 0;
+    }));
+    const PAGE_SIZE = 1e3;
+    const MAX_PAGES = 20;
     let allMemories = [];
-    let page = 0;
-    while (true) {
-      let pageQuery = db.from("memories").select("memory_type, importance, decay_factor, created_at, related_user, tags, concepts").gt("decay_factor", MEMORY_MIN_DECAY).range(page * PAGE_SIZE, (page + 1) * PAGE_SIZE - 1);
+    for (let page = 0; page < MAX_PAGES; page++) {
+      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;
       allMemories = allMemories.concat(pageData);
       if (pageData.length < PAGE_SIZE) break;
-      page++;
     }
     if (allMemories.length > 0) {
       let impSum = 0;
@@ -3305,11 +5325,10 @@ async function getMemoryStats() {
       const conceptCounts = {};
       const users = /* @__PURE__ */ new Set();
       for (const m of allMemories) {
-        const type = m.memory_type;
-        if (type in stats.byType) stats.byType[type]++;
         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;
@@ -3330,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;
 }
@@ -3350,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();
@@ -3361,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();
@@ -3372,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.");
@@ -3444,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 || {});
   }
 }
@@ -3471,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,
@@ -3494,32 +5510,52 @@ function moodToValence(mood) {
       return 0;
   }
 }
-var import_crypto2, EMBED_CACHE_MAX, embeddingCache, _ownerWallet, SCOPE_BOT_OWN, HASH_ID_PREFIX, log10, DEDUP_TTL_MS, dedupCache, 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();
+    INSTALLED_PACKS_TTL_MS = 6e4;
+    topicEmbeddingCache = /* @__PURE__ */ new Map();
+    topicEmbeddingPopulationLock = null;
+    TOKENISATION_SKIP_SOURCES = /* @__PURE__ */ new Set([
+      "demo",
+      "demo-maas",
+      "locomo-benchmark",
+      "longmemeval-benchmark"
+    ]);
+    outboxDegradeLogged = false;
     STOPWORDS = /* @__PURE__ */ new Set([
       "the",
       "a",
@@ -3604,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,
@@ -3625,11 +5735,14 @@ __export(memory_exports2, {
   getSelfModel: () => getSelfModel,
   hydrateMemories: () => hydrateMemories,
   inferConcepts: () => inferConcepts,
+  invalidateInstalledPacksCache: () => invalidateInstalledPacksCache,
   isValidHashId: () => isValidHashId,
   listMemories: () => listMemories,
   moodToValence: () => moodToValence,
   recallMemories: () => recallMemories,
   recallMemorySummaries: () => recallMemorySummaries,
+  redelegateMemory: () => redelegateMemory,
+  revokeMemory: () => revokeMemory,
   scopeToOwner: () => scopeToOwner,
   scoreImportanceWithLLM: () => scoreImportanceWithLLM,
   scoreMemory: () => scoreMemory,
@@ -3641,6 +5754,8 @@ var init_memory2 = __esm({
   "packages/brain/src/memory/index.ts"() {
     "use strict";
     init_memory();
+    init_memory_decryption();
+    init_memory_revoke();
   }
 });
 
@@ -3770,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();
@@ -3793,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) {
@@ -3888,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";
@@ -3905,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;
@@ -3940,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();
@@ -3952,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();
     }
@@ -3973,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) {
@@ -4040,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",
@@ -4079,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 = {
@@ -4117,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 = {
@@ -4158,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",
@@ -4192,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 [];
   }
 }
@@ -4219,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;
@@ -4235,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";
@@ -4247,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,
@@ -4293,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;
   }
 }
@@ -4326,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;
   }
 }
@@ -4347,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() {
@@ -4362,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(
@@ -4375,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();
@@ -4420,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) {
@@ -4428,7 +6543,7 @@ async function refineStrategies() {
     }
     return lessons;
   } catch (err) {
-    log13.error({ err }, "Strategy refinement failed");
+    log20.error({ err }, "Strategy refinement failed");
     return lessons;
   }
 }
@@ -4452,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;
   }
 }
@@ -4474,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() {
@@ -4532,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";
@@ -4549,7 +6664,7 @@ var init_action_learning = __esm({
     init_logger();
     init_database();
     init_claude_client();
-    log13 = createChildLogger("action-learning");
+    log20 = createChildLogger("action-learning");
   }
 });
 
@@ -4576,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)
@@ -4586,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");
       }
     });
   }
@@ -4594,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();
@@ -4609,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();
@@ -4623,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;
   }
@@ -4637,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");
@@ -4654,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) {
@@ -4698,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);
@@ -4713,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) {
@@ -4745,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({
@@ -4776,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(
@@ -4797,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({
@@ -4820,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";
@@ -4881,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) {
@@ -4895,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();
@@ -4921,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;
   }
@@ -4953,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 {
@@ -4965,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]));
@@ -5008,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);
@@ -5032,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");
       }
     }
   }
@@ -5046,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);
@@ -5116,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);
@@ -5126,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 [];
@@ -5155,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({
@@ -5170,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 [];
   }
 }
@@ -5200,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);
 }
@@ -5239,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";
@@ -5256,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,
@@ -5281,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);
@@ -5293,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();
@@ -5304,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 = [];
@@ -5330,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,
@@ -5356,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";
@@ -5364,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;
@@ -5400,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)]];
@@ -5439,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);
@@ -5481,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",
@@ -5518,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;
@@ -5552,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) {
@@ -5593,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);
 }
@@ -5624,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";
@@ -5636,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;
@@ -6037,10 +8152,10 @@ var Cortex = class {
     this.requireSelfHosted("verifyOnChain");
     const { hydrateMemories: hydrateMemories2 } = (init_memory2(), __toCommonJS(memory_exports2));
     const { verifyMemoryOnChain: verifyMemoryOnChain2 } = (init_solana_client(), __toCommonJS(solana_client_exports));
-    const { createHash: createHash2 } = require("crypto");
+    const { createHash: createHash3 } = require("crypto");
     const memories = await hydrateMemories2([memoryId]);
     if (memories.length === 0) return false;
-    const contentHash = createHash2("sha256").update(memories[0].content).digest();
+    const contentHash = createHash3("sha256").update(memories[0].content).digest();
     return verifyMemoryOnChain2(contentHash);
   }
   /** Clean up resources and stop schedules. */
@@ -6066,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" },
@@ -6127,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) => ({