omnius 1.0.33 → 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,
@@ -599929,6 +600195,21 @@ function telegramSpeakerLabel(msg) {
   if (msg.fromUserId) return `user:${msg.fromUserId}`;
   return "Telegram user";
 }
+function telegramReplySenderLabel(sender) {
+  if (!sender) return "unknown sender";
+  if (sender.username) return `@${sender.username}`;
+  if (sender.title) return sender.title;
+  if (sender.firstName) return sender.firstName;
+  if (sender.id) return `user:${sender.id}`;
+  return "unknown sender";
+}
+function telegramReplyParameters(replyToMessageId) {
+  if (!replyToMessageId || !Number.isFinite(replyToMessageId)) return void 0;
+  return {
+    message_id: Math.floor(replyToMessageId),
+    allow_sending_without_reply: true
+  };
+}
 function telegramHistorySpeaker(entry) {
   if (entry.role === "assistant") return entry.speaker || "Assistant";
   if (entry.speaker) return entry.speaker;
@@ -600053,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 || "");
@@ -600344,6 +600625,140 @@ function normalizeTelegramMedia(message2) {
   }
   return void 0;
 }
+function telegramOptionalString(value2) {
+  return typeof value2 === "string" && value2.trim() ? value2 : void 0;
+}
+function telegramOptionalNumber(value2) {
+  return typeof value2 === "number" && Number.isFinite(value2) ? value2 : void 0;
+}
+function normalizeTelegramReplySender(message2) {
+  if (!message2) return void 0;
+  const from3 = typeof message2.from === "object" && message2.from ? message2.from : void 0;
+  const senderChat = typeof message2.sender_chat === "object" && message2.sender_chat ? message2.sender_chat : void 0;
+  const origin = typeof message2.origin === "object" && message2.origin ? message2.origin : void 0;
+  const originUser = typeof origin?.sender_user === "object" && origin.sender_user ? origin.sender_user : void 0;
+  const originChat = typeof origin?.chat === "object" && origin.chat ? origin.chat : void 0;
+  const source = from3 ?? senderChat ?? originUser ?? originChat;
+  if (!source) {
+    const senderUserName = telegramOptionalString(origin?.sender_user_name);
+    const authorSignature = telegramOptionalString(origin?.author_signature);
+    if (!senderUserName && !authorSignature) return void 0;
+    return {
+      firstName: senderUserName ?? authorSignature
+    };
+  }
+  return {
+    id: telegramOptionalNumber(source.id),
+    username: telegramOptionalString(source.username),
+    firstName: telegramOptionalString(source.first_name),
+    title: telegramOptionalString(source.title),
+    isBot: typeof source.is_bot === "boolean" ? source.is_bot : void 0
+  };
+}
+function telegramReplyTextFromMessage(message2, poll) {
+  return telegramOptionalString(message2.text) ?? telegramOptionalString(message2.caption) ?? (poll ? formatTelegramPollSummary(poll) : void 0);
+}
+function telegramReplyOriginSummary(origin) {
+  if (!origin || typeof origin !== "object") return void 0;
+  const record = origin;
+  const type = telegramOptionalString(record.type);
+  const sender = normalizeTelegramReplySender({ origin: record });
+  const label = sender?.username ? `@${sender.username}` : sender?.title ?? sender?.firstName;
+  return [type ? `origin:${type}` : "", label ? `from ${label}` : ""].filter(Boolean).join(" ") || void 0;
+}
+function normalizeTelegramQuote(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const quote = raw;
+  const text = telegramOptionalString(quote.text);
+  const position = telegramOptionalNumber(quote.position);
+  if (!text && position === void 0) return void 0;
+  return { text, position };
+}
+function normalizeTelegramReplyContext(message2) {
+  const quote = normalizeTelegramQuote(message2.quote);
+  const replyTo = message2.reply_to_message && typeof message2.reply_to_message === "object" ? message2.reply_to_message : void 0;
+  if (replyTo) {
+    const poll = normalizeTelegramPoll(replyTo.poll);
+    const media = normalizeTelegramMedia(replyTo);
+    return {
+      kind: "message",
+      source: "reply_to_message",
+      messageId: telegramOptionalNumber(replyTo.message_id),
+      chatId: normalizeTelegramChatId(replyTo.chat?.id ?? message2.chat?.id),
+      threadId: telegramOptionalNumber(replyTo.message_thread_id ?? message2.message_thread_id),
+      sender: normalizeTelegramReplySender(replyTo),
+      text: telegramReplyTextFromMessage(replyTo, poll),
+      caption: telegramOptionalString(replyTo.caption),
+      quote: quote?.text,
+      quotePosition: quote?.position,
+      media,
+      poll,
+      checklistTaskId: telegramOptionalNumber(message2.reply_to_checklist_task_id),
+      pollOptionId: telegramOptionalString(message2.reply_to_poll_option_id)
+    };
+  }
+  const externalReply = message2.external_reply && typeof message2.external_reply === "object" ? message2.external_reply : void 0;
+  if (externalReply) {
+    const poll = normalizeTelegramPoll(externalReply.poll);
+    const media = normalizeTelegramMedia(externalReply);
+    return {
+      kind: "external",
+      source: "external_reply",
+      messageId: telegramOptionalNumber(externalReply.message_id),
+      chatId: externalReply.chat?.id !== void 0 ? normalizeTelegramChatId(externalReply.chat.id) : void 0,
+      threadId: telegramOptionalNumber(message2.message_thread_id),
+      sender: normalizeTelegramReplySender(externalReply),
+      text: telegramReplyTextFromMessage(externalReply, poll),
+      caption: telegramOptionalString(externalReply.caption),
+      quote: quote?.text,
+      quotePosition: quote?.position,
+      media,
+      poll,
+      checklistTaskId: telegramOptionalNumber(message2.reply_to_checklist_task_id),
+      pollOptionId: telegramOptionalString(message2.reply_to_poll_option_id),
+      originSummary: telegramReplyOriginSummary(externalReply.origin)
+    };
+  }
+  if (quote?.text) {
+    return {
+      kind: "quote",
+      source: "quote",
+      threadId: telegramOptionalNumber(message2.message_thread_id),
+      quote: quote.text,
+      quotePosition: quote.position
+    };
+  }
+  const story = message2.reply_to_story && typeof message2.reply_to_story === "object" ? message2.reply_to_story : void 0;
+  if (story) {
+    return {
+      kind: "story",
+      source: "reply_to_story",
+      chatId: story.chat?.id !== void 0 ? normalizeTelegramChatId(story.chat.id) : void 0,
+      storyId: telegramOptionalNumber(story.id),
+      sender: normalizeTelegramReplySender(story),
+      threadId: telegramOptionalNumber(message2.message_thread_id)
+    };
+  }
+  const checklistTaskId = telegramOptionalNumber(message2.reply_to_checklist_task_id);
+  if (checklistTaskId !== void 0) {
+    return {
+      kind: "checklist_task",
+      source: "reply_to_checklist_task",
+      checklistTaskId,
+      threadId: telegramOptionalNumber(message2.message_thread_id)
+    };
+  }
+  const pollOptionId = telegramOptionalString(message2.reply_to_poll_option_id);
+  if (pollOptionId) {
+    return {
+      kind: "poll_option",
+      source: "reply_to_poll_option",
+      pollOptionId,
+      threadId: telegramOptionalNumber(message2.message_thread_id)
+    };
+  }
+  return void 0;
+}
 function telegramMediaIsImage(media) {
   if (media.type === "photo") return true;
   if (media.mimeType?.toLowerCase().startsWith("image/")) return true;
@@ -600426,10 +600841,7 @@ function normalizeTelegramUpdate(update2) {
   const username = message2.from?.username ?? message2.sender_chat?.username ?? "";
   const chatType = message2.chat?.type ?? "private";
   const media = normalizeTelegramMedia(message2);
-  const replyTo = message2.reply_to_message && typeof message2.reply_to_message === "object" ? message2.reply_to_message : void 0;
-  const replyToMedia = replyTo ? normalizeTelegramMedia(replyTo) : void 0;
-  const replyToPoll = replyTo ? normalizeTelegramPoll(replyTo.poll) : void 0;
-  const replyToText = replyTo ? replyTo.text || replyTo.caption || (replyToPoll ? formatTelegramPollSummary(replyToPoll) : "") : "";
+  const replyContext = normalizeTelegramReplyContext(message2);
   const poll = normalizeTelegramPoll(message2.poll);
   const livePhoto = normalizeTelegramLivePhoto(message2.live_photo);
   const text = message2.text || message2.caption || (poll ? formatTelegramPollSummary(poll) : "");
@@ -600444,8 +600856,6 @@ function normalizeTelegramUpdate(update2) {
     chatType,
     chatTitle: message2.chat?.title,
     media,
-    replyToMedia,
-    replyToText: replyToText || void 0,
     poll,
     livePhoto,
     guestQueryId: typeof message2.guest_query_id === "string" ? message2.guest_query_id : void 0,
@@ -600454,9 +600864,13 @@ function normalizeTelegramUpdate(update2) {
     isGuestMessage: sourceUpdateType === "guest_message",
     isDirectMessages: Boolean(message2.chat?.is_direct_messages),
     parentChatId: message2.chat?.parent_chat?.id ?? message2.direct_messages_topic?.parent_topic?.id,
-    replyToMessageId: replyTo?.message_id,
-    replyToUsername: replyTo?.from?.username ?? replyTo?.sender_chat?.username,
-    replyToBot: Boolean(replyTo?.from?.is_bot),
+    messageThreadId: telegramOptionalNumber(message2.message_thread_id),
+    replyContext,
+    replyToMedia: replyContext?.media,
+    replyToText: replyContext?.text || replyContext?.quote,
+    replyToMessageId: replyContext?.messageId,
+    replyToUsername: replyContext?.sender?.username,
+    replyToBot: Boolean(replyContext?.sender?.isBot),
     mentionedUsernames: extractTelegramMentionedUsernames(message2, text),
     sourceUpdateType
   };
@@ -600975,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, "-")}`;
@@ -601095,8 +601509,225 @@ Telegram response contract:
         }
         this.chatHistory.set(sessionKey, existing);
       }
+      telegramReplySenderWithSelfFlag(sender) {
+        if (!sender) return void 0;
+        const bot = this.state.botUsername.trim().replace(/^@/, "").toLowerCase();
+        const senderUsername = sender.username?.trim().replace(/^@/, "").toLowerCase();
+        const isSelf = Boolean(sender.isSelf || bot && senderUsername === bot);
+        return isSelf === sender.isSelf ? sender : { ...sender, isSelf };
+      }
+      telegramReplyContextFromHistoryEntry(entry) {
+        if (!entry.messageId) return void 0;
+        const sender = entry.role === "assistant" ? {
+          username: this.state.botUsername || void 0,
+          firstName: entry.speaker || "Assistant",
+          isBot: true,
+          isSelf: true
+        } : {
+          id: entry.fromUserId,
+          username: entry.username,
+          firstName: entry.firstName,
+          isBot: false
+        };
+        return {
+          kind: "message",
+          source: "local_history",
+          messageId: entry.messageId,
+          chatId: entry.chatId,
+          threadId: entry.messageThreadId,
+          sender: this.telegramReplySenderWithSelfFlag(sender),
+          text: entry.text,
+          mediaSummary: entry.mediaSummary
+        };
+      }
+      resolveTelegramReplyContext(sessionKey, msg) {
+        this.ensureTelegramConversationLoaded(sessionKey);
+        const targetId = msg.replyContext?.messageId ?? msg.replyToMessageId;
+        const history = this.chatHistory.get(sessionKey) ?? [];
+        const local = targetId ? [...history].reverse().find((entry) => entry.messageId === targetId) : void 0;
+        const localContext = local ? this.telegramReplyContextFromHistoryEntry(local) : void 0;
+        let reply;
+        if (msg.replyContext && localContext) {
+          reply = {
+            ...localContext,
+            ...msg.replyContext,
+            chatId: msg.replyContext.chatId ?? localContext.chatId,
+            threadId: msg.replyContext.threadId ?? localContext.threadId,
+            sender: this.telegramReplySenderWithSelfFlag({
+              ...localContext.sender ?? {},
+              ...msg.replyContext.sender ?? {}
+            }),
+            text: msg.replyContext.text ?? localContext.text,
+            mediaSummary: msg.replyContext.mediaSummary ?? localContext.mediaSummary
+          };
+        } else if (msg.replyContext) {
+          reply = {
+            ...msg.replyContext,
+            sender: this.telegramReplySenderWithSelfFlag(msg.replyContext.sender)
+          };
+        } else if (localContext) {
+          reply = localContext;
+        } else if (msg.replyToMessageId) {
+          reply = {
+            kind: "message",
+            source: "local_history",
+            messageId: msg.replyToMessageId,
+            threadId: msg.messageThreadId
+          };
+        }
+        return reply;
+      }
+      quoteTelegramContextBlock(text, maxLength = 1800) {
+        const clean3 = stripTelegramHiddenThinking(text).trim();
+        const clipped = clean3.length > maxLength ? `${clean3.slice(0, Math.max(0, maxLength - 60)).trimEnd()}
+[reply context truncated]` : clean3;
+        return clipped.split(/\r?\n/).map((line) => `> ${line}`).join("\n");
+      }
+      buildTelegramCurrentReplyContext(sessionKey, msg) {
+        const reply = this.resolveTelegramReplyContext(sessionKey, msg);
+        if (!reply) return "";
+        const current = telegramSpeakerLabel(msg);
+        const target = telegramReplySenderLabel(reply.sender);
+        const selfMarker = reply.sender?.isSelf ? " (bot/self)" : reply.sender?.isBot ? " (bot)" : "";
+        const targetId = reply.messageId ? ` message_id ${reply.messageId}` : "";
+        const relation = reply.kind === "external" ? "is replying to an external Telegram message" : reply.kind === "quote" ? "is replying to a quoted Telegram excerpt" : reply.kind === "story" ? "is replying to a Telegram story" : reply.kind === "checklist_task" ? "is replying to a Telegram checklist task" : reply.kind === "poll_option" ? "is replying to a Telegram poll option" : "is replying to a Telegram message";
+        const metadata = [
+          `Current message_id ${msg.messageId} from ${current} ${relation}${targetId}.`,
+          `Replied-to author: ${target}${selfMarker}.`,
+          `Reply source: ${reply.source}.`,
+          reply.chatId !== void 0 ? `Replied-to chat_id: ${String(reply.chatId)}.` : "",
+          reply.threadId !== void 0 ? `Telegram thread/topic id: ${reply.threadId}.` : "",
+          reply.originSummary ? `External origin: ${reply.originSummary}.` : "",
+          reply.storyId !== void 0 ? `Story id: ${reply.storyId}.` : "",
+          reply.checklistTaskId !== void 0 ? `Checklist task id: ${reply.checklistTaskId}.` : "",
+          reply.pollOptionId ? `Poll option id: ${reply.pollOptionId}.` : ""
+        ].filter(Boolean);
+        const content = reply.text || reply.caption;
+        const blocks = [
+          "### Current Telegram Reply Relationship",
+          metadata.join("\n"),
+          reply.quote ? `Quoted excerpt:
+${this.quoteTelegramContextBlock(reply.quote, 1e3)}` : "",
+          content ? `Replied-to content:
+${this.quoteTelegramContextBlock(content, 2200)}` : "",
+          reply.mediaSummary ? `Replied-to media: ${reply.mediaSummary}` : "",
+          reply.media && !reply.mediaSummary ? `Replied-to media: ${reply.media.type}${reply.media.fileName ? ` ${reply.media.fileName}` : ""}${reply.media.mimeType ? ` ${reply.media.mimeType}` : ""}` : "",
+          msg.text ? `Current user message:
+${this.quoteTelegramContextBlock(msg.text, 1e3)}` : "",
+          'Instruction: resolve pronouns, follow-up requests, and requests like "links", "repos", "instructions", "that", or "this" against the replied-to content before broader chat/workspace context.'
+        ].filter(Boolean);
+        return blocks.join("\n");
+      }
+      formatTelegramCurrentMessageForPrompt(sessionKey, msg, header, mediaContext = "") {
+        return [
+          this.buildTelegramCurrentReplyContext(sessionKey, msg),
+          `${header}:
+${msg.text}`,
+          mediaContext ? `[Media attached - processed content below]
+${mediaContext}` : ""
+        ].filter(Boolean).join("\n\n");
+      }
+      formatTelegramReplyEdgeForTui(sessionKey, msg) {
+        const reply = this.resolveTelegramReplyContext(sessionKey, msg);
+        if (!reply) return "";
+        const current = telegramSpeakerLabel(msg);
+        const target = telegramReplySenderLabel(reply.sender);
+        const selfMarker = reply.sender?.isSelf ? " (bot/self)" : "";
+        const id = reply.messageId ? ` #${reply.messageId}` : "";
+        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) {
@@ -601197,7 +601828,9 @@ Telegram response contract:
           firstName: msg.firstName,
           fromUserId: msg.fromUserId,
           messageId: msg.messageId,
+          messageThreadId: msg.messageThreadId,
           replyToMessageId: msg.replyToMessageId,
+          replyContext: msg.replyContext,
           chatType: msg.chatType,
           chatTitle: msg.chatTitle,
           mediaSummary
@@ -601221,7 +601854,7 @@ Telegram response contract:
         }
         this.saveTelegramConversationState(sessionKey);
       }
-      recordTelegramAssistantMessage(msg, text, mode) {
+      recordTelegramAssistantMessage(msg, text, mode, options2 = {}) {
         const clean3 = stripTelegramHiddenThinking(text).trim();
         if (!clean3) return;
         const sessionKey = this.sessionKeyForMessage(msg);
@@ -601231,6 +601864,9 @@ Telegram response contract:
           mode,
           chatId: msg.chatId,
           speaker: this.state.botUsername ? `@${this.state.botUsername}` : "Assistant",
+          messageId: options2.messageId ?? void 0,
+          messageThreadId: msg.messageThreadId,
+          replyToMessageId: options2.replyToMessageId,
           chatType: msg.chatType,
           chatTitle: msg.chatTitle
         };
@@ -601398,7 +602034,7 @@ Telegram response contract:
           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: [],
@@ -601467,12 +602103,14 @@ Telegram response contract:
         })).sort((a2, b) => b.score - a2.score || b.card.updatedAt - a2.card.updatedAt).slice(0, limit);
       }
       buildTelegramConversationContextStream(sessionKey, msg, maxRecent = TELEGRAM_CONTEXT_RECENT_DEFAULT) {
+        this.ensureTelegramConversationLoaded(sessionKey);
         const history = this.chatHistory.get(sessionKey) ?? [];
         const participants = [...this.chatParticipants.get(sessionKey)?.values() ?? []].sort((a2, b) => b.lastSeenTs - a2.lastSeenTs);
         const isGroup = msg.chatType !== "private";
         const retainedCount = history.length;
         const olderCount = Math.max(0, retainedCount - maxRecent);
         const currentSpeaker = telegramSpeakerLabel(msg);
+        const currentReplyContext = this.buildTelegramCurrentReplyContext(sessionKey, msg);
         const sections = [
           "## Telegram Conversation Context Stream",
           [
@@ -601480,9 +602118,13 @@ Telegram response contract:
             `Retained messages in bridge memory: ${retainedCount}`,
             olderCount ? `Older retained messages compacted below: ${olderCount}` : "",
             `Current sender: ${currentSpeaker}${msg.fromUserId ? ` (id ${msg.fromUserId})` : ""}`,
+            msg.messageThreadId !== void 0 ? `Current Telegram thread/topic id: ${msg.messageThreadId}` : "",
             msg.replyToMessageId ? `Current message replies to message_id ${msg.replyToMessageId}` : ""
           ].filter(Boolean).join("\n")
         ];
+        if (currentReplyContext) {
+          sections.push(currentReplyContext);
+        }
         const scopedPersonality = this.renderTelegramScopedPersonality(sessionKey, msg);
         if (scopedPersonality) {
           sections.push(scopedPersonality);
@@ -601557,7 +602199,8 @@ ${olderLines.join("\n")}`);
             const when = telegramHistoryTime(entry);
             const speaker = telegramHistorySpeaker(entry);
             const mode = entry.mode ? `/${entry.mode}` : "";
-            const reply = entry.replyToMessageId ? ` reply_to:${entry.replyToMessageId}` : "";
+            const replySender = entry.replyContext?.sender ? `/${telegramReplySenderLabel(entry.replyContext.sender)}` : "";
+            const reply = entry.replyToMessageId ? ` reply_to:${entry.replyToMessageId}${replySender}` : "";
             const media = entry.mediaSummary ? ` [${entry.mediaSummary}]` : "";
             const prefix = [when, `${speaker}${mode}${reply}${media}`].filter(Boolean).join(" ");
             return `${prefix}: ${truncateTelegramContextLine(entry.text)}`;
@@ -601593,11 +602236,20 @@ ${lines.join("\n")}`);
         );
         if (mentioned) return true;
         if (msg.replyToUsername && msg.replyToUsername.trim().replace(/^@/, "").toLowerCase() === bot) return true;
+        const replyUsername = msg.replyContext?.sender?.username?.trim().replace(/^@/, "").toLowerCase();
+        if (replyUsername && replyUsername === bot) return true;
+        const resolvedReply = this.resolveTelegramReplyContext(this.sessionKeyForMessage(msg), msg);
+        if (resolvedReply?.sender?.isSelf) return true;
         return false;
       }
       telegramMessageRepliesToBot(msg) {
         const bot = this.state.botUsername.trim().replace(/^@/, "").toLowerCase();
-        return !!bot && !!msg.replyToUsername && msg.replyToUsername.trim().replace(/^@/, "").toLowerCase() === bot;
+        if (!bot) return false;
+        const legacyReply = msg.replyToUsername?.trim().replace(/^@/, "").toLowerCase();
+        const contextReply = msg.replyContext?.sender?.username?.trim().replace(/^@/, "").toLowerCase();
+        if (legacyReply === bot || contextReply === bot) return true;
+        const resolvedReply = this.resolveTelegramReplyContext(this.sessionKeyForMessage(msg), msg);
+        return Boolean(resolvedReply?.sender?.isSelf);
       }
       applyTelegramStimulationDecision(sessionKey, decision) {
         this.stimulation.applyAgentDecision(sessionKey, {
@@ -601649,6 +602301,7 @@ ${lines.join("\n")}`);
         );
         const forcedLine = forcedRoute ? `The operator selected Telegram mode "${forcedRoute}". The route field MUST be "${forcedRoute}", but should_reply must still be inferred live from context.` : `The operator selected Telegram mode "auto". Infer route live from context.`;
         const context2 = this.buildTelegramConversationContextStream(sessionKey, msg, isGroup ? 36 : 20);
+        const currentReplyContext = this.buildTelegramCurrentReplyContext(sessionKey, msg);
         const userPrompt = [
           `You are the Telegram live routing and reply-discretion model.`,
           `Return JSON only, with no markdown and no explanation outside JSON.`,
@@ -601673,6 +602326,7 @@ ${lines.join("\n")}`);
           `Current sender: ${telegramSpeakerLabel(msg)}`,
           msg.replyToMessageId ? `Current message replies to message_id ${msg.replyToMessageId}` : "",
           msg.replyToUsername ? `Current message replies to @${msg.replyToUsername}` : "",
+          currentReplyContext,
           (msg.mentionedUsernames ?? []).length > 0 ? `Current message mentions: ${(msg.mentionedUsernames ?? []).map((name10) => `@${name10}`).join(", ")}` : "",
           msg.media ? `Current message has media: ${summarizeTelegramMessageAttachments(msg)}` : "",
           ``,
@@ -601845,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) {
@@ -602065,7 +602719,8 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`);
             text: initialText,
             parse_mode: "HTML"
           };
-          if (replyToMessageId) body["reply_to_message_id"] = replyToMessageId;
+          const replyParameters = telegramReplyParameters(replyToMessageId);
+          if (replyParameters) body["reply_parameters"] = replyParameters;
           const result = await this.apiCall("sendMessage", body);
           this.state.messagesSent++;
           return result.result?.message_id ?? null;
@@ -602075,7 +602730,8 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`);
               chat_id: chatId,
               text: initialText
             };
-            if (replyToMessageId) body["reply_to_message_id"] = replyToMessageId;
+            const replyParameters = telegramReplyParameters(replyToMessageId);
+            if (replyParameters) body["reply_parameters"] = replyParameters;
             const result = await this.apiCall("sendMessage", body);
             this.state.messagesSent++;
             return result.result?.message_id ?? null;
@@ -602118,7 +602774,7 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`);
       }
       async sendOrEditFinalTelegramHTML(msg, html, liveMessageId) {
         const chunks = splitTelegramMessageText(html, 3900);
-        if (chunks.length === 0) return;
+        if (chunks.length === 0) return null;
         const replyToMessageId = msg.chatType !== "private" ? msg.messageId : void 0;
         if (liveMessageId && !msg.guestQueryId) {
           const edited = await this.editLiveMessage(msg.chatId, liveMessageId, chunks[0]);
@@ -602126,16 +602782,19 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`);
             for (const chunk of chunks.slice(1)) {
               await this.sendMessageHTML(msg.chatId, chunk);
             }
-            return;
+            return liveMessageId;
           }
         }
         if (msg.guestQueryId) {
           await this.answerGuestQuery(msg.guestQueryId, chunks.join("\n\n"), { parseMode: "HTML" });
-          return;
+          return null;
         }
+        let firstMessageId = null;
         for (let idx = 0; idx < chunks.length; idx++) {
-          await this.sendMessageHTML(msg.chatId, chunks[idx], idx === 0 ? replyToMessageId : void 0);
+          const messageId = await this.sendMessageHTML(msg.chatId, chunks[idx], idx === 0 ? replyToMessageId : void 0);
+          if (firstMessageId === null) firstMessageId = messageId;
         }
+        return firstMessageId;
       }
       async deleteLiveMessage(chatId, messageId) {
         try {
@@ -602267,16 +602926,16 @@ Join: ${newUrl}`);
               return;
             }
           }
-          let steeringText = msg.text;
+          let mediaContext = "";
           if (msg.media || msg.replyToMedia) {
-            const mediaContext = await this.processMediaContextForMessage(msg);
-            if (mediaContext) {
-              steeringText += `
-
-[Media attached — processed content below]
-${mediaContext}`;
-            }
+            mediaContext = await this.processMediaContextForMessage(msg);
           }
+          const steeringText = this.formatTelegramCurrentMessageForPrompt(
+            sessionKey,
+            msg,
+            `Telegram steering message from @${msg.username}`,
+            mediaContext
+          );
           if (isGroup) {
             this.markLastTelegramUserMessageMode(msg, "steering");
           } else {
@@ -602337,11 +602996,18 @@ ${mediaContext}`;
           `✈ @${msg.username || "telegram"}`,
           `Telegram ${toolContext} message: ${msg.text.slice(0, 160)}`
         );
+        const replyEdge = this.formatTelegramReplyEdgeForTui(sessionKey, msg);
+        if (replyEdge) {
+          this.subAgentViewCallbacks?.onWrite(subAgent.viewId, replyEdge);
+        }
         this.subAgentViewCallbacks?.onWrite(subAgent.viewId, `✈ Telegram message from @${msg.username}: ${msg.text}`);
         if (this.canUseChatActions(msg)) {
           subAgent.typingInterval = this.startTypingIndicator(msg.chatId);
         }
         this.tuiWrite(() => renderTelegramSubAgentStart(msg.username, msg.text, isAdminDM));
+        if (replyEdge) {
+          this.tuiWrite(() => renderTelegramSubAgentEvent(msg.username, replyEdge));
+        }
         try {
           let mediaContext = "";
           if (msg.media || msg.replyToMedia) {
@@ -602371,9 +603037,12 @@ ${mediaContext}`;
             await subAgent.liveMessagePromise.catch(() => {
             });
           }
-          this.recordTelegramAssistantMessage(msg, finalText, "action");
           const finalHtml = convertMarkdownToTelegramHTML(finalText);
-          await this.sendOrEditFinalTelegramHTML(msg, finalHtml, subAgent.liveMessageId);
+          const sentMessageId = await this.sendOrEditFinalTelegramHTML(msg, finalHtml, subAgent.liveMessageId);
+          this.recordTelegramAssistantMessage(msg, finalText, "action", {
+            messageId: sentMessageId,
+            replyToMessageId: msg.chatType !== "private" ? msg.messageId : void 0
+          });
           await this.sendGeneratedArtifactsFromSubAgent(
             msg,
             subAgent,
@@ -602439,6 +603108,10 @@ ${mediaContext}`;
           `✈ @${msg.username || "telegram"}`,
           `Telegram admin chat: ${msg.text.slice(0, 160)}`
         );
+        const replyEdge = this.formatTelegramReplyEdgeForTui(sessionKey, msg);
+        if (replyEdge) {
+          this.subAgentViewCallbacks?.onWrite(subAgent.viewId, replyEdge);
+        }
         this.subAgentViewCallbacks?.onWrite(subAgent.viewId, `✈ Telegram admin chat from @${msg.username}: ${msg.text}`);
         this.subAgentViewCallbacks?.onWrite(subAgent.viewId, `route: chat (${this.interactionMode}) with admin tools`);
         this.subAgentViewCallbacks?.onStatus(subAgent.viewId, "running");
@@ -602446,6 +603119,9 @@ ${mediaContext}`;
           subAgent.typingInterval = this.startTypingIndicator(msg.chatId);
         }
         this.tuiWrite(() => renderTelegramSubAgentEvent(msg.username, `admin chat with full context/tools (${this.interactionMode})`));
+        if (replyEdge) {
+          this.tuiWrite(() => renderTelegramSubAgentEvent(msg.username, replyEdge));
+        }
         try {
           let mediaContext = "";
           if (msg.media || msg.replyToMedia) {
@@ -602470,9 +603146,12 @@ ${mediaContext}`;
             this.subAgentViewCallbacks?.onStatus(subAgent.viewId, "completed");
             return;
           }
-          this.recordTelegramAssistantMessage(msg, finalText, "chat");
           const finalHtml = convertMarkdownToTelegramHTML(finalText);
-          await this.sendOrEditFinalTelegramHTML(msg, finalHtml, subAgent.liveMessageId);
+          const sentMessageId = await this.sendOrEditFinalTelegramHTML(msg, finalHtml, subAgent.liveMessageId);
+          this.recordTelegramAssistantMessage(msg, finalText, "chat", {
+            messageId: sentMessageId,
+            replyToMessageId: msg.chatType !== "private" ? msg.messageId : void 0
+          });
           await this.sendGeneratedArtifactsFromSubAgent(
             msg,
             subAgent,
@@ -602510,6 +603189,7 @@ ${mediaContext}`;
           return;
         }
         const viewId = `${this.viewIdForMessage(msg)}-chat`;
+        const sessionKey = this.sessionKeyForMessage(msg);
         let typingInterval = null;
         let liveMessageId = null;
         let accumulated = "";
@@ -602524,6 +603204,10 @@ ${mediaContext}`;
           `✈ @${msg.username || "telegram"}`,
           `Telegram quick chat: ${msg.text.slice(0, 160)}`
         );
+        const replyEdge = this.formatTelegramReplyEdgeForTui(sessionKey, msg);
+        if (replyEdge) {
+          this.subAgentViewCallbacks?.onWrite(viewId, replyEdge);
+        }
         this.subAgentViewCallbacks?.onWrite(viewId, `✈ Telegram quick chat from @${msg.username}: ${msg.text}`);
         this.subAgentViewCallbacks?.onWrite(viewId, `route: chat (${this.interactionMode})`);
         this.subAgentViewCallbacks?.onStatus(viewId, "running");
@@ -602592,9 +603276,12 @@ ${mediaContext}`;
             this.subAgentViewCallbacks?.onStatus(viewId, "completed");
             return;
           }
-          this.recordTelegramAssistantMessage(msg, cleaned, "chat");
           const finalHtml = convertMarkdownToTelegramHTML(cleaned);
-          await this.sendOrEditFinalTelegramHTML(msg, finalHtml, liveMessageId);
+          const sentMessageId = await this.sendOrEditFinalTelegramHTML(msg, finalHtml, liveMessageId);
+          this.recordTelegramAssistantMessage(msg, cleaned, "chat", {
+            messageId: sentMessageId,
+            replyToMessageId: msg.chatType !== "private" ? msg.messageId : void 0
+          });
           this.subAgentViewCallbacks?.onWrite(viewId, `completed: ${cleaned}`);
           this.subAgentViewCallbacks?.onStatus(viewId, "completed");
         } catch (err) {
@@ -602657,12 +603344,15 @@ ${conversationStream}`
           }
         ];
         const chatLabel = isGroup ? ` in group "${msg.chatTitle || "unknown"}"` : "";
+        const currentPrompt = this.formatTelegramCurrentMessageForPrompt(
+          sessionKey,
+          msg,
+          `Telegram message from @${msg.username}${chatLabel}`,
+          mediaContext
+        );
         messages2.push({
           role: "user",
-          content: `Telegram message from @${msg.username}${chatLabel}:
-${msg.text}${mediaContext ? `
-
-${mediaContext}` : ""}`
+          content: currentPrompt
         });
         return messages2;
       }
@@ -602869,6 +603559,11 @@ ${mediaContext}` : ""}`
 
 ${GROUP_REPLY_DISCRETION_PROMPT}` : "";
         const chatLabel = isGroup ? ` in group "${msg.chatTitle || "unknown"}"` : "";
+        const currentTelegramPrompt = this.formatTelegramCurrentMessageForPrompt(
+          sessionContext.sessionKey,
+          msg,
+          `${isAdminDM ? "Telegram message from admin" : "Telegram message from"} @${msg.username}${isAdminDM ? "" : chatLabel}`
+        );
         let userPrompt;
         if (isAdminDM) {
           const profileLine = profile === "chat" ? "Handle this as contextual Telegram chat: answer directly if simple, use tools/delegation if needed." : "Handle this as Telegram action work: complete the requested task or clearly report the blocker.";
@@ -602880,8 +603575,7 @@ ${reminderToolContract}
 
 ${profileLine}
 
-Telegram message from admin @${msg.username}:
-${msg.text}`;
+${currentTelegramPrompt}`;
         } else {
           const toolHint = [
             "You have access to isolated per-chat memory (memory_write, memory_read, memory_search) scoped to this conversation.",
@@ -602898,8 +603592,7 @@ ${toolHint}
 
 ---
 
-Telegram message from @${msg.username}${chatLabel}:
-${msg.text}
+${currentTelegramPrompt}
 
 Respond concisely and safely. Send the actual chat reply, not router/status/completion commentary.`;
         }
@@ -603816,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 {
@@ -603842,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 {
@@ -603888,12 +604581,12 @@ ${text}`.trim());
       }
       // ── Message sending ───────────────────────────────────────────────────
       /** Send a response back to a Telegram chat (Markdown → HTML conversion) */
-      async sendMessage(chatId, text) {
+      async sendMessage(chatId, text, replyToMessageId) {
         const extracted = extractMediaReferences(text);
         const html = convertMarkdownToTelegramHTML(extracted.text);
-        const msgId = extracted.text.trim() ? await this.sendMessageHTML(chatId, html) : null;
+        const msgId = extracted.text.trim() ? await this.sendMessageHTML(chatId, html, replyToMessageId) : null;
         for (const media of extracted.media) {
-          await this.sendMediaReference(chatId, media).catch(() => null);
+          await this.sendMediaReference(chatId, media, { replyToMessageId }).catch(() => null);
         }
         return msgId;
       }
@@ -603903,8 +604596,13 @@ ${text}`.trim());
         const sendHtml = extracted.text || (extracted.media.length > 0 ? "" : html);
         let sentId = null;
         if (!sendHtml.trim()) {
-          for (const media of extracted.media) {
-            const mediaId = await this.sendMediaReference(chatId, media).catch(() => null);
+          for (let idx = 0; idx < extracted.media.length; idx++) {
+            const media = extracted.media[idx];
+            const mediaId = await this.sendMediaReference(
+              chatId,
+              media,
+              idx === 0 ? { replyToMessageId } : {}
+            ).catch(() => null);
             if (sentId === null) sentId = mediaId;
           }
           return sentId;
@@ -603917,7 +604615,8 @@ ${text}`.trim());
             text: chunk,
             parse_mode: "HTML"
           };
-          if (idx === 0 && replyToMessageId) body["reply_to_message_id"] = replyToMessageId;
+          const replyParameters = idx === 0 ? telegramReplyParameters(replyToMessageId) : void 0;
+          if (replyParameters) body["reply_parameters"] = replyParameters;
           try {
             const result = await this.apiCall("sendMessage", body);
             if (result.ok === false) throw new Error(String(result.description || "Telegram sendMessage failed"));
@@ -603926,7 +604625,7 @@ ${text}`.trim());
           } catch {
             const plain = chunk.replace(/<[^>]+>/g, "");
             const fallbackBody = { chat_id: chatId, text: plain };
-            if (idx === 0 && replyToMessageId) fallbackBody["reply_to_message_id"] = replyToMessageId;
+            if (replyParameters) fallbackBody["reply_parameters"] = replyParameters;
             try {
               const result = await this.apiCall("sendMessage", fallbackBody);
               if (result.ok === false) throw new Error(String(result.description || "Telegram sendMessage failed"));
@@ -603948,7 +604647,7 @@ ${text}`.trim());
             parseMode: options2.html ? "HTML" : void 0
           });
         }
-        return options2.html ? this.sendMessageHTML(msg.chatId, text, options2.replyToMessageId) : this.sendMessage(msg.chatId, text);
+        return options2.html ? this.sendMessageHTML(msg.chatId, text, options2.replyToMessageId) : this.sendMessage(msg.chatId, text, options2.replyToMessageId);
       }
       async sendTelegramFileToChat(chatId, path11, options2) {
         const abs = resolve40(path11);
@@ -603973,12 +604672,13 @@ ${text}`.trim());
       async sendMediaReferenceStrict(chatId, media, options2 = {}) {
         const { method, field } = mediaTelegramMethod(media.kind);
         const caption = options2.caption?.trim();
+        const replyParameters = telegramReplyParameters(options2.replyToMessageId);
         if (media.source === "url") {
           const result2 = await this.apiCall(method, {
             chat_id: chatId,
             [field]: media.value,
             ...caption ? { caption } : {},
-            ...options2.replyToMessageId ? { reply_to_message_id: options2.replyToMessageId } : {}
+            ...replyParameters ? { reply_parameters: replyParameters } : {}
           });
           if (result2.ok === false) throw new Error(String(result2.description || `Telegram ${method} failed`));
           this.state.messagesSent++;
@@ -604001,7 +604701,7 @@ ${text}`.trim());
         };
         addField("chat_id", String(chatId));
         if (caption) addField("caption", caption);
-        if (options2.replyToMessageId) addField("reply_to_message_id", String(options2.replyToMessageId));
+        if (replyParameters) addField("reply_parameters", JSON.stringify(replyParameters));
         parts.push(Buffer.from(`--${boundary}\r
 `));
         parts.push(Buffer.from(
@@ -605973,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));
@@ -606096,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;
@@ -606110,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);
 }
@@ -606288,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);
@@ -606367,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;
@@ -606383,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);
@@ -607158,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",
@@ -607221,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) {
@@ -608897,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;
@@ -621377,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));
@@ -621742,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();
@@ -621785,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 {
@@ -627242,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;
@@ -627359,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 {
     }
@@ -628290,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 {
@@ -628684,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) });
   }
@@ -628755,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) {
@@ -636802,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,