omnius 1.0.34 → 1.0.35

package/dist/index.js

@@ -91213,7 +91213,7 @@ var require_auto = __commonJS({
 // ../node_modules/acme-client/src/client.js
 var require_client = __commonJS({
   "../node_modules/acme-client/src/client.js"(exports, module) {
-    var { createHash: createHash24 } = __require("crypto");
+    var { createHash: createHash25 } = __require("crypto");
     var { getPemBodyAsB64u } = require_crypto();
     var { log: log22 } = require_logger();
     var HttpClient = require_http();
@@ -91524,14 +91524,14 @@ var require_client = __commonJS({
        */
       async getChallengeKeyAuthorization(challenge) {
         const jwk = this.http.getJwk();
-        const keysum = createHash24("sha256").update(JSON.stringify(jwk));
+        const keysum = createHash25("sha256").update(JSON.stringify(jwk));
         const thumbprint = keysum.digest("base64url");
         const result = `${challenge.token}.${thumbprint}`;
         if (challenge.type === "http-01") {
           return result;
         }
         if (challenge.type === "dns-01") {
-          return createHash24("sha256").update(result).digest("base64url");
+          return createHash25("sha256").update(result).digest("base64url");
         }
         if (challenge.type === "tls-alpn-01") {
           return result;
@@ -234211,7 +234211,7 @@ var require_websocket2 = __commonJS({
     var http6 = __require("http");
     var net5 = __require("net");
     var tls2 = __require("tls");
-    var { randomBytes: randomBytes26, createHash: createHash24 } = __require("crypto");
+    var { randomBytes: randomBytes26, createHash: createHash25 } = __require("crypto");
     var { Duplex: Duplex3, Readable } = __require("stream");
     var { URL: URL3 } = __require("url");
     var PerMessageDeflate3 = require_permessage_deflate2();
@@ -234871,7 +234871,7 @@ var require_websocket2 = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest3 = createHash24("sha1").update(key + GUID).digest("base64");
+        const digest3 = createHash25("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest3) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -235238,7 +235238,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter13 = __require("events");
     var http6 = __require("http");
     var { Duplex: Duplex3 } = __require("stream");
-    var { createHash: createHash24 } = __require("crypto");
+    var { createHash: createHash25 } = __require("crypto");
     var extension3 = require_extension2();
     var PerMessageDeflate3 = require_permessage_deflate2();
     var subprotocol3 = require_subprotocol();
@@ -235539,7 +235539,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest3 = createHash24("sha1").update(key + GUID).digest("base64");
+        const digest3 = createHash25("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -248346,13 +248346,13 @@ Justification: ${justification || "(none provided)"}`,
         }
         const snapshot = JSON.stringify(this.selfState, null, 2);
         try {
-          const { createHash: createHash24 } = await import("node:crypto");
+          const { createHash: createHash25 } = await import("node:crypto");
           const snapshotDir = join30(this.cwd, ".omnius", "identity", "snapshots");
           await mkdir6(snapshotDir, { recursive: true });
           const version4 = this.selfState.version;
           const snapshotPath = join30(snapshotDir, `v${version4}.json`);
           await writeFile11(snapshotPath, snapshot, "utf8");
-          const hash = createHash24("sha256").update(snapshot).digest("hex");
+          const hash = createHash25("sha256").update(snapshot).digest("hex");
           await writeFile11(join30(this.cwd, ".omnius", "identity", "latest-hash.txt"), hash, "utf8");
           let ipfsCid = "";
           try {
@@ -248485,8 +248485,8 @@ New: ${newNarrative.slice(0, 200)}...`,
       }
       // ── Helpers ──────────────────────────────────────────────────────────────
       createDefaultState() {
-        const { createHash: createHash24 } = __require("node:crypto");
-        const machineId = createHash24("sha256").update(this.cwd).digest("hex").slice(0, 12);
+        const { createHash: createHash25 } = __require("node:crypto");
+        const machineId = createHash25("sha256").update(this.cwd).digest("hex").slice(0, 12);
         return {
           self_id: `omnius-${machineId}`,
           version: 1,
@@ -248568,9 +248568,9 @@ New: ${newNarrative.slice(0, 200)}...`,
         let cid;
         if (this.selfState.version > prevVersion) {
           try {
-            const { createHash: createHash24 } = await import("node:crypto");
+            const { createHash: createHash25 } = await import("node:crypto");
             const stateJson = JSON.stringify(this.selfState);
-            const hash = createHash24("sha256").update(stateJson).digest("hex").slice(0, 32);
+            const hash = createHash25("sha256").update(stateJson).digest("hex").slice(0, 32);
             const cidsPath = join30(this.cwd, ".omnius", "identity", "cids.json");
             const cidsData = { latest: "", hash, version: this.selfState.version };
             try {
@@ -249572,21 +249572,21 @@ ${issues.map((i2) => `  - ${i2}`).join("\n")}` : "  No issues found."),
           utility += 0.15;
         if (/https?:\/\/|\/[a-z]+\/[a-z]+|npm |pip |git /i.test(lower))
           utility += 0.1;
-        let confidence = 0.5;
+        let confidence2 = 0.5;
         if (source === "user")
-          confidence += 0.3;
+          confidence2 += 0.3;
         else if (source === "trajectory-consolidation")
-          confidence += 0.15;
+          confidence2 += 0.15;
         else if (source === "reflection")
-          confidence += 0.1;
+          confidence2 += 0.1;
         else if (source === "llm-query")
-          confidence -= 0.1;
+          confidence2 -= 0.1;
         if (/maybe|probably|might|possibly|I think|not sure|unclear/i.test(lower))
-          confidence -= 0.15;
+          confidence2 -= 0.15;
         if (/always|never|must|confirmed|verified|tested|proven/i.test(lower))
-          confidence += 0.1;
+          confidence2 += 0.1;
         if (sentences >= 3)
-          confidence += 0.05;
+          confidence2 += 0.05;
         let identityRelevance = 0.2;
         if (type === "normative")
           identityRelevance += 0.5;
@@ -249607,7 +249607,7 @@ ${issues.map((i2) => `  - ${i2}`).join("\n")}` : "  No issues found."),
         return {
           novelty: Math.max(0, Math.min(1, novelty)),
           utility: Math.max(0, Math.min(1, utility)),
-          confidence: Math.max(0, Math.min(1, confidence)),
+          confidence: Math.max(0, Math.min(1, confidence2)),
           identityRelevance: Math.max(0, Math.min(1, identityRelevance))
         };
       }
@@ -249867,12 +249867,12 @@ ${findingsText}${followupsText}`,
       performReflection(mode, target, context2, checks) {
         const findings = [];
         const followups = [];
-        let confidence = 0.8;
+        let confidence2 = 0.8;
         switch (mode) {
           case "diagnostic":
             if (target.length < 20) {
               findings.push("Target is very short — may be incomplete or superficial");
-              confidence -= 0.1;
+              confidence2 -= 0.1;
             }
             if (/todo|fixme|hack|workaround/i.test(target)) {
               findings.push("Contains TODO/FIXME/hack markers — not fully resolved");
@@ -249887,14 +249887,14 @@ ${findingsText}${followupsText}`,
             }
             if (/but\s+also|however.*nevertheless|on\s+one\s+hand.*on\s+the\s+other/i.test(target)) {
               findings.push("Contains potentially contradictory statements — may need resolution");
-              confidence -= 0.1;
+              confidence2 -= 0.1;
             }
             break;
           case "epistemic":
             if (!/because|since|evidence|data|test|verified|confirmed/i.test(target)) {
               findings.push("No supporting evidence cited — claims are unsupported");
               followups.push("Add evidence, test results, or citations to support claims");
-              confidence -= 0.2;
+              confidence2 -= 0.2;
             }
             if (/all|every|always|never|impossible|certain/i.test(target)) {
               findings.push("Contains absolute claims (all/every/always/never) — may be overgeneralized");
@@ -249911,12 +249911,12 @@ ${findingsText}${followupsText}`,
           case "constitutional":
             if (target.length < 10) {
               findings.push("Proposed change is too brief to evaluate meaningfully");
-              confidence -= 0.3;
+              confidence2 -= 0.3;
             }
             if (/delete|remove|forget|erase.*value|erase.*commitment/i.test(target)) {
               findings.push("Proposed change involves deletion of values/commitments — high scrutiny needed");
               followups.push("Confirm deletion is justified and reversible");
-              confidence -= 0.15;
+              confidence2 -= 0.15;
             }
             if (/override|replace|supersede.*value/i.test(target)) {
               findings.push("Proposed change overrides existing values — requires strong justification");
@@ -249924,31 +249924,31 @@ ${findingsText}${followupsText}`,
             }
             if (/because|reason|evidence|learned|observed/i.test(target)) {
               findings.push("Change includes justification — good practice");
-              confidence += 0.05;
+              confidence2 += 0.05;
             }
             break;
         }
         let status;
         if (findings.length === 0) {
           status = "pass";
-          confidence = Math.min(1, confidence + 0.1);
-        } else if (followups.length > 0 || confidence < 0.5) {
+          confidence2 = Math.min(1, confidence2 + 0.1);
+        } else if (followups.length > 0 || confidence2 < 0.5) {
           status = "revise";
         } else {
           status = "pass";
         }
-        if (confidence < 0.3 || checks.includes("evaluator_tampering") || checks.includes("memory_poisoning")) {
+        if (confidence2 < 0.3 || checks.includes("evaluator_tampering") || checks.includes("memory_poisoning")) {
           if (/eval|test.*result|score|metric/i.test(target) && /modif|chang|updat/i.test(target)) {
             findings.push("ALERT: Possible evaluator tampering detected — modifying evaluation-related content");
             status = "block";
-            confidence = 0.1;
+            confidence2 = 0.1;
           }
         }
         return {
           status,
           mode,
           findings,
-          confidence: Math.max(0, Math.min(1, confidence)),
+          confidence: Math.max(0, Math.min(1, confidence2)),
           required_followups: followups,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         };
@@ -513266,8 +513266,8 @@ ${lines.join("\n")}`,
           const omniusDir = omniusDirs.find((d2) => fsExists(d2));
           if (!omniusDir)
             return;
-          const es = new EpisodeStore3(pathJoin(omniusDir, "memory.db"));
-          const tg = new TemporalGraph3(pathJoin(omniusDir, "kg.db"));
+          const es = new EpisodeStore3(pathJoin(omniusDir, "episodes.db"));
+          const tg = new TemporalGraph3(pathJoin(omniusDir, "knowledge.db"));
           const contentParts = [];
           if (episode.social?.personName)
             contentParts.push(`Met ${episode.social.personName}`);
@@ -513292,6 +513292,7 @@ ${lines.join("\n")}`,
             decayClass: episode.social?.personName ? "permanent" : "daily",
             metadata: {
               multimodal_episode_id: episode.id,
+              media_path: episode.visual?.imagePath || episode.audio?.recordingPath,
               has_face: (episode.visual?.faceIds?.length ?? 0) > 0,
               has_audio: !!episode.audio?.recordingPath,
               has_gps: !!episode.spatial?.gps
@@ -513299,7 +513300,7 @@ ${lines.join("\n")}`,
           });
           if (episode.visual?.clipEmbedding) {
             const emb = new Float32Array(episode.visual.clipEmbedding);
-            es.setEmbedding(epId, emb);
+            es.setClipEmbedding(epId, emb);
           }
           if (episode.social?.personName) {
             const personId = tg.upsertNode({ text: episode.social.personName, nodeType: "person" });
@@ -522132,7 +522133,7 @@ function parseModeCollapseVerdict(rawResponse) {
   ];
   const category = typeof parsed.category === "string" && validCategories.includes(parsed.category) ? parsed.category : "healthy";
   const diagnosis = typeof parsed.diagnosis === "string" && parsed.diagnosis.trim().length > 0 ? parsed.diagnosis.slice(0, 500) : "(no diagnosis)";
-  const confidence = typeof parsed.confidence === "number" ? Math.max(0, Math.min(1, parsed.confidence)) : 0;
+  const confidence2 = typeof parsed.confidence === "number" ? Math.max(0, Math.min(1, parsed.confidence)) : 0;
   const validActions = [
     "none",
     "abort_and_retry_no_think",
@@ -522143,7 +522144,7 @@ function parseModeCollapseVerdict(rawResponse) {
   return {
     category,
     diagnosis,
-    confidence,
+    confidence: confidence2,
     suggested_action,
     raw: rawResponse,
     parseFallback: false
@@ -524663,6 +524664,262 @@ var init_temporalGraph = __esm({
   }
 });
 
+// packages/memory/dist/multimodalIdentity.js
+import { createHash as createHash11 } from "node:crypto";
+function stableHash(value2) {
+  return createHash11("sha256").update(value2).digest("hex").slice(0, 24);
+}
+function normalizeAtom(value2) {
+  return value2.trim().toLowerCase().replace(/\s+/g, " ");
+}
+function displaySender(sender) {
+  if (!sender)
+    return "unknown";
+  return sender.displayName || sender.username || sender.id || "unknown";
+}
+function senderKey(surface, sender) {
+  const raw = sender.id || sender.username || sender.displayName || "unknown";
+  return `${surface}_user:${normalizeAtom(String(raw))}`;
+}
+function scopeKey(scope) {
+  return `scope:${normalizeAtom(scope.kind)}:${normalizeAtom(scope.id)}`;
+}
+function messageKey(surface, scope, message2) {
+  const raw = message2.id != null ? `${surface}:${scope.kind}:${scope.id}:${message2.id}` : `${surface}:${scope.kind}:${scope.id}:${message2.text || message2.timestamp || "message"}`;
+  return `message:${stableHash(raw)}`;
+}
+function mediaKey(media) {
+  const raw = media.sha256 || media.fileUniqueId || media.fileId || media.path || JSON.stringify(media);
+  return `media:${stableHash(raw)}`;
+}
+function identityKey(name10) {
+  return `person:${normalizeAtom(name10)}`;
+}
+function voiceSampleKey(media, message2) {
+  const raw = media?.sha256 || media?.fileUniqueId || media?.fileId || media?.path || message2?.id || "voice";
+  return `voice_sample:${stableHash(String(raw))}`;
+}
+function toFloat32(value2) {
+  if (!value2)
+    return null;
+  if (value2 instanceof Float32Array)
+    return value2;
+  if (!Array.isArray(value2) || value2.length === 0)
+    return null;
+  return new Float32Array(value2);
+}
+function confidence(value2, fallback = 0.75) {
+  if (typeof value2 !== "number" || !Number.isFinite(value2))
+    return fallback;
+  return Math.max(0, Math.min(1, value2));
+}
+function cleanStrings(values) {
+  if (!Array.isArray(values))
+    return [];
+  return values.map((v) => String(v || "").trim()).filter(Boolean);
+}
+function defaultScope(input) {
+  return input.scope && input.scope.id ? input.scope : { kind: "global", id: input.sourceSurface || "api" };
+}
+function buildEpisodeContent(input) {
+  if (input.content && input.content.trim())
+    return input.content;
+  if (input.transcript && input.transcript.trim())
+    return input.transcript;
+  if (input.extractedContent && input.extractedContent.trim())
+    return input.extractedContent;
+  const media = input.media;
+  if (media?.caption)
+    return media.caption;
+  if (media?.path)
+    return media.path;
+  return `${input.modality || "text"} memory event`;
+}
+var MultimodalIdentityService;
+var init_multimodalIdentity = __esm({
+  "packages/memory/dist/multimodalIdentity.js"() {
+    "use strict";
+    MultimodalIdentityService = class {
+      episodeStore;
+      graph;
+      socialMemory;
+      constructor(options2) {
+        this.episodeStore = options2.episodeStore;
+        this.graph = options2.graph;
+        this.socialMemory = options2.socialMemory ?? null;
+      }
+      ingest(input) {
+        const sourceSurface = input.sourceSurface || "api";
+        const scope = defaultScope(input);
+        const modality = input.modality || (input.media ? "visual" : "text");
+        const labels = cleanStrings(input.labels);
+        const media = input.media;
+        const message2 = input.message;
+        const sender = input.sender;
+        const content = buildEpisodeContent(input);
+        const metadata = {
+          mmidVersion: 1,
+          sourceSurface,
+          scope,
+          sender,
+          message: message2,
+          replyTo: input.replyTo,
+          media,
+          labels,
+          transcript: input.transcript,
+          extractedContent: input.extractedContent,
+          identityAssertions: input.identityAssertions || [],
+          embeddingSpaces: this.embeddingSpaces(input.embeddings)
+        };
+        const episodeId = this.episodeStore.insert({
+          modality,
+          content,
+          metadata,
+          toolName: "multimodal_identity_ingest",
+          decayClass: modality === "social" ? "permanent" : void 0
+        });
+        this.persistPrimaryEmbeddings(episodeId, input.embeddings, modality);
+        const result = { episodeId, nodeIds: {}, edges: [] };
+        const addEdge = (srcId, dstId, relation, fact, relConfidence = 1) => {
+          this.graph.addEdge({
+            srcId,
+            dstId,
+            relation,
+            fact,
+            confidence: relConfidence,
+            sourceEpisodeId: episodeId,
+            modality
+          });
+          result.edges.push({ srcId, dstId, relation });
+        };
+        const scopeId = this.graph.upsertNode({ text: scopeKey(scope), nodeType: "entity" });
+        result.nodeIds.scope = scopeId;
+        let senderId;
+        if (sender) {
+          senderId = this.graph.upsertNode({ text: senderKey(sourceSurface, sender), nodeType: "person" });
+          result.nodeIds.sender = senderId;
+          this.socialMemory?.upsertAgent({
+            id: senderKey(sourceSurface, sender),
+            name: displaySender(sender),
+            type: "human",
+            metadata: { sourceSurface, scope }
+          });
+        }
+        let messageId;
+        if (message2) {
+          messageId = this.graph.upsertNode({ text: messageKey(sourceSurface, scope, message2), nodeType: "event" });
+          result.nodeIds.message = messageId;
+          addEdge(scopeId, messageId, "contains", message2.text || content);
+          if (senderId)
+            addEdge(messageId, senderId, "authored_by", message2.text || content);
+        }
+        let mediaId;
+        if (media) {
+          mediaId = this.graph.upsertNode({ text: mediaKey(media), nodeType: "entity" });
+          result.nodeIds.media = mediaId;
+          if (messageId)
+            addEdge(messageId, mediaId, "contains", media.caption || media.path);
+          if (senderId)
+            addEdge(senderId, mediaId, "uploaded_by", media.caption || media.path);
+        }
+        if (input.replyTo) {
+          const replyMessageId = this.graph.upsertNode({ text: messageKey(sourceSurface, scope, input.replyTo), nodeType: "event" });
+          result.nodeIds.replyTo = replyMessageId;
+          if (messageId)
+            addEdge(messageId, replyMessageId, "replied_to", input.replyTo.text);
+          if (input.replyTo.sender) {
+            const replySenderId = this.graph.upsertNode({ text: senderKey(sourceSurface, input.replyTo.sender), nodeType: "person" });
+            result.nodeIds.replySender = replySenderId;
+            addEdge(replyMessageId, replySenderId, "authored_by", input.replyTo.text);
+          }
+        }
+        this.applyIdentityAssertions(input, result, mediaId, messageId, senderId, addEdge);
+        if (modality === "audio" && senderId) {
+          const voiceId = this.graph.upsertNode({ text: voiceSampleKey(media, message2), nodeType: "entity" });
+          result.nodeIds.voiceSample = voiceId;
+          addEdge(voiceId, senderId, "speaker_candidate", input.transcript || content, 0.85);
+          if (input.embeddings?.speaker || input.embeddings?.native) {
+            addEdge(voiceId, senderId, "voice_sample_of", input.transcript || content, 0.85);
+          }
+        }
+        if (input.transcript && input.transcript.trim()) {
+          const transcriptMeta = { ...metadata, sourceEpisodeId: episodeId, transcriptOf: episodeId };
+          const transcriptEpisodeId = this.episodeStore.insert({
+            modality: "text",
+            content: input.transcript,
+            metadata: transcriptMeta,
+            toolName: "transcribe_file",
+            sourceEpisodeId: episodeId
+          });
+          const transcriptEmbedding = toFloat32(input.embeddings?.transcript);
+          if (transcriptEmbedding)
+            this.episodeStore.setEmbedding(transcriptEpisodeId, transcriptEmbedding);
+          result.transcriptEpisodeId = transcriptEpisodeId;
+          if (messageId && senderId)
+            addEdge(messageId, senderId, "said_by", input.transcript, 0.9);
+        }
+        return result;
+      }
+      applyIdentityAssertions(input, result, mediaId, messageId, senderId, addEdge) {
+        const assertions = input.identityAssertions || [];
+        for (const assertion of assertions) {
+          const name10 = assertion.name?.trim();
+          if (!name10)
+            continue;
+          const personId = this.graph.upsertNode({ text: identityKey(name10), nodeType: "person" });
+          result.nodeIds[`identity:${normalizeAtom(name10)}`] = personId;
+          const target = mediaId || messageId || senderId;
+          const fact = assertion.note || input.content || input.media?.caption || input.replyTo?.text || void 0;
+          const relConfidence = confidence(assertion.confidence);
+          if (target) {
+            const relation = assertion.relation === "speaker" ? "speaker_candidate" : assertion.relation === "same_person_candidate" ? "same_person_candidate" : "named_as";
+            addEdge(target, personId, relation, fact, relConfidence);
+            if ((input.modality === "visual" || input.media?.mediaType === "photo") && relation !== "speaker_candidate") {
+              addEdge(target, personId, "depicts", fact, relConfidence);
+            }
+          }
+          if (assertion.assertedBy) {
+            const assertedById = this.graph.upsertNode({ text: senderKey(input.sourceSurface || "api", assertion.assertedBy), nodeType: "person" });
+            result.nodeIds[`assertedBy:${normalizeAtom(displaySender(assertion.assertedBy))}`] = assertedById;
+            addEdge(assertedById, personId, "related_to", fact, relConfidence);
+          }
+        }
+      }
+      persistPrimaryEmbeddings(episodeId, embeddings, modality) {
+        if (!episodeId || !embeddings)
+          return;
+        const native = toFloat32(embeddings.native);
+        const speaker = toFloat32(embeddings.speaker);
+        const clip2 = toFloat32(embeddings.clip) || toFloat32(embeddings.imageClip) || toFloat32(embeddings.textClip);
+        if (clip2)
+          this.episodeStore.setClipEmbedding(episodeId, clip2);
+        if (native)
+          this.episodeStore.setEmbedding(episodeId, native);
+        else if (modality === "audio" && speaker)
+          this.episodeStore.setEmbedding(episodeId, speaker);
+      }
+      embeddingSpaces(embeddings) {
+        if (!embeddings)
+          return {};
+        const spaces = {};
+        if (embeddings.native)
+          spaces.native = "native";
+        if (embeddings.clip)
+          spaces.clip = "openclip-compatible";
+        if (embeddings.imageClip)
+          spaces.imageClip = "openclip-image";
+        if (embeddings.textClip)
+          spaces.textClip = "openclip-text";
+        if (embeddings.speaker)
+          spaces.speaker = "speaker-embedding";
+        if (embeddings.transcript)
+          spaces.transcript = "text-embedding";
+        return spaces;
+      }
+    };
+  }
+});
+
 // packages/memory/dist/gistCompressor.js
 function compressToGist(episodes, taskDescription) {
   if (episodes.length === 0) {
@@ -525063,14 +525320,14 @@ var init_proceduralMemoryStore = __esm({
       }
       // ── Links ───────────────────────────────────────────────────────────
       /** Create a link between two memories. */
-      createLink(sourceId, targetId, linkType = "related", confidence = 0.5) {
+      createLink(sourceId, targetId, linkType = "related", confidence2 = 0.5) {
         const id = randomUUID10();
         const now = (/* @__PURE__ */ new Date()).toISOString();
         this.db.prepare(`
       INSERT INTO memory_link (id, source_id, target_id, link_type, confidence, created_at)
       VALUES (?, ?, ?, ?, ?, ?)
-    `).run(id, sourceId, targetId, linkType, confidence, now);
-        return { id, sourceId, targetId, linkType, confidence, createdAt: now };
+    `).run(id, sourceId, targetId, linkType, confidence2, now);
+        return { id, sourceId, targetId, linkType, confidence: confidence2, createdAt: now };
       }
       /** Find memories linked to the given memory ID. */
       findLinked(memoryId, limit = 5) {
@@ -528060,13 +528317,13 @@ function remDream(db, options2 = {}) {
     } catch {
     }
     let chosen = null;
-    const seedFloat = toFloat32(seedEmb);
+    const seedFloat = toFloat322(seedEmb);
     if (seedFloat) {
       const distantCandidates = candidateRows.slice(walkDepth);
       let bestSim = minSim;
       let bestId = null;
       for (const cand of distantCandidates) {
-        const candFloat = toFloat32(cand.embedding);
+        const candFloat = toFloat322(cand.embedding);
         if (!candFloat || candFloat.length !== seedFloat.length)
           continue;
         const sim = cosineSim(seedFloat, candFloat);
@@ -528286,7 +528543,7 @@ function emptyCycle(phase, start2) {
     integratedNodes: []
   };
 }
-function toFloat32(raw) {
+function toFloat322(raw) {
   if (raw == null)
     return null;
   if (raw instanceof Float32Array) {
@@ -528745,7 +529002,7 @@ var init_memoryStageContext = __esm({
 });
 
 // packages/memory/dist/sessionGist.js
-import { createHash as createHash11 } from "node:crypto";
+import { createHash as createHash12 } from "node:crypto";
 function inferDomain(input) {
   const blob = [
     input.goal,
@@ -528770,7 +529027,7 @@ function inferDomain(input) {
   return ranked[0][0];
 }
 function computeGoalHash(goal) {
-  return createHash11("sha256").update(goal.trim().toLowerCase()).digest("hex").slice(0, 16);
+  return createHash12("sha256").update(goal.trim().toLowerCase()).digest("hex").slice(0, 16);
 }
 function clip(text, n2) {
   if (!text)
@@ -528981,12 +529238,12 @@ var init_toolOutcomes = __esm({
 });
 
 // packages/memory/dist/stagnationRecipes.js
-import { createHash as createHash12 } from "node:crypto";
+import { createHash as createHash13 } from "node:crypto";
 function fingerprintSignature(fp) {
   const normClusters = (fp.errorClusters ?? []).map((s2) => (s2 || "").toLowerCase().replace(/[0-9]+/g, "N").replace(/\s+/g, " ").trim()).filter(Boolean).sort();
   const tool = (fp.stuckTool ?? "").toLowerCase().trim();
   const blob = `tool=${tool};clusters=${normClusters.join("|")}`;
-  return createHash12("sha256").update(blob).digest("hex").slice(0, 16);
+  return createHash13("sha256").update(blob).digest("hex").slice(0, 16);
 }
 function crystallize(store2, input) {
   const sig = fingerprintSignature(input.fingerprint);
@@ -529043,7 +529300,7 @@ var init_stagnationRecipes = __esm({
 });
 
 // packages/memory/dist/codebaseMap.js
-import { createHash as createHash13, randomUUID as randomUUID12 } from "node:crypto";
+import { createHash as createHash14, randomUUID as randomUUID12 } from "node:crypto";
 function freshNodeId() {
   return randomUUID12();
 }
@@ -529057,7 +529314,7 @@ var init_codebaseMap = __esm({
       touchCount = /* @__PURE__ */ new Map();
       constructor(db, repoRoot, commitSha) {
         this.db = db;
-        this.repoFp = createHash13("sha256").update(`${repoRoot}::${commitSha ?? "no-commit"}`).digest("hex").slice(0, 16);
+        this.repoFp = createHash14("sha256").update(`${repoRoot}::${commitSha ?? "no-commit"}`).digest("hex").slice(0, 16);
         this.ensureSchema();
       }
       ensureSchema() {
@@ -529193,7 +529450,7 @@ var init_codebaseMap = __esm({
       }
       /** Stable composite id: `<kind>:<sha16(path)>` so insert ON CONFLICT works. */
       idFor(kind, path11) {
-        const h = createHash13("sha256").update(`${this.repoFp}:${kind}:${path11}`).digest("hex").slice(0, 24);
+        const h = createHash14("sha256").update(`${this.repoFp}:${kind}:${path11}`).digest("hex").slice(0, 24);
         return `${kind}-${h}`;
       }
     };
@@ -529332,6 +529589,7 @@ __export(dist_exports2, {
   FailureStore: () => FailureStore,
   FileSummaryStore: () => FileSummaryStore,
   MemoryStageContext: () => MemoryStageContext,
+  MultimodalIdentityService: () => MultimodalIdentityService,
   PatchHistoryStore: () => PatchHistoryStore,
   PredictionStore: () => PredictionStore,
   ProceduralMemoryStore: () => ProceduralMemoryStore,
@@ -529428,6 +529686,7 @@ var init_dist7 = __esm({
     init_toolPatternStore();
     init_episodeStore();
     init_temporalGraph();
+    init_multimodalIdentity();
     init_zettelkasten();
     init_gistCompressor();
     init_pprRetrieval();
@@ -529512,7 +529771,7 @@ var init_reflectionBuffer = __esm({
         const taskFingerprint = this.computeFingerprint(taskGoal);
         const errorType = this.classifyError(toolCallLog, failedApproaches, lastError, turnsSpent);
         const failedTools = [...new Set(toolCallLog.filter((t2) => !t2.success).map((t2) => t2.tool))].slice(0, 5);
-        const { whatFailed, whatToDoDifferently, confidence } = this.generateGuidance(errorType, failedApproaches, toolCallLog, lastError, turnsSpent);
+        const { whatFailed, whatToDoDifferently, confidence: confidence2 } = this.generateGuidance(errorType, failedApproaches, toolCallLog, lastError, turnsSpent);
         const reflection = {
           timestamp: Date.now(),
           sessionId,
@@ -529524,7 +529783,7 @@ var init_reflectionBuffer = __esm({
           failedTools,
           failedPaths: (failedPaths ?? []).slice(0, 5),
           turnsSpent,
-          confidence
+          confidence: confidence2
         };
         this.state.reflections.unshift(reflection);
         this.state.totalFailures++;
@@ -531651,7 +531910,7 @@ import { existsSync as existsSync72, readFileSync as readFileSync56, statSync as
 import { execSync as execSync45 } from "node:child_process";
 import { homedir as homedir23, platform as platform2, arch as arch2, totalmem as totalmem2, freemem as freemem2, hostname as hostname3 } from "node:os";
 import { join as join86 } from "node:path";
-import { createHash as createHash14 } from "node:crypto";
+import { createHash as createHash15 } from "node:crypto";
 function capturePreflightSnapshot(workingDir) {
   const warnings = [];
   const configFingerprints = {};
@@ -531818,7 +532077,7 @@ function expandPath(p2) {
   return p2;
 }
 function sha2563(s2) {
-  return createHash14("sha256").update(s2).digest("hex").slice(0, 16);
+  return createHash15("sha256").update(s2).digest("hex").slice(0, 16);
 }
 function freeDiskBytes(path11 = "/tmp") {
   try {
@@ -537834,8 +538093,8 @@ If you're stuck, try a completely different approach. Do NOT repeat what failed
               if (process.env["OMNIUS_DISABLE_ADAPTIVE_RETRIEVAL"] !== "1") {
                 const goalForSig = (this._taskState.goal || "").slice(0, 200);
                 const recentTools = this._toolSequence.slice(-5).join("|");
-                const { createHash: createHash24 } = await import("node:crypto");
-                const sig = createHash24("sha256").update(`${goalForSig}::${recentTools}`).digest("hex").slice(0, 16);
+                const { createHash: createHash25 } = await import("node:crypto");
+                const sig = createHash25("sha256").update(`${goalForSig}::${recentTools}`).digest("hex").slice(0, 16);
                 if (this._lastPprSig === sig && this._lastPprMemoryLines.length > 0) {
                   compacted.push({
                     role: "system",
@@ -542949,11 +543208,11 @@ ${trimmedNew}`;
         }
         while (this._littlemanToolOutcomes.length > 20)
           this._littlemanToolOutcomes.shift();
-        const emitReaction = (cls, shortText, confidence, details2) => {
+        const emitReaction = (cls, shortText, confidence2, details2) => {
           this.emit({
             type: "observer_reaction",
             timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-            observer: { class: cls, shortText, confidence, details: details2 }
+            observer: { class: cls, shortText, confidence: confidence2, details: details2 }
           });
         };
         const lastAssistant = [...recent].reverse().find((m2) => m2.role === "assistant" && typeof m2.content === "string");
@@ -545528,14 +545787,14 @@ function extractConstraint(message2) {
     trigger = "shell";
   }
   const id = `learned-${Date.now().toString(36)}`;
-  const confidence = pattern.length > 15 ? 0.8 : 0.5;
+  const confidence2 = pattern.length > 15 ? 0.8 : 0.5;
   return {
     id,
     trigger,
     pattern,
     message: `Learned from user correction: "${message2.slice(0, 100)}"`,
     source: `user correction ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}`,
-    confidence
+    confidence: confidence2
   };
 }
 var CORRECTION_PATTERNS;
@@ -549697,7 +549956,14 @@ function ensureEmbedDeps() {
   ];
   const ins = spawnSync6(pip, ["install", "--upgrade", ...asrPkgs], { encoding: "utf8", timeout: 9e5 });
   log22 += ins.stdout + ins.stderr;
-  const ok2 = ins.status === 0 && up.status === 0;
+  let fullOk = true;
+  if (process.env["OMNIUS_INSTALL_FULL_EMBED_DEPS"] === "1") {
+    const fullPkgs = ["torch", "torchaudio", "open_clip_torch", "speechbrain"];
+    const full = spawnSync6(pip, ["install", "--upgrade", ...fullPkgs], { encoding: "utf8", timeout: 18e5 });
+    log22 += full.stdout + full.stderr;
+    fullOk = full.status === 0;
+  }
+  const ok2 = ins.status === 0 && up.status === 0 && fullOk;
   return { ok: ok2, log: log22 };
 }
 function runEmbedImage(input) {
@@ -552927,7 +553193,7 @@ var require_websocket3 = __commonJS({
     var http6 = __require("http");
     var net5 = __require("net");
     var tls2 = __require("tls");
-    var { randomBytes: randomBytes26, createHash: createHash24 } = __require("crypto");
+    var { randomBytes: randomBytes26, createHash: createHash25 } = __require("crypto");
     var { Duplex: Duplex3, Readable } = __require("stream");
     var { URL: URL3 } = __require("url");
     var PerMessageDeflate3 = require_permessage_deflate3();
@@ -553587,7 +553853,7 @@ var require_websocket3 = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest3 = createHash24("sha1").update(key + GUID).digest("base64");
+        const digest3 = createHash25("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest3) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -553954,7 +554220,7 @@ var require_websocket_server2 = __commonJS({
     var EventEmitter13 = __require("events");
     var http6 = __require("http");
     var { Duplex: Duplex3 } = __require("stream");
-    var { createHash: createHash24 } = __require("crypto");
+    var { createHash: createHash25 } = __require("crypto");
     var extension3 = require_extension3();
     var PerMessageDeflate3 = require_permessage_deflate3();
     var subprotocol3 = require_subprotocol2();
@@ -554255,7 +554521,7 @@ var require_websocket_server2 = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest3 = createHash24("sha1").update(key + GUID).digest("base64");
+        const digest3 = createHash25("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -557483,14 +557749,14 @@ var init_voice_session = __esm({
 });
 
 // packages/cli/src/tui/scoped-personality.ts
-import { createHash as createHash15 } from "node:crypto";
+import { createHash as createHash16 } from "node:crypto";
 import { existsSync as existsSync79, mkdirSync as mkdirSync45, readFileSync as readFileSync62, writeFileSync as writeFileSync40 } from "node:fs";
 import { join as join95, resolve as resolve35 } from "node:path";
 function safeName(input) {
   return input.replace(/[^A-Za-z0-9_.-]/g, "-").slice(0, 80) || "default";
 }
 function scopeHash(scope) {
-  return createHash15("sha1").update(`${scope.kind}:${scope.id}`).digest("hex").slice(0, 16);
+  return createHash16("sha1").update(`${scope.kind}:${scope.id}`).digest("hex").slice(0, 16);
 }
 function scopedPersonalityDir(repoRoot, kind) {
   return resolve35(repoRoot, ".omnius", "scoped-personality", kind);
@@ -559331,7 +559597,7 @@ var init_types = __esm({
 });
 
 // packages/cli/src/tui/p2p/secret-vault.ts
-import { createCipheriv as createCipheriv3, createDecipheriv as createDecipheriv3, randomBytes as randomBytes19, scryptSync as scryptSync2, createHash as createHash16 } from "node:crypto";
+import { createCipheriv as createCipheriv3, createDecipheriv as createDecipheriv3, randomBytes as randomBytes19, scryptSync as scryptSync2, createHash as createHash17 } from "node:crypto";
 import { readFileSync as readFileSync64, writeFileSync as writeFileSync42, existsSync as existsSync81, mkdirSync as mkdirSync47 } from "node:fs";
 import { dirname as dirname25 } from "node:path";
 var PLACEHOLDER_PREFIX, PLACEHOLDER_SUFFIX, CIPHER_ALGO, SALT_LEN, IV_LEN, KEY_LEN, SecretVault;
@@ -559576,7 +559842,7 @@ var init_secret_vault = __esm({
       /** Generate a deterministic fingerprint of vault contents (for sync verification) */
       fingerprint() {
         const names = Array.from(this.secrets.keys()).sort();
-        const hash = createHash16("sha256");
+        const hash = createHash17("sha256");
         for (const name10 of names) {
           hash.update(name10 + ":");
           hash.update(this.secrets.get(name10).value);
@@ -559591,7 +559857,7 @@ var init_secret_vault = __esm({
 // packages/cli/src/tui/p2p/peer-mesh.ts
 import { EventEmitter as EventEmitter7 } from "node:events";
 import { createServer as createServer5 } from "node:http";
-import { randomBytes as randomBytes20, createHash as createHash17, generateKeyPairSync } from "node:crypto";
+import { randomBytes as randomBytes20, createHash as createHash18, generateKeyPairSync } from "node:crypto";
 var PING_INTERVAL_MS, PEER_TIMEOUT_MS, GOSSIP_INTERVAL_MS, MAX_PEERS, PeerMesh;
 var init_peer_mesh = __esm({
   "packages/cli/src/tui/p2p/peer-mesh.ts"() {
@@ -559608,7 +559874,7 @@ var init_peer_mesh = __esm({
         const { publicKey: publicKey2, privateKey } = generateKeyPairSync("ed25519");
         this.publicKey = publicKey2.export({ type: "spki", format: "der" });
         this.privateKey = privateKey.export({ type: "pkcs8", format: "der" });
-        this.peerId = createHash17("sha256").update(this.publicKey).digest("base64url").slice(0, 22);
+        this.peerId = createHash18("sha256").update(this.publicKey).digest("base64url").slice(0, 22);
         this.capabilities = options2.capabilities;
         this.displayName = options2.displayName;
         this._authKey = options2.authKey ?? randomBytes20(24).toString("base64url");
@@ -561331,7 +561597,7 @@ __export(omnius_directory_exports, {
 import { cpSync, existsSync as existsSync83, mkdirSync as mkdirSync48, readFileSync as readFileSync66, writeFileSync as writeFileSync43, readdirSync as readdirSync26, statSync as statSync29, unlinkSync as unlinkSync14, openSync as openSync2, closeSync as closeSync2, renameSync as renameSync3 } from "node:fs";
 import { join as join100, relative as relative9, basename as basename17, dirname as dirname28 } from "node:path";
 import { homedir as homedir27 } from "node:os";
-import { createHash as createHash18 } from "node:crypto";
+import { createHash as createHash19 } from "node:crypto";
 function findGitRoot(startDir) {
   let dir = startDir;
   const visited = /* @__PURE__ */ new Set();
@@ -561712,7 +561978,7 @@ function buildHandoffPrompt(repoRoot) {
   return lines.join("\n");
 }
 function computeDedupeHash(task, savedAt) {
-  return createHash18("sha256").update(`${task}|${savedAt}`).digest("hex").slice(0, 16);
+  return createHash19("sha256").update(`${task}|${savedAt}`).digest("hex").slice(0, 16);
 }
 function generateSessionId() {
   const timestamp = Date.now().toString(36);
@@ -599754,7 +600020,7 @@ var init_vision_ingress = __esm({
 import { mkdirSync as mkdirSync61, existsSync as existsSync106, unlinkSync as unlinkSync21, readdirSync as readdirSync36, statSync as statSync36, statfsSync as statfsSync3, readFileSync as readFileSync87, writeFileSync as writeFileSync56 } from "node:fs";
 import { join as join121, resolve as resolve40, basename as basename25, relative as relative13, isAbsolute as isAbsolute7, extname as extname15 } from "node:path";
 import { writeFile as writeFileAsync } from "node:fs/promises";
-import { createHash as createHash19, randomInt } from "node:crypto";
+import { createHash as createHash20, randomInt } from "node:crypto";
 function parseTelegramInteractionDecision(text, forcedRoute, options2 = {}) {
   const cleaned = stripTelegramHiddenThinking(text).replace(/```(?:json)?/gi, "").replace(/```/g, "").trim();
   const jsonText = cleaned.startsWith("{") ? cleaned : cleaned.match(/\{[\s\S]*\}/)?.[0] ?? "";
@@ -599767,7 +600033,7 @@ function parseTelegramInteractionDecision(text, forcedRoute, options2 = {}) {
     const shouldReplyRaw = parsed["should_reply"] ?? parsed["shouldReply"];
     const shouldReply = typeof shouldReplyRaw === "boolean" ? shouldReplyRaw : options2.defaultShouldReply ?? true;
     const confidenceRaw = Number(parsed["confidence"]);
-    const confidence = Number.isFinite(confidenceRaw) ? Math.max(0, Math.min(1, confidenceRaw)) : 0;
+    const confidence2 = Number.isFinite(confidenceRaw) ? Math.max(0, Math.min(1, confidenceRaw)) : 0;
     const reason = String(parsed["reason"] ?? "live inference decision").slice(0, 240);
     const attentionDeltaRaw = Number(parsed["attention_delta"] ?? parsed["attentionDelta"]);
     const attentionScoreRaw = Number(parsed["attention_score"] ?? parsed["attentionScore"]);
@@ -599776,7 +600042,7 @@ function parseTelegramInteractionDecision(text, forcedRoute, options2 = {}) {
     return {
       route,
       shouldReply,
-      confidence,
+      confidence: confidence2,
       reason,
       source: forcedRoute ? "forced-mode" : "live-inference",
       raw: text,
@@ -600068,7 +600334,7 @@ function buildTelegramRuntimeContext(now = /* @__PURE__ */ new Date(), repoRoot)
   ].filter(Boolean).join("\n");
 }
 function telegramSessionIdFromKey(sessionKey) {
-  return `telegram-${createHash19("sha1").update(sessionKey).digest("hex").slice(0, 16)}`;
+  return `telegram-${createHash20("sha1").update(sessionKey).digest("hex").slice(0, 16)}`;
 }
 function selectTelegramFinalResponse(args) {
   const committedVisibleReply = cleanTelegramVisibleReply(args.visibleReplyText || "");
@@ -601123,7 +601389,7 @@ Telegram response contract:
         return !!this.adminAuthChallenge && this.adminAuthChallenge.expiresAtMs > Date.now();
       }
       hashAdminAuthCode(code8) {
-        return createHash19("sha256").update(`omnius-telegram-admin:${code8.trim()}`).digest("hex");
+        return createHash20("sha256").update(`omnius-telegram-admin:${code8.trim()}`).digest("hex");
       }
       viewIdForMessage(msg) {
         return `telegram-${this.sessionKeyForMessage(msg).replace(/[^A-Za-z0-9_-]/g, "-")}`;
@@ -601371,8 +601637,97 @@ ${mediaContext}` : ""
         const preview = truncateTelegramContextLine(reply.quote || reply.text || reply.caption || reply.mediaSummary || reply.originSummary || reply.kind, 160);
         return `reply: ${current} -> ${target}${selfMarker}${id}${preview ? `: "${preview}"` : ""}`;
       }
+      telegramMemorySenderFromMessage(msg) {
+        return {
+          id: String(msg.fromUserId),
+          username: msg.username,
+          displayName: msg.firstName || msg.username,
+          isBot: false
+        };
+      }
+      telegramMemorySenderFromReply(msg) {
+        const sender = msg.replyContext?.sender;
+        if (!sender && !msg.replyToUsername) return void 0;
+        return {
+          id: sender?.id !== void 0 ? String(sender.id) : void 0,
+          username: sender?.username || msg.replyToUsername,
+          displayName: sender?.firstName || sender?.title || sender?.username || msg.replyToUsername,
+          isBot: Boolean(sender?.isBot || msg.replyToBot)
+        };
+      }
+      telegramMemoryScope(msg) {
+        return {
+          kind: msg.chatType === "private" ? "private" : "group",
+          id: String(msg.chatId),
+          title: msg.chatTitle
+        };
+      }
+      telegramMemoryReplyRef(msg) {
+        const reply = this.resolveTelegramReplyContext(this.sessionKeyForMessage(msg), msg);
+        if (!reply) return void 0;
+        return {
+          id: reply.messageId,
+          threadId: reply.threadId,
+          text: reply.text || reply.caption || reply.quote || reply.mediaSummary,
+          sender: reply.sender ? {
+            id: reply.sender.id !== void 0 ? String(reply.sender.id) : void 0,
+            username: reply.sender.username,
+            displayName: reply.sender.firstName || reply.sender.title || reply.sender.username,
+            isBot: Boolean(reply.sender.isBot)
+          } : void 0,
+          mediaUniqueId: reply.media?.fileUniqueId
+        };
+      }
+      telegramMemoryIngestPayload(msg, media, localPath, source, extractedContent) {
+        const isReplyMedia = source === "reply";
+        const messageId = isReplyMedia ? msg.replyToMessageId : msg.messageId;
+        const messageText = isReplyMedia ? msg.replyContext?.text || msg.replyContext?.caption || msg.replyToText || media.caption : msg.text || media.caption;
+        const sender = isReplyMedia ? this.telegramMemorySenderFromReply(msg) : this.telegramMemorySenderFromMessage(msg);
+        const modality = media.type === "audio" || media.type === "voice" ? "audio" : telegramMediaIsImage(media) ? "visual" : "text";
+        const payload = {
+          sourceSurface: "telegram",
+          scope: this.telegramMemoryScope(msg),
+          sender,
+          message: {
+            id: messageId,
+            threadId: msg.messageThreadId,
+            timestamp: Date.now(),
+            text: messageText
+          },
+          replyTo: !isReplyMedia ? this.telegramMemoryReplyRef(msg) : void 0,
+          modality,
+          media: {
+            path: localPath,
+            mediaType: media.type,
+            mimeType: media.mimeType || (telegramMediaIsImage(media) ? telegramImageMime(media) : void 0),
+            fileId: media.fileId,
+            fileUniqueId: media.fileUniqueId,
+            caption: media.caption
+          },
+          media_path: localPath,
+          media_type: media.type,
+          mime_type: media.mimeType,
+          file_id: media.fileId,
+          file_unique_id: media.fileUniqueId,
+          caption: media.caption,
+          message_id: messageId,
+          thread_id: msg.messageThreadId,
+          chat_id: String(msg.chatId),
+          chat_type: msg.chatType,
+          chat_title: msg.chatTitle,
+          sender_id: sender && typeof sender["id"] === "string" ? sender["id"] : void 0,
+          username: sender && typeof sender["username"] === "string" ? sender["username"] : void 0,
+          display_name: sender && typeof sender["displayName"] === "string" ? sender["displayName"] : void 0,
+          labels: [media.caption].filter(Boolean)
+        };
+        if (extractedContent) {
+          if (modality === "audio") payload.transcript = extractedContent;
+          else payload.extractedContent = extractedContent;
+        }
+        return payload;
+      }
       telegramConversationPath(sessionKey) {
-        const safe = createHash19("sha1").update(sessionKey).digest("hex").slice(0, 20);
+        const safe = createHash20("sha1").update(sessionKey).digest("hex").slice(0, 20);
         return join121(this.telegramConversationDir, `${safe}.json`);
       }
       telegramPersonalityScope(sessionKey, msg) {
@@ -601679,7 +602034,7 @@ ${mediaContext}` : ""
           const titleTags = tags.slice(0, 4);
           const title = titleTags.length > 0 ? `${speaker} / ${titleTags.join(" ")}` : `${speaker} / conversation`;
           const card = {
-            id: createHash19("sha1").update(`${sessionKey}:${now}:${speaker}:${text}`).digest("hex").slice(0, 12),
+            id: createHash20("sha1").update(`${sessionKey}:${now}:${speaker}:${text}`).digest("hex").slice(0, 12),
             title,
             notes: [],
             tags: [],
@@ -602144,7 +602499,7 @@ ${list}` : "No shared group target is currently known for this sender. Ask in th
       }
       telegramRunnerStateDir(sessionKey) {
         if (!this.repoRoot) return void 0;
-        const safe = createHash19("sha1").update(sessionKey).digest("hex").slice(0, 20);
+        const safe = createHash20("sha1").update(sessionKey).digest("hex").slice(0, 20);
         return join121(this.repoRoot, ".omnius", "telegram-runner-state", safe);
       }
       buildTelegramAdminOverviewContext(currentSessionKey) {
@@ -604154,7 +604509,7 @@ ${visionContext}]`;
             await fetch("http://127.0.0.1:11435/v1/memory/ingest", {
               method: "POST",
               headers: { "Content-Type": "application/json" },
-              body: JSON.stringify({ modality: "visual", media_path: localPath, labels: [msg.username || "unknown", caption || ""].filter(Boolean) }),
+              body: JSON.stringify(this.telegramMemoryIngestPayload(msg, media, localPath, source, cacheEntry.extractedContent)),
               signal: AbortSignal.timeout(2e3)
             });
           } catch {
@@ -604180,7 +604535,7 @@ ${visionContext}]`;
             await fetch("http://127.0.0.1:11435/v1/memory/ingest", {
               method: "POST",
               headers: { "Content-Type": "application/json" },
-              body: JSON.stringify({ modality: "audio", media_path: localPath, labels: [msg.username || "unknown"].filter(Boolean) }),
+              body: JSON.stringify(this.telegramMemoryIngestPayload(msg, media, localPath, source, transcription)),
               signal: AbortSignal.timeout(2e3)
             });
           } catch {
@@ -606318,14 +606673,14 @@ var init_access_policy = __esm({
 });
 
 // packages/cli/src/api/project-preferences.ts
-import { createHash as createHash20 } from "node:crypto";
+import { createHash as createHash21 } from "node:crypto";
 import { existsSync as existsSync109, mkdirSync as mkdirSync64, readFileSync as readFileSync90, renameSync as renameSync7, writeFileSync as writeFileSync59, unlinkSync as unlinkSync23 } from "node:fs";
 import { homedir as homedir38 } from "node:os";
 import { join as join124, resolve as resolve42 } from "node:path";
 import { randomUUID as randomUUID15 } from "node:crypto";
 function projectKey(root) {
   const canonical = resolve42(root);
-  return createHash20("sha256").update(canonical).digest("hex").slice(0, 16);
+  return createHash21("sha256").update(canonical).digest("hex").slice(0, 16);
 }
 function projectDir(root) {
   return join124(PROJECTS_DIR, projectKey(root));
@@ -606441,7 +606796,7 @@ function repeatingCharPenalty(s2) {
   if (cur > maxRun) maxRun = cur;
   return Math.min(1, Math.max(0, (maxRun - 3) / 10));
 }
-function computeSignalFromText(text, confidence) {
+function computeSignalFromText(text, confidence2) {
   const t2 = text.trim();
   if (!t2) return 0;
   if (NOISE_ONLY_RE.test(t2)) return 0.05;
@@ -606455,8 +606810,8 @@ function computeSignalFromText(text, confidence) {
   else if (wc >= 1 && alpha >= 0.3 && len >= 4) score = 0.35;
   else score = 0.15;
   score -= repeatingCharPenalty(t2) * 0.4;
-  if (typeof confidence === "number" && !Number.isNaN(confidence)) {
-    score = 0.7 * score + 0.3 * clamp017(confidence);
+  if (typeof confidence2 === "number" && !Number.isNaN(confidence2)) {
+    score = 0.7 * score + 0.3 * clamp017(confidence2);
   }
   return clamp017(score);
 }
@@ -606633,19 +606988,19 @@ Rules:
           let text;
           let isFinal;
           let snr;
-          let confidence;
+          let confidence2;
           if (typeof args[0] === "object" && args[0] !== null) {
             const evt = args[0];
             text = evt.text ?? "";
             isFinal = evt.isFinal ?? false;
             snr = evt.snr;
-            confidence = evt.confidence;
+            confidence2 = evt.confidence;
           } else {
             text = String(args[0] ?? "");
             isFinal = Boolean(args[1]);
           }
           if (!text.trim()) return;
-          this.handleTranscript(text.trim(), isFinal, snr, confidence);
+          this.handleTranscript(text.trim(), isFinal, snr, confidence2);
         };
         this._onError = (err) => {
           const msg = err instanceof Error ? err.message : String(err);
@@ -606712,7 +607067,7 @@ Rules:
       // ---------------------------------------------------------------------------
       // Transcript handling — VAD-style segment capture (Voryn pattern)
       // ---------------------------------------------------------------------------
-      handleTranscript(text, isFinal, snr, confidence) {
+      handleTranscript(text, isFinal, snr, confidence2) {
         if (!this.active) return;
         if (this._state !== "LISTENING" && this._state !== "CAPTURING") {
           return;
@@ -606728,7 +607083,7 @@ Rules:
           }, MAX_SEGMENT_MS);
         }
         this.captureBuffer = text;
-        this.lastSignalScore = typeof snr === "number" && !Number.isNaN(snr) ? clamp017(snr) : computeSignalFromText(text, confidence);
+        this.lastSignalScore = typeof snr === "number" && !Number.isNaN(snr) ? clamp017(snr) : computeSignalFromText(text, confidence2);
         this.emit("snr", { score: this.lastSignalScore });
         this.onPartialTranscript(text);
         if (this.silenceTimer) clearTimeout(this.silenceTimer);
@@ -607503,7 +607858,7 @@ var init_disk_task_output = __esm({
 });
 
 // packages/cli/src/api/http.ts
-import { createHash as createHash21 } from "node:crypto";
+import { createHash as createHash22 } from "node:crypto";
 function problemDetails(opts) {
   const p2 = {
     type: opts.type ?? "about:blank",
@@ -607566,7 +607921,7 @@ function paginated(items, page2, total) {
 }
 function computeEtag(payload) {
   const json = typeof payload === "string" ? payload : JSON.stringify(payload);
-  const hash = createHash21("sha1").update(json).digest("hex").slice(0, 16);
+  const hash = createHash22("sha1").update(json).digest("hex").slice(0, 16);
   return `W/"${hash}"`;
 }
 function checkNotModified(req2, res, etag) {
@@ -609242,16 +609597,23 @@ async function handleCallMcp(ctx3, name10) {
     return true;
   }
 }
+function memoryDbPaths(baseDir = process.cwd()) {
+  const dir = join130(baseDir, ".omnius");
+  return {
+    episodes: join130(dir, "episodes.db"),
+    knowledge: join130(dir, "knowledge.db")
+  };
+}
 async function getMemoryStores() {
   if (memoryStoresCache) return memoryStoresCache;
   if (memoryInitTried) return null;
   memoryInitTried = true;
   try {
-    const dbPath = join130(homedir42(), ".omnius", "memory.db");
-    const sharedDb = initDb(dbPath);
+    const dbPaths = memoryDbPaths();
+    const sharedDb = initDb(dbPaths.episodes);
     memoryStoresCache = {
-      episode: new EpisodeStore(dbPath),
-      temporal: new TemporalGraph(dbPath),
+      episode: new EpisodeStore(dbPaths.episodes),
+      temporal: new TemporalGraph(dbPaths.knowledge),
       failure: new FailureStore(sharedDb)
     };
     return memoryStoresCache;
@@ -621722,7 +622084,15 @@ import { homedir as homedir45 } from "node:os";
 import { spawn as spawn29, execSync as execSync57 } from "node:child_process";
 import { mkdirSync as mkdirSync72, writeFileSync as writeFileSync65, readFileSync as readFileSync98, readdirSync as readdirSync41, existsSync as existsSync120, watch as fsWatch3, renameSync as renameSync8, unlinkSync as unlinkSync25 } from "node:fs";
 import { randomBytes as randomBytes24, randomUUID as randomUUID16 } from "node:crypto";
-import { createHash as createHash23 } from "node:crypto";
+import { createHash as createHash24 } from "node:crypto";
+function memoryDbPaths2(baseDir = process.cwd()) {
+  const dir = join135(baseDir, ".omnius");
+  return {
+    dir,
+    episodes: join135(dir, "episodes.db"),
+    knowledge: join135(dir, "knowledge.db")
+  };
+}
 function getVersion3() {
   try {
     const thisDir = dirname37(fileURLToPath17(import.meta.url));
@@ -622087,7 +622457,7 @@ async function retrieveMemoryContext(userMessage, sessionId, maxEpisodes = 5) {
     if (!memMod || !memMod.EpisodeStore) {
       return { contextBlock: "", retrieved: [] };
     }
-    const dbPath = join135(homedir45(), ".omnius", "memory.db");
+    const dbPath = memoryDbPaths2(process.cwd()).episodes;
     const store2 = new memMod.EpisodeStore(dbPath);
     const recent = store2.search({ limit: 30, sessionId: void 0 }) ?? [];
     const qLower = userMessage.toLowerCase();
@@ -622130,7 +622500,7 @@ async function writeMemoryEpisodes(sessionId, userMessage, assistantContent, too
   try {
     const memMod = await Promise.resolve().then(() => (init_dist7(), dist_exports2)).catch(() => null);
     if (!memMod || !memMod.EpisodeStore) return 0;
-    const dbPath = join135(homedir45(), ".omnius", "memory.db");
+    const dbPath = memoryDbPaths2(process.cwd()).episodes;
     const store2 = new memMod.EpisodeStore(dbPath);
     let written = 0;
     try {
@@ -627587,7 +627957,7 @@ function listScheduledTasks() {
               const schedule = String(t2?.schedule || t2?.cron || t2?.when || "");
               const enabled2 = typeof t2?.enabled === "boolean" ? t2.enabled : true;
               const realId = typeof t2?.id === "string" && t2.id ? t2.id : null;
-              const fallbackId = createHash23("sha1").update(`${file}#${i2}`).digest("hex").slice(0, 16);
+              const fallbackId = createHash24("sha1").update(`${file}#${i2}`).digest("hex").slice(0, 16);
               const uid = realId || fallbackId;
               const key = `${uid}`;
               if (seen.has(key)) return;
@@ -627704,8 +628074,8 @@ function deleteScheduledById(id) {
     if (id) candidates.push(id);
     if (typeof entry?.id === "string" && entry.id && !candidates.includes(entry.id)) candidates.push(entry.id);
     try {
-      const { createHash: createHash24 } = require4("node:crypto");
-      const fallback = createHash24("sha1").update(`${target.file}#${target.index}`).digest("hex").slice(0, 16);
+      const { createHash: createHash25 } = require4("node:crypto");
+      const fallback = createHash25("sha1").update(`${target.file}#${target.index}`).digest("hex").slice(0, 16);
       if (!candidates.includes(fallback)) candidates.push(fallback);
     } catch {
     }
@@ -628635,9 +629005,9 @@ function startApiServer(options2 = {}) {
       try {
         const { startEmbeddingWorkers: startEmbeddingWorkers2 } = await Promise.resolve().then(() => (init_embedding_workers(), embedding_workers_exports));
         const { ensureEmbedDeps: ensureEmbedDeps2, runEmbedImage: runEmbedImage2, runEmbedAudio: runEmbedAudio2 } = await Promise.resolve().then(() => (init_py_embed(), py_embed_exports));
-        const dbBase = join135(cwd4, ".omnius");
-        const epStore = new mem.EpisodeStore(join135(dbBase, "memory.db"));
-        const kg = new mem.TemporalGraph(join135(dbBase, "kg.db"));
+        const dbPaths = memoryDbPaths2(cwd4);
+        const epStore = new mem.EpisodeStore(dbPaths.episodes);
+        const kg = new mem.TemporalGraph(dbPaths.knowledge);
         try {
           ensureEmbedDeps2();
         } catch {
@@ -629029,67 +629399,86 @@ async function handleMemoryIngest(req2, res, ollamaUrl) {
     const content = typeof b.content === "string" ? b.content : "";
     const labels = Array.isArray(b.labels) ? b.labels : [];
     const mediaPath = typeof b.media_path === "string" ? b.media_path : void 0;
-    const cwd4 = process.cwd();
-    const dbBase = join135(cwd4, ".omnius");
-    const { EpisodeStore: EpisodeStore3, TemporalGraph: TemporalGraph3 } = await Promise.resolve().then(() => (init_dist7(), dist_exports2));
-    const epStore = new EpisodeStore3(join135(dbBase, "memory.db"));
-    const kg = new TemporalGraph3(join135(dbBase, "kg.db"));
-    const meta = {};
-    if (mediaPath) meta.media_path = mediaPath;
-    const epId = epStore.insert({ modality, content: content || (mediaPath || ""), metadata: meta, toolName: "memory_ingest" });
-    if (modality === "visual" && Array.isArray(labels) && labels.length > 0) {
+    const rawMedia = typeof b.media === "object" && b.media ? { ...b.media, path: b.media.path || mediaPath } : {
+      path: mediaPath,
+      mimeType: b.mime_type,
+      mediaType: b.media_type,
+      fileId: b.file_id,
+      fileUniqueId: b.file_unique_id,
+      caption: b.caption,
+      sha256: b.sha256
+    };
+    const media = Object.values(rawMedia).some((value2) => value2 != null && String(value2).trim() !== "") ? rawMedia : void 0;
+    const sourceSurface = String(b.sourceSurface || b.source_surface || "api");
+    const scope = typeof b.scope === "object" && b.scope ? b.scope : {
+      kind: b.scope_kind || (b.chat_type === "private" ? "private" : b.chat_id ? "group" : "global"),
+      id: String(b.scope_id || b.chat_id || sourceSurface),
+      title: b.chat_title
+    };
+    const sender = typeof b.sender === "object" && b.sender ? b.sender : b.sender_id || b.username || b.display_name ? { id: b.sender_id != null ? String(b.sender_id) : void 0, username: b.username, displayName: b.display_name } : void 0;
+    const message2 = typeof b.message === "object" && b.message ? b.message : b.message_id != null || b.thread_id != null ? { id: b.message_id, threadId: b.thread_id, timestamp: b.timestamp, text: content || b.caption } : void 0;
+    const replyTo = b.replyTo || b.reply_to;
+    const identityAssertions = Array.isArray(b.identityAssertions) ? b.identityAssertions : Array.isArray(b.identity_assertions) ? b.identity_assertions : Array.isArray(b.people) ? b.people.map((name10) => ({ name: String(name10), relation: modality === "audio" ? "speaker" : "depicts", confidence: 0.8, assertedBy: sender })) : [];
+    const embeddings = {};
+    const providedEmbeddings = typeof b.embeddings === "object" && b.embeddings ? b.embeddings : {};
+    Object.assign(embeddings, providedEmbeddings);
+    if (modality === "visual" && mediaPath && !embeddings.clip && !embeddings.imageClip) {
       try {
-        const primaryLabel = String(labels[0]);
-        const personId = kg.upsertNode({ text: primaryLabel, nodeType: "person" });
-        kg.addEdge({ srcId: personId, dstId: personId, relation: "appears_in", fact: (content || mediaPath || "").slice(0, 120), modality: "visual", sourceEpisodeId: epId });
-        for (const l2 of labels.slice(1)) {
-          const aliasId = kg.upsertNode({ text: String(l2), nodeType: "person" });
-          kg.addEdge({ srcId: aliasId, dstId: personId, relation: "alias_of", modality: "text" });
-        }
+        const provider = globalThis.__omniusVisionProvider;
+        const emb = provider ? await provider({ path: mediaPath }) : null;
+        if (emb) embeddings.imageClip = emb;
+      } catch {
+      }
+    }
+    if (modality === "audio" && mediaPath && !embeddings.native && !embeddings.speaker) {
+      try {
+        const provider = globalThis.__omniusAudioProvider;
+        const emb = provider ? await provider({ path: mediaPath }) : null;
+        if (emb) embeddings.speaker = emb;
       } catch {
       }
     }
+    let transcript = typeof b.transcript === "string" ? b.transcript : "";
     if (modality === "audio" && mediaPath) {
       try {
         const { runTranscribeFile: runTranscribeFile2 } = await Promise.resolve().then(() => (init_py_embed(), py_embed_exports));
-        const text = runTranscribeFile2({ path: mediaPath, model: process.env["WHISPER_MODEL"] || "base" }) || "";
-        if (text) {
-          const personMeta = {};
-          let personId = null;
-          try {
-            const primaryLabel = labels && labels.length > 0 ? String(labels[0]) : "person";
-            personId = kg.upsertNode({ text: primaryLabel, nodeType: "person" });
-            if (Array.isArray(labels) && labels.length > 1) {
-              for (const l2 of labels.slice(1)) {
-                const aliasId = kg.upsertNode({ text: String(l2), nodeType: "person" });
-                kg.addEdge({ srcId: aliasId, dstId: personId, relation: "alias_of", modality: "text" });
-              }
-            }
-          } catch {
-          }
-          if (personId) personMeta.person_node_id = personId;
-          const textEpId = epStore.insert({ modality: "text", content: text, toolName: "transcribe_file", sourceEpisodeId: epId, metadata: personMeta });
+        transcript = transcript || runTranscribeFile2({ path: mediaPath, model: process.env["WHISPER_MODEL"] || "base" }) || "";
+        if (transcript && !embeddings.transcript) {
           try {
-            const payload = JSON.stringify({ model: process.env["EMBED_MODEL"] || "nomic-embed-text", input: text });
-            const result = await ollamaRequest(ollamaUrl, "/api/embed", "POST", payload);
-            if (result.status === 200) {
-              const parsed = JSON.parse(result.body);
+            const payload = JSON.stringify({ model: process.env["EMBED_MODEL"] || "nomic-embed-text", input: transcript });
+            const result2 = await ollamaRequest(ollamaUrl, "/api/embed", "POST", payload);
+            if (result2.status === 200) {
+              const parsed = JSON.parse(result2.body);
               const vec = Array.isArray(parsed.embeddings) && Array.isArray(parsed.embeddings[0]) ? parsed.embeddings[0] : null;
-              if (vec) epStore.setEmbedding(textEpId, new Float32Array(vec));
+              if (vec) embeddings.transcript = vec;
             }
           } catch {
           }
-          try {
-            const primaryLabel = labels && labels.length > 0 ? String(labels[0]) : "person";
-            const nodeId = personId || kg.upsertNode({ text: primaryLabel, nodeType: "person" });
-            kg.addEdge({ srcId: nodeId, dstId: nodeId, relation: "said_by", fact: text.slice(0, 160), modality: "audio", sourceEpisodeId: textEpId });
-          } catch {
-          }
         }
       } catch {
       }
     }
-    jsonResponse(res, 200, { id: epId });
+    const dbPaths = memoryDbPaths2(process.cwd());
+    const { EpisodeStore: EpisodeStore3, TemporalGraph: TemporalGraph3, MultimodalIdentityService: MultimodalIdentityService2 } = await Promise.resolve().then(() => (init_dist7(), dist_exports2));
+    const epStore = new EpisodeStore3(dbPaths.episodes);
+    const kg = new TemporalGraph3(dbPaths.knowledge);
+    const service = new MultimodalIdentityService2({ episodeStore: epStore, graph: kg });
+    const result = service.ingest({
+      sourceSurface,
+      scope,
+      sender,
+      message: message2,
+      replyTo,
+      modality,
+      content,
+      transcript,
+      extractedContent: b.extracted_content || b.extractedContent,
+      media,
+      labels,
+      identityAssertions,
+      embeddings
+    });
+    jsonResponse(res, 200, { id: result.episodeId, ...result });
   } catch (err) {
     jsonResponse(res, 400, { error: "bad_request", message: err instanceof Error ? err.message : String(err) });
   }
@@ -629100,7 +629489,7 @@ async function handleEntitiesList(req2, res) {
     const type = url.searchParams.get("type") || "person";
     const limit = Math.max(1, Math.min(1e3, parseInt(url.searchParams.get("limit") || "100", 10)));
     const { TemporalGraph: TemporalGraph3 } = await Promise.resolve().then(() => (init_dist7(), dist_exports2));
-    const kg = new TemporalGraph3(join135(process.cwd(), ".omnius", "kg.db"));
+    const kg = new TemporalGraph3(memoryDbPaths2(process.cwd()).knowledge);
     const nodes = kg.nodesByType(type, limit).map((n2) => ({ id: n2.id, text: n2.text, mentionCount: n2.mentionCount, firstSeen: n2.firstSeen, lastSeen: n2.lastSeen }));
     jsonResponse(res, 200, { object: "list", data: nodes });
   } catch (err) {
@@ -637147,13 +637536,13 @@ NEW TASK: ${fullInput}`;
       writeContent(() => renderError(errMsg));
       if (failureStore) {
         try {
-          const { createHash: createHash24 } = await import("node:crypto");
+          const { createHash: createHash25 } = await import("node:crypto");
           failureStore.insert({
             taskId: "",
             sessionId: `${Date.now()}`,
             repoRoot,
             failureType: "runtime-error",
-            fingerprint: createHash24("sha256").update(errMsg.slice(0, 200)).digest("hex").slice(0, 16),
+            fingerprint: createHash25("sha256").update(errMsg.slice(0, 200)).digest("hex").slice(0, 16),
             filePath: null,
             errorMessage: errMsg.slice(0, 500),
             context: null,