@clude/sdk 3.0.3 → 3.2.0

package/dist/sdk/index.js

@@ -348,13 +348,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);
@@ -788,6 +793,19 @@ 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);
       `
     });
     if (error) {
@@ -1050,11 +1068,13 @@ var init_openrouter_client = __esm({
     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",
@@ -1674,8 +1694,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() {
@@ -1890,6 +1910,335 @@ 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).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 init_pack_merkle = __esm({
+  "packages/tokenization/src/pack-merkle.ts"() {
+    "use strict";
+  }
+});
+
+// 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];
@@ -2365,6 +2714,7 @@ __export(memory_exports, {
   getSelfModel: () => getSelfModel,
   hydrateMemories: () => hydrateMemories,
   inferConcepts: () => inferConcepts,
+  invalidateInstalledPacksCache: () => invalidateInstalledPacksCache,
   isValidHashId: () => isValidHashId,
   listMemories: () => listMemories,
   markJepaQueried: () => markJepaQueried,
@@ -2467,13 +2817,83 @@ 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) {
+      log10.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) {
+      log10.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) {
   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");
     return null;
   }
   const db = getDb();
+  const ownerWallet = getOwnerWallet();
   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);
@@ -2484,7 +2904,7 @@ async function storeMemory(opts) {
       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),
@@ -2497,8 +2917,8 @@ async function storeMemory(opts) {
       compacted: false,
       encrypted: shouldEncrypt,
       encryption_pubkey: shouldEncrypt ? getEncryptionPubkey() : null,
-      owner_wallet: getOwnerWallet() || null
-    }).select("id, hash_id").single();
+      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");
       return null;
@@ -2516,7 +2936,9 @@ async function storeMemory(opts) {
       memoryType: opts.type,
       source: opts.source
     });
-    commitMemoryToChain(data.id, opts).catch((err) => log10.warn({ err }, "On-chain memory commit failed"));
+    commitMemoryToChain(data.id, opts, data).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"));
@@ -2526,9 +2948,19 @@ async function storeMemory(opts) {
     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) {
+  if (TOKENISATION_SKIP_SOURCES.has(opts.source)) return;
+  const canonicalHash = memoryContentHash({
+    content: row.content,
+    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();
@@ -2541,22 +2973,61 @@ async function commitMemoryToChain(memoryId, opts) {
     );
   }
   if (!signature) {
-    const contentHashHex = contentHashBuf.toString("hex");
-    const memo = `clude-memory | v2 | ${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);
+  log10.debug({ memoryId, signature: signature.slice(0, 16) }, "Memory committed on-chain (PMP + legacy)");
 }
 async function embedMemory(memoryId, opts) {
   if (!isEmbeddingEnabled()) return;
   const db = getDb();
   const embeddings = await generateEmbeddings([opts.summary]);
   const summaryEmbedding = embeddings[0];
-  if (summaryEmbedding) {
-    await db.from("memories").update({ embedding: JSON.stringify(summaryEmbedding) }).eq("id", memoryId);
+  if (!summaryEmbedding) {
+    log10.debug({ memoryId }, "No embedding generated; skipping semantic tagging");
+    return;
+  }
+  await db.from("memories").update({ embedding: JSON.stringify(summaryEmbedding) }).eq("id", memoryId);
+  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);
+          log10.debug({
+            memoryId,
+            added: semantic.filter((t) => !existing.includes(t))
+          }, "Semantic pack tags appended");
+        }
+      }
+    }
+  } catch (err) {
+    log10.debug({ err, memoryId }, "Semantic tagging skipped");
   }
   log10.debug({ memoryId }, "Memory embedded");
 }
@@ -3278,25 +3749,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, 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,8 +3782,6 @@ 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);
@@ -3494,7 +3969,7 @@ 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_crypto2, EMBED_CACHE_MAX, embeddingCache, _ownerWallet, SCOPE_BOT_OWN, HASH_ID_PREFIX, log10, DEDUP_TTL_MS, dedupCache, installedPacksCache, INSTALLED_PACKS_TTL_MS, topicEmbeddingCache, topicEmbeddingPopulationLock, TOKENISATION_SKIP_SOURCES, STOPWORDS;
 var init_memory = __esm({
   "packages/brain/src/memory/memory.ts"() {
     "use strict";
@@ -3503,7 +3978,9 @@ var init_memory = __esm({
     init_utils();
     init_claude_client();
     init_solana_client();
+    init_src();
     init_embeddings();
+    init_wiki_packs();
     init_config2();
     init_bm25_search();
     init_openrouter_client();
@@ -3520,6 +3997,16 @@ var init_memory = __esm({
     log10 = 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"
+    ]);
     STOPWORDS = /* @__PURE__ */ new Set([
       "the",
       "a",
@@ -3625,6 +4112,7 @@ __export(memory_exports2, {
   getSelfModel: () => getSelfModel,
   hydrateMemories: () => hydrateMemories,
   inferConcepts: () => inferConcepts,
+  invalidateInstalledPacksCache: () => invalidateInstalledPacksCache,
   isValidHashId: () => isValidHashId,
   listMemories: () => listMemories,
   moodToValence: () => moodToValence,
@@ -6037,10 +6525,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. */