omnius 1.0.59 → 1.0.61

package/dist/index.js

@@ -12159,17 +12159,26 @@ process.on('unhandledRejection', (reason) => {
 
               dlog('COHERE response: ' + _cData.queryId + ' model=' + _cModel + ' tier=' + ['trivial','moderate','complex','expert'][_cTier] + ' ' + _cLatency + 'ms' + (_cReviewed ? ' (reviewed)' : ''));
               // IK-01: Update identity on query success
+              // Store full query + response content; downstream renderers (narrative summary, prompts)
+              // are responsible for compaction. Truncating at write time destroys identity history.
+              // NOTE: '\\n' is double-escaped because this whole block runs inside the
+              // outer DAEMON_SCRIPT template literal — see comment near line 440.
               _updateIdentity({ type: 'query_served', outcome: 1.0, details: {
                 latencyMs: _cLatency, toolsUsed: _cToolsUsed, model: _cModel,
-                summary: (_cData.query || '').slice(0, 60)
+                query: _cData.query || '',
+                response: _cFinalContent || '',
+                summary: (_cData.query || '') + (_cFinalContent ? '\\n→ ' + _cFinalContent : '')
               }});
             } catch (_cErr) {
               dlog('COHERE inference error: ' + (_cErr.message || _cErr));
               _cohereStats.queriesErrors++;
               _saveStats();
               // IK-01: Update identity on query failure
+              // Preserve the full error so post-hoc diagnosis is possible.
               _updateIdentity({ type: 'query_failed', outcome: 0, details: {
-                error: (_cErr.message || String(_cErr)).slice(0, 100), summary: 'inference error'
+                error: (_cErr && _cErr.message) || String(_cErr),
+                query: _cData.query || '',
+                summary: 'inference error: ' + ((_cErr && _cErr.message) || String(_cErr))
               }});
             }
           } catch (_cParseErr) {
@@ -561982,8 +561991,7 @@ function wrapTaskCompleteSummary(summary) {
 }
 function wrapPlainLine(line, width) {
   const out = [];
-  const indent = line.match(/^\s*/)?.[0] ?? "";
-  const continuationIndent = indent.length > 0 ? indent : "";
+  const continuationIndent = hangingIndentForPlainLine(line, width);
   let remaining = line;
   while (remaining.length > width) {
     let breakAt = remaining.lastIndexOf(" ", width);
@@ -561994,6 +562002,20 @@ function wrapPlainLine(line, width) {
   out.push(remaining);
   return out;
 }
+function hangingIndentForPlainLine(line, width) {
+  const capped = (n2) => " ".repeat(Math.max(0, Math.min(n2, width - 4)));
+  const patterns = [
+    /^(\s*(?:[-*+○•]\s+))/,
+    /^(\s*(?:\d+[.)]\s+))/,
+    /^(\s*(?:>\s*))/,
+    /^(\s*(?:[A-Za-z][\w.-]{0,28}:\s+))/
+  ];
+  for (const pattern of patterns) {
+    const match = line.match(pattern);
+    if (match?.[1]) return capped(match[1].length);
+  }
+  return capped(line.match(/^\s*/)?.[0].length ?? 0);
+}
 function renderTaskIncomplete(turns, toolCalls, durationMs, tokens) {
   const duration = formatDuration2(durationMs);
   const tokenStr = tokens ? ` ${formatTokenCount(tokens)}` : "";
@@ -563699,7 +563721,7 @@ var init_voice_session = __esm({
 
 // packages/cli/src/tui/scoped-personality.ts
 import { createHash as createHash17 } from "node:crypto";
-import { existsSync as existsSync82, mkdirSync as mkdirSync46, readFileSync as readFileSync65, writeFileSync as writeFileSync41 } from "node:fs";
+import { appendFileSync as appendFileSync4, existsSync as existsSync82, mkdirSync as mkdirSync46, readFileSync as readFileSync65, writeFileSync as writeFileSync41 } from "node:fs";
 import { join as join98, resolve as resolve37 } from "node:path";
 function safeName(input) {
   return input.replace(/[^A-Za-z0-9_.-]/g, "-").slice(0, 80) || "default";
@@ -563715,7 +563737,8 @@ function scopedPersonalityPaths(scope) {
   const prefix = `${safeName(scope.label)}-${scopeHash(scope)}`;
   return {
     json: join98(dir, `${prefix}.json`),
-    markdown: join98(dir, `${prefix}.md`)
+    markdown: join98(dir, `${prefix}.md`),
+    events: join98(dir, `${prefix}.events.jsonl`)
   };
 }
 function inferToneTags(text) {
@@ -563776,16 +563799,49 @@ function newDocument(scope) {
       "Do not expose private local files, secrets, credentials, or hidden reasoning in public or group scopes.",
       "Do not claim memory is unavailable when scoped context is present."
     ],
+    topicCounts: {},
+    durableObservations: [],
+    relationshipEvents: [],
     recentObservations: []
   };
 }
+function normalizeDocument(scope, parsed) {
+  const fresh = newDocument(scope);
+  const doc = {
+    ...fresh,
+    ...parsed,
+    scope: {
+      kind: scope.kind,
+      idHash: scopeHash(scope),
+      label: scope.label || parsed.scope?.label || fresh.scope.label
+    },
+    participants: parsed.participants && typeof parsed.participants === "object" ? parsed.participants : {},
+    dominantTone: Array.isArray(parsed.dominantTone) ? parsed.dominantTone : [],
+    responseStyle: Array.isArray(parsed.responseStyle) && parsed.responseStyle.length > 0 ? parsed.responseStyle : fresh.responseStyle,
+    relationshipModel: Array.isArray(parsed.relationshipModel) && parsed.relationshipModel.length > 0 ? parsed.relationshipModel : fresh.relationshipModel,
+    behavioralGuidance: Array.isArray(parsed.behavioralGuidance) && parsed.behavioralGuidance.length > 0 ? parsed.behavioralGuidance : fresh.behavioralGuidance,
+    boundaries: Array.isArray(parsed.boundaries) && parsed.boundaries.length > 0 ? parsed.boundaries : fresh.boundaries,
+    topicCounts: parsed.topicCounts && typeof parsed.topicCounts === "object" ? parsed.topicCounts : {},
+    durableObservations: Array.isArray(parsed.durableObservations) ? parsed.durableObservations.slice(-MAX_PROFILE_DURABLE_OBSERVATIONS) : [],
+    relationshipEvents: Array.isArray(parsed.relationshipEvents) ? parsed.relationshipEvents.slice(-MAX_PROFILE_RELATIONSHIP_EVENTS) : [],
+    recentObservations: Array.isArray(parsed.recentObservations) ? parsed.recentObservations.slice(-MAX_PROFILE_OBSERVATIONS) : []
+  };
+  doc.messageCount = Number.isFinite(doc.messageCount) ? doc.messageCount : 0;
+  for (const profile of Object.values(doc.participants)) {
+    if (!Array.isArray(profile.toneTags)) profile.toneTags = [];
+    if (!Array.isArray(profile.samples)) profile.samples = [];
+    profile.toneTags = profile.toneTags.slice(0, MAX_PROFILE_TAGS);
+    profile.samples = profile.samples.slice(-MAX_PROFILE_SAMPLES);
+  }
+  return doc;
+}
 function loadScopedPersonality(scope) {
   const paths = scopedPersonalityPaths(scope);
   if (!existsSync82(paths.json)) return newDocument(scope);
   try {
     const parsed = JSON.parse(readFileSync65(paths.json, "utf8"));
     if (parsed.version !== PROFILE_VERSION) return newDocument(scope);
-    return parsed;
+    return normalizeDocument(scope, parsed);
   } catch {
     return newDocument(scope);
   }
@@ -563796,6 +563852,14 @@ function saveScopedPersonality(scope, doc) {
   writeFileSync41(paths.json, JSON.stringify(doc, null, 2) + "\n", "utf8");
   writeFileSync41(paths.markdown, renderScopedPersonalityMarkdown(doc) + "\n", "utf8");
 }
+function appendScopedPersonalityEvent(scope, event) {
+  try {
+    const paths = scopedPersonalityPaths(scope);
+    mkdirSync46(scopedPersonalityDir(scope.repoRoot, scope.kind), { recursive: true });
+    appendFileSync4(paths.events, JSON.stringify(event) + "\n", "utf8");
+  } catch {
+  }
+}
 function updateScopedPersonality(scope, observation) {
   const doc = loadScopedPersonality(scope);
   const now = new Date(observation.ts ?? Date.now()).toISOString();
@@ -563806,6 +563870,7 @@ function updateScopedPersonality(scope, observation) {
     ...inferToneTags(observation.text),
     ...keywords(observation.text)
   ];
+  const topicTags = keywords(observation.text);
   doc.updatedAt = now;
   doc.messageCount += 1;
   doc.scope.label = scope.label;
@@ -563831,6 +563896,9 @@ function updateScopedPersonality(scope, observation) {
     for (const tag of profile.toneTags) allTags.set(tag, (allTags.get(tag) ?? 0) + profile.count);
   }
   doc.dominantTone = [...allTags.entries()].sort((a2, b) => b[1] - a2[1]).map(([tag]) => tag).slice(0, MAX_PROFILE_TAGS);
+  for (const tag of topicTags) {
+    doc.topicCounts[tag] = (doc.topicCounts[tag] ?? 0) + 1;
+  }
   if (doc.dominantTone.includes("frustrated")) {
     doc.responseStyle = [
       "Start with the concrete fix or answer; avoid soothing filler.",
@@ -563852,15 +563920,31 @@ function updateScopedPersonality(scope, observation) {
   for (const hint of relationshipHints) {
     const clean5 = compactLine(hint, 180);
     if (clean5 && !doc.relationshipModel.includes(clean5)) doc.relationshipModel.push(clean5);
+    if (clean5 && !doc.relationshipEvents.includes(`${now} ${clean5}`)) doc.relationshipEvents.push(`${now} ${clean5}`);
   }
   doc.relationshipModel = doc.relationshipModel.slice(-12);
+  doc.relationshipEvents = doc.relationshipEvents.slice(-MAX_PROFILE_RELATIONSHIP_EVENTS);
   if (text) {
     const line = `${now} ${speaker}${observation.mode ? `/${observation.mode}` : ""}: ${text}`;
     doc.recentObservations.push(line);
     if (doc.recentObservations.length > MAX_PROFILE_OBSERVATIONS) {
       doc.recentObservations.splice(0, doc.recentObservations.length - MAX_PROFILE_OBSERVATIONS);
     }
+    doc.durableObservations.push(line);
+    if (doc.durableObservations.length > MAX_PROFILE_DURABLE_OBSERVATIONS) {
+      doc.durableObservations.splice(0, doc.durableObservations.length - MAX_PROFILE_DURABLE_OBSERVATIONS);
+    }
   }
+  appendScopedPersonalityEvent(scope, {
+    ts: observation.ts ?? Date.now(),
+    iso: now,
+    speaker,
+    role: observation.role,
+    mode: observation.mode,
+    text,
+    toneTags: [...new Set(toneTags)].slice(0, 32),
+    relationshipHints
+  });
   saveScopedPersonality(scope, doc);
   return doc;
 }
@@ -563871,6 +563955,9 @@ function renderScopedPersonalityMarkdown(doc) {
     return `- ${name10}: messages=${profile.count}; last=${profile.lastSeenAt};${tags}${samples ? `
 ${samples}` : ""}`;
   });
+  const topTopics = Object.entries(doc.topicCounts ?? {}).sort((a2, b) => b[1] - a2[1]).slice(0, 18).map(([topic, count]) => `- ${topic}: ${count}`);
+  const durable = doc.durableObservations.slice(-18).map((line) => `- ${line}`);
+  const relationships = doc.relationshipEvents.slice(-10).map((line) => `- ${line}`);
   return [
     `# Scoped Personality Profile`,
     ``,
@@ -563887,6 +563974,11 @@ ${samples}` : ""}`;
     `## Relationship Model`,
     doc.relationshipModel.map((line) => `- ${line}`).join("\n"),
     ``,
+    `## Durable Profile Memory`,
+    topTopics.length ? [`Top recurring topics:`, ...topTopics].join("\n") : "Top recurring topics:\n- none",
+    durable.length ? [`Longer-term observations:`, ...durable].join("\n") : "Longer-term observations:\n- none",
+    relationships.length ? [`Relationship events:`, ...relationships].join("\n") : "Relationship events:\n- none",
+    ``,
     `## Behavioral Guidance`,
     doc.behavioralGuidance.map((line) => `- ${line}`).join("\n"),
     ``,
@@ -563910,13 +564002,15 @@ function renderScopedPersonalityContext(doc) {
 function buildScopedPersonalityContext(scope) {
   return renderScopedPersonalityContext(loadScopedPersonality(scope));
 }
-var PROFILE_VERSION, MAX_PROFILE_OBSERVATIONS, MAX_PROFILE_SAMPLES, MAX_PROFILE_TAGS, STOPWORDS2;
+var PROFILE_VERSION, MAX_PROFILE_OBSERVATIONS, MAX_PROFILE_DURABLE_OBSERVATIONS, MAX_PROFILE_RELATIONSHIP_EVENTS, MAX_PROFILE_SAMPLES, MAX_PROFILE_TAGS, STOPWORDS2;
 var init_scoped_personality = __esm({
   "packages/cli/src/tui/scoped-personality.ts"() {
     "use strict";
     PROFILE_VERSION = 1;
-    MAX_PROFILE_OBSERVATIONS = 18;
-    MAX_PROFILE_SAMPLES = 8;
+    MAX_PROFILE_OBSERVATIONS = 40;
+    MAX_PROFILE_DURABLE_OBSERVATIONS = 240;
+    MAX_PROFILE_RELATIONSHIP_EVENTS = 120;
+    MAX_PROFILE_SAMPLES = 16;
     MAX_PROFILE_TAGS = 12;
     STOPWORDS2 = /* @__PURE__ */ new Set([
       "about",
@@ -567727,7 +567821,7 @@ __export(omnius_directory_exports, {
   writeIndexMeta: () => writeIndexMeta,
   writeTaskHandoff: () => writeTaskHandoff2
 });
-import { cpSync as cpSync2, existsSync as existsSync87, mkdirSync as mkdirSync50, readFileSync as readFileSync70, writeFileSync as writeFileSync45, readdirSync as readdirSync29, statSync as statSync32, unlinkSync as unlinkSync15, openSync as openSync2, closeSync as closeSync2, renameSync as renameSync4 } from "node:fs";
+import { appendFileSync as appendFileSync5, cpSync as cpSync2, existsSync as existsSync87, mkdirSync as mkdirSync50, readFileSync as readFileSync70, writeFileSync as writeFileSync45, readdirSync as readdirSync29, statSync as statSync32, unlinkSync as unlinkSync15, openSync as openSync2, closeSync as closeSync2, renameSync as renameSync4 } from "node:fs";
 import { join as join104, relative as relative9, basename as basename17, dirname as dirname29 } from "node:path";
 import { homedir as homedir31 } from "node:os";
 import { createHash as createHash20 } from "node:crypto";
@@ -568248,6 +568342,7 @@ function saveSessionContext(repoRoot, entry) {
   const contextDir = join104(repoRoot, OMNIUS_DIR, "context");
   mkdirSync50(contextDir, { recursive: true });
   const filePath = join104(contextDir, CONTEXT_SAVE_FILE);
+  const ledgerPath = join104(contextDir, CONTEXT_LEDGER_FILE);
   const lockPath = join104(contextDir, CONTEXT_SAVE_FILE + ".lock");
   const locked = acquireLock(lockPath);
   if (!locked) {
@@ -568264,7 +568359,23 @@ function saveSessionContext(repoRoot, entry) {
     } catch {
       ctx3 = { entries: [], maxEntries: MAX_CONTEXT_ENTRIES, updatedAt: "" };
     }
+    ctx3.maxEntries = Math.max(
+      Number.isFinite(ctx3.maxEntries) ? ctx3.maxEntries : 0,
+      MAX_CONTEXT_ENTRIES
+    );
     const normalizedEntry = normalizeSessionContextEntry(entry);
+    try {
+      appendFileSync5(
+        ledgerPath,
+        JSON.stringify({
+          ...normalizedEntry,
+          ledgerSavedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          ledgerVersion: 1
+        }) + "\n",
+        "utf-8"
+      );
+    } catch {
+    }
     const hashToIndex = /* @__PURE__ */ new Map();
     for (let i2 = 0; i2 < ctx3.entries.length; i2++) {
       const existing = ctx3.entries[i2];
@@ -568316,7 +568427,7 @@ function saveSessionContext(repoRoot, entry) {
     try {
       writeFileSync45(
         join104(contextDir, "session-diary.md"),
-        renderSessionDiary(ctx3.entries.slice(-10)),
+        renderSessionDiary(ctx3.entries.slice(-MAX_SESSION_DIARY_ENTRIES)),
         "utf-8"
       );
     } catch {
@@ -568744,7 +568855,7 @@ function deleteUsageRecord(kind, value2, repoRoot) {
     remove(join104(repoRoot, OMNIUS_DIR, USAGE_HISTORY_FILE));
   }
 }
-var OMNIUS_DIR, LEGACY_DIRS, SUBDIRS, CONTEXT_FILES, PENDING_TASK_FILE, HANDOFF_FILE, CONTEXT_SAVE_FILE, MAX_CONTEXT_ENTRIES, SAME_TASK_REPLACE_WINDOW_MS, LOCK_TIMEOUT_MS, LOCK_RETRY_MS, LOCK_RETRY_MAX, SESSIONS_DIR, SESSIONS_INDEX, SKIP_DIRS2, HOME_SKIP_DIRS, USAGE_HISTORY_FILE, MAX_HISTORY_RECORDS;
+var OMNIUS_DIR, LEGACY_DIRS, SUBDIRS, CONTEXT_FILES, PENDING_TASK_FILE, HANDOFF_FILE, CONTEXT_SAVE_FILE, CONTEXT_LEDGER_FILE, MAX_CONTEXT_ENTRIES, MAX_SESSION_DIARY_ENTRIES, SAME_TASK_REPLACE_WINDOW_MS, LOCK_TIMEOUT_MS, LOCK_RETRY_MS, LOCK_RETRY_MAX, SESSIONS_DIR, SESSIONS_INDEX, SKIP_DIRS2, HOME_SKIP_DIRS, USAGE_HISTORY_FILE, MAX_HISTORY_RECORDS;
 var init_omnius_directory = __esm({
   "packages/cli/src/tui/omnius-directory.ts"() {
     "use strict";
@@ -568764,7 +568875,9 @@ var init_omnius_directory = __esm({
     PENDING_TASK_FILE = "pending-task.json";
     HANDOFF_FILE = "task-handoff.json";
     CONTEXT_SAVE_FILE = "session-context.json";
-    MAX_CONTEXT_ENTRIES = 20;
+    CONTEXT_LEDGER_FILE = "session-context.events.jsonl";
+    MAX_CONTEXT_ENTRIES = 200;
+    MAX_SESSION_DIARY_ENTRIES = 80;
     SAME_TASK_REPLACE_WINDOW_MS = 12 * 60 * 60 * 1e3;
     LOCK_TIMEOUT_MS = 5e3;
     LOCK_RETRY_MS = 50;
@@ -572786,6 +572899,106 @@ ${CONTENT_BG_SEQ}`);
           (seq) => seq.endsWith("m") ? seq : ""
         );
       }
+      reflowContentLines(livePartialLine, width) {
+        const maxWidth = Math.max(16, width);
+        const source = livePartialLine ? [...this._contentLines, livePartialLine] : this._contentLines;
+        return source.flatMap(
+          (line, idx) => this.reflowContentLine(line, maxWidth).map((segment) => ({
+            line: segment,
+            bufferIdx: idx
+          }))
+        );
+      }
+      reflowContentLine(line, width) {
+        const visible = stripAnsi(line);
+        if (visible.length <= width) return [line];
+        const continuationIndent = this.hangingIndentForVisibleLine(
+          visible,
+          width
+        );
+        const ranges = this.visibleWrapRanges(
+          visible,
+          width,
+          continuationIndent.length
+        );
+        if (ranges.length <= 1) return [line];
+        return ranges.map((range, idx) => {
+          const raw = this.rawSliceForVisibleRange(line, range.start, range.end);
+          return idx === 0 ? raw : continuationIndent + raw.trimStart();
+        });
+      }
+      hangingIndentForVisibleLine(visible, width) {
+        const capped = (n2) => " ".repeat(Math.max(0, Math.min(n2, width - 4)));
+        const patterns = [
+          /^(\s*(?:[│├└]\s*)?(?:[-*+○•]\s+))/,
+          /^(\s*(?:[│├└]\s*)?(?:\d+[.)]\s+))/,
+          /^(\s*(?:[│├└]\s*)?(?:>\s*))/,
+          /^(\s*(?:[│├└]\s*)?(?:[A-Za-z][\w.-]{0,28}:\s+))/
+        ];
+        for (const pattern of patterns) {
+          const match = visible.match(pattern);
+          if (match?.[1]) return capped(match[1].length);
+        }
+        return capped(visible.match(/^\s*/)?.[0].length ?? 0);
+      }
+      visibleWrapRanges(visible, width, continuationIndent) {
+        const ranges = [];
+        let start2 = 0;
+        let available = width;
+        while (start2 < visible.length) {
+          if (visible.length - start2 <= available) {
+            ranges.push({ start: start2, end: visible.length });
+            break;
+          }
+          const limit = start2 + available;
+          let breakAt = visible.lastIndexOf(" ", limit);
+          if (breakAt <= start2 + 2) breakAt = limit;
+          let end = breakAt;
+          while (end > start2 && /\s/.test(visible[end - 1] ?? "")) end--;
+          ranges.push({ start: start2, end: Math.max(start2 + 1, end) });
+          start2 = breakAt;
+          while (start2 < visible.length && /\s/.test(visible[start2] ?? "")) start2++;
+          available = Math.max(8, width - continuationIndent);
+        }
+        return ranges;
+      }
+      rawSliceForVisibleRange(line, start2, end) {
+        const startRaw = this.rawIndexForVisibleColumn(line, start2);
+        const endRaw = this.rawIndexForVisibleColumn(line, end);
+        const activeStyle = this.activeSgrAt(line, startRaw);
+        const raw = line.slice(startRaw, endRaw);
+        return activeStyle ? `${activeStyle}${raw}${RESET2}` : raw;
+      }
+      rawIndexForVisibleColumn(line, target) {
+        if (target <= 0) return 0;
+        let visible = 0;
+        for (let i2 = 0; i2 < line.length; i2++) {
+          if (line.charCodeAt(i2) === 27) {
+            const match = line.slice(i2).match(/^\x1B\[[0-?]*[ -/]*[@-~]/);
+            if (match) {
+              i2 += match[0].length - 1;
+              continue;
+            }
+          }
+          if (visible >= target) return i2;
+          visible++;
+        }
+        return line.length;
+      }
+      activeSgrAt(line, rawIndex) {
+        let active = "";
+        const sgr = /\x1B\[[0-9;]*m/g;
+        let match;
+        while ((match = sgr.exec(line)) && match.index < rawIndex) {
+          const seq = match[0];
+          if (seq === RESET2 || /\x1B\[(?:0|39|49)(?:;0)?m/.test(seq)) {
+            active = "";
+          } else {
+            active += seq;
+          }
+        }
+        return active;
+      }
       /**
        * Remove the last N lines from the content scrollback buffer and repaint.
        * Used by Esc-to-recall to erase the just-rendered user prompt.
@@ -572876,9 +573089,10 @@ ${CONTENT_BG_SEQ}`);
       repaintContent() {
         const h = this.contentHeight;
         const livePartialLine = this.getLiveBufferedLine();
-        const totalLines = this._contentLines.length + (livePartialLine ? 1 : 0);
-        const startIdx = Math.max(0, totalLines - h - this._contentScrollOffset);
         const w = termCols();
+        const reflowedLines = this.reflowContentLines(livePartialLine, w);
+        const totalLines = reflowedLines.length;
+        const startIdx = Math.max(0, totalLines - h - this._contentScrollOffset);
         const headerSafeFloor = layout().headerBottom + 1;
         let buf = "\x1B[?2026h";
         buf += "\x1B7";
@@ -572886,16 +573100,12 @@ ${CONTENT_BG_SEQ}`);
         const selRanges = this._textSelection.getSelectedRanges();
         for (let row = 0; row < h; row++) {
           const lineIdx = startIdx + row;
-          let line = "";
-          if (lineIdx < this._contentLines.length) {
-            line = this._contentLines[lineIdx];
-          } else if (livePartialLine && lineIdx === this._contentLines.length) {
-            line = livePartialLine;
-          }
+          const reflowed = reflowedLines[lineIdx];
+          let line = reflowed?.line ?? "";
           const screenRow = this.scrollRegionTop + row;
           if (screenRow < headerSafeFloor) continue;
           line = line.replace(/\x1B\[0m/g, `\x1B[0m${CONTENT_BG_SEQ}`);
-          const sel = selRanges.find((r2) => r2.bufferIdx === lineIdx);
+          const sel = selRanges.find((r2) => r2.bufferIdx === reflowed?.bufferIdx);
           if (sel) {
             line = TextSelection.applyHighlight(line, sel.startCol, sel.endCol);
           }
@@ -575667,7 +575877,7 @@ __export(setup_exports, {
 import * as readline from "node:readline";
 import { execSync as execSync50, spawn as spawn26, exec as exec4 } from "node:child_process";
 import { promisify as promisify6 } from "node:util";
-import { existsSync as existsSync90, writeFileSync as writeFileSync47, readFileSync as readFileSync74, appendFileSync as appendFileSync4, mkdirSync as mkdirSync52 } from "node:fs";
+import { existsSync as existsSync90, writeFileSync as writeFileSync47, readFileSync as readFileSync74, appendFileSync as appendFileSync6, mkdirSync as mkdirSync52 } from "node:fs";
 import { join as join107 } from "node:path";
 import { homedir as homedir34, platform as platform5 } from "node:os";
 function wrapText(value2, width) {
@@ -578034,7 +578244,7 @@ function ensurePathInShellRc(binDir) {
     const exportLine = `
 export PATH="${binDir}:$PATH"  # Added by omnius for nvim
 `;
-    appendFileSync4(rcFile, exportLine, "utf8");
+    appendFileSync6(rcFile, exportLine, "utf8");
     console.log(`  Added ${binDir} to ${rcFile}`);
   } catch {
   }
@@ -587604,7 +587814,7 @@ import {
   lstatSync,
   statSync as statSync37,
   rmSync as rmSync4,
-  appendFileSync as appendFileSync5
+  appendFileSync as appendFileSync7
 } from "node:fs";
 import { relative as relative11, join as join114 } from "node:path";
 async function _immediateReregister(newUrl) {
@@ -592004,7 +592214,7 @@ sleep 1
             const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}
 `;
             try {
-              appendFileSync5(_spLogFile, line);
+              appendFileSync7(_spLogFile, line);
             } catch {
             }
           };
@@ -592967,12 +593177,16 @@ sleep 1
           return "handled";
         }
         if (requested !== "auto" && requested !== "chat" && requested !== "action") {
-          renderWarning("Usage: /telegram mode auto|chat|action [--local]");
+          renderWarning("Usage: /telegram mode auto|chat|action [--global]");
           return "handled";
         }
-        ctx3.saveTelegramSettings?.({ mode: requested, local: isLocal });
+        const hasGlobalFlagMode = parts.includes("--global");
+        const projectRootMode = ctx3.repoRoot || process.cwd();
+        const projectHasOmniusMode = existsSync100(join114(projectRootMode, ".omnius"));
+        const wantsLocalMode = hasGlobalFlagMode ? false : isLocal || projectHasOmniusMode;
+        ctx3.saveTelegramSettings?.({ mode: requested, local: wantsLocalMode });
         ctx3.telegramSetInteractionMode?.(requested);
-        renderInfo(`Telegram interaction mode set to ${c3.bold(requested)}${isLocal ? " (project)" : " (global)"}.`);
+        renderInfo(`Telegram interaction mode set to ${c3.bold(requested)}${wantsLocalMode ? " (project)" : " (global)"}.`);
         return "handled";
       }
       if (parts[0] === "auth" || parts[0] === "authenticate") {
@@ -593219,18 +593433,23 @@ sleep 1
       }
       const keyIdx = parts.indexOf("--key");
       const adminIdx = parts.indexOf("--admin");
+      const hasGlobalFlag = parts.includes("--global");
+      const projectRoot = ctx3.repoRoot || process.cwd();
+      const projectHasOmnius = existsSync100(join114(projectRoot, ".omnius"));
+      const wantsLocal = hasGlobalFlag ? false : isLocal || projectHasOmnius;
       if (keyIdx !== -1 || adminIdx !== -1) {
         const settings = {
-          local: isLocal
+          local: wantsLocal
         };
-        const scope = isLocal ? "project" : "global";
+        const scope = wantsLocal ? "project" : "global";
         if (keyIdx !== -1) {
           const token = parts[keyIdx + 1];
           if (!token || token.startsWith("--")) {
             renderWarning(
-              "Usage: /telegram --key <bot-token> [--admin <id>] [--local]"
+              "Usage: /telegram --key <bot-token> [--admin <id>] [--global]"
             );
             renderInfo("Get a bot token from @BotFather on Telegram.");
+            renderInfo("Default scope: project-local when .omnius/ exists; use --global to override.");
             return "handled";
           }
           settings.key = token;
@@ -593239,7 +593458,7 @@ sleep 1
           const userId = parts[adminIdx + 1];
           if (!userId || userId.startsWith("--")) {
             renderWarning(
-              "Usage: /telegram --admin <user-id-or-username> [--key <token>] [--local]"
+              "Usage: /telegram --admin <user-id-or-username> [--key <token>] [--global]"
             );
             return "handled";
           }
@@ -593254,6 +593473,11 @@ sleep 1
           renderInfo(
             `Telegram admin set to ${c3.bold(settings.admin)} (${scope}).`
           );
+        if (wantsLocal && !projectHasOmnius) {
+          renderWarning(
+            "No .omnius/ in the current directory; this 'local' setting was written to ./.omnius/settings.json and only applies when omnius is invoked from this folder."
+          );
+        }
         if (!ctx3.isTelegramActive?.() && settings.key)
           renderInfo("Use /telegram to start.");
         return "handled";
@@ -593267,9 +593491,30 @@ sleep 1
         if (!settings.key) {
           renderWarning("No Telegram bot token configured.");
           renderInfo("Set one first: /telegram --key <bot-token>");
-          renderInfo("Get a token from @BotFather on Telegram.");
+          renderInfo("Get a token from @BotFather on Telegram. The token saves project-locally by default when .omnius/ exists.");
           return "handled";
         }
+        try {
+          const startProjectRoot = ctx3.repoRoot || process.cwd();
+          if (existsSync100(join114(startProjectRoot, ".omnius"))) {
+            const projectSettingsPath = join114(startProjectRoot, ".omnius", "settings.json");
+            let projectHasKey = false;
+            if (existsSync100(projectSettingsPath)) {
+              try {
+                const projectJson = JSON.parse(readFileSync81(projectSettingsPath, "utf8"));
+                projectHasKey = typeof projectJson?.telegramKey === "string" && projectJson.telegramKey.length > 0;
+              } catch {
+              }
+            }
+            if (!projectHasKey) {
+              renderWarning(
+                "Using GLOBAL Telegram token in a project that has no local key. Another omnius instance running with the same token will steal getUpdates and you'll see 409 conflicts."
+              );
+              renderInfo("Scope it locally: /telegram --key <token> (writes to ./.omnius/settings.json)");
+            }
+          }
+        } catch {
+        }
         try {
           await ctx3.telegramStart?.(settings.key, settings.admin);
         } catch (err) {
@@ -593281,8 +593526,8 @@ sleep 1
       }
       renderWarning(`Unknown argument: "${arg}"`);
       renderInfo("Usage:");
-      renderInfo("  /telegram --key <token>   Save bot token (global)");
-      renderInfo("  /telegram --admin <id>    Set admin filter (global)");
+      renderInfo("  /telegram --key <token>   Save bot token (project-local when .omnius/ exists)");
+      renderInfo("  /telegram --admin <id>    Set admin filter (project-local by default)");
       renderInfo("  /telegram                 Toggle on/off");
       renderInfo("  /telegram stop            Stop bridge");
       renderInfo("  /telegram status          Show status");
@@ -593301,7 +593546,7 @@ sleep 1
       renderInfo("  /telegram delete-messages <chat> <msg,msg> [reason]  Delete multiple messages");
       renderInfo("  /telegram delete-reaction <chat> <msg> --user <id>  Delete a reaction");
       renderInfo("  /telegram delete-reactions <chat> --user <id>  Delete recent reactions");
-      renderInfo("  Add --local to scope settings to this project only");
+      renderInfo("  Add --global to write to ~/.omnius/ (shared across all omnius instances)");
       return "handled";
     }
     case "platforms":
@@ -602934,10 +603179,13 @@ var init_stream_renderer = __esm({
         const words = text.split(/(\s+)/);
         const lines = [];
         let currentLine = "";
+        const continuationIndent = this.hangingIndentForText(text, maxWidth);
+        let available = maxWidth;
         for (const segment of words) {
-          if (currentLine.length + segment.length > maxWidth && currentLine.trim()) {
+          if (currentLine.length + segment.length > available && currentLine.trim()) {
             lines.push(currentLine.trimEnd());
-            currentLine = segment.replace(/^\s+/, "");
+            currentLine = continuationIndent + segment.replace(/^\s+/, "");
+            available = maxWidth;
           } else {
             currentLine += segment;
           }
@@ -602947,12 +603195,26 @@ var init_stream_renderer = __esm({
         }
         return lines.length > 0 ? lines : [text];
       }
+      hangingIndentForText(text, maxWidth) {
+        const capped = (n2) => " ".repeat(Math.max(0, Math.min(n2, maxWidth - 4)));
+        const patterns = [
+          /^(\s*(?:[-*+○•]\s+))/,
+          /^(\s*(?:\d+[.)]\s+))/,
+          /^(\s*(?:>\s*))/,
+          /^(\s*(?:[A-Za-z][\w.-]{0,28}:\s+))/
+        ];
+        for (const pattern of patterns) {
+          const match = text.match(pattern);
+          if (match?.[1]) return capped(match[1].length);
+        }
+        return capped(text.match(/^\s*/)?.[0].length ?? 0);
+      }
     };
   }
 });
 
 // packages/cli/src/tui/edit-history.ts
-import { appendFileSync as appendFileSync6, mkdirSync as mkdirSync60 } from "node:fs";
+import { appendFileSync as appendFileSync8, mkdirSync as mkdirSync60 } from "node:fs";
 import { join as join119 } from "node:path";
 function createEditHistoryLogger(repoRoot, sessionId) {
   const historyDir = join119(repoRoot, ".omnius", "history");
@@ -602973,7 +603235,7 @@ function createEditHistoryLogger(repoRoot, sessionId) {
       args: sanitizeArgs(toolName, toolArgs)
     };
     try {
-      appendFileSync6(logPath3, JSON.stringify(entry) + "\n", "utf-8");
+      appendFileSync8(logPath3, JSON.stringify(entry) + "\n", "utf-8");
     } catch {
     }
   }
@@ -608356,6 +608618,9 @@ function upsertTelegramReflectionMessage(repoRoot, sessionKey, entry, options2)
       content,
       labels: [entry.mode, entry.mediaSummary, senderLabel(entry)].filter((value2) => Boolean(value2))
     });
+    if (typeof entry.ts === "number" && Number.isFinite(entry.ts) && result.episodeId) {
+      store2.getDb().prepare("UPDATE episodes SET timestamp = ? WHERE id = ?").run(entry.ts, result.episodeId);
+    }
     addTextEdges(graph, result, entry);
     const after = store2.count(sessionKey);
     return { episodeId: result.episodeId, reused: after === before };
@@ -608418,6 +608683,9 @@ async function buildTelegramReflectionCorpus(options2) {
         content,
         labels: [entry.mode, entry.mediaSummary, senderLabel(entry)].filter((value2) => Boolean(value2))
       });
+      if (typeof entry.ts === "number" && Number.isFinite(entry.ts) && result.episodeId) {
+        store2.getDb().prepare("UPDATE episodes SET timestamp = ? WHERE id = ?").run(entry.ts, result.episodeId);
+      }
       addTextEdges(graph, result, entry);
       const after = store2.count(options2.sessionKey);
       if (after === before) reusedEpisodes++;
@@ -609061,7 +609329,7 @@ var init_vision_ingress = __esm({
 });
 
 // packages/cli/src/tui/telegram-bridge.ts
-import { mkdirSync as mkdirSync65, existsSync as existsSync112, unlinkSync as unlinkSync22, readdirSync as readdirSync40, statSync as statSync39, statfsSync as statfsSync5, readFileSync as readFileSync92, writeFileSync as writeFileSync59 } from "node:fs";
+import { mkdirSync as mkdirSync65, existsSync as existsSync112, unlinkSync as unlinkSync22, readdirSync as readdirSync40, statSync as statSync39, statfsSync as statfsSync5, readFileSync as readFileSync92, writeFileSync as writeFileSync59, appendFileSync as appendFileSync9 } from "node:fs";
 import { join as join127, resolve as resolve43, basename as basename27, relative as relative13, isAbsolute as isAbsolute8, extname as extname16 } from "node:path";
 import { writeFile as writeFileAsync } from "node:fs/promises";
 import { createHash as createHash23, randomBytes as randomBytes22, randomInt } from "node:crypto";
@@ -610277,7 +610545,7 @@ function renderTelegramSubAgentError(username, error) {
   process.stdout.write(`    ${c3.dim("│")} ${c3.red("✘")} @${username}: ${c3.dim(preview)}
 `);
 }
-var TELEGRAM_TOOL_ACTION_GROUPS, TELEGRAM_TOOL_ACTION_GROUP, TELEGRAM_TOOL_MUTATING_GROUPS, DEFAULT_TELEGRAM_TOOL_GROUP_POLICY, TELEGRAM_TOOL_BUTTON_LABELS, TELEGRAM_SAFETY_PROMPT, ADMIN_DM_PROMPT, ADMIN_GROUP_PROMPT, TELEGRAM_PUBLIC_SOUL_PROFILE, TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT, TELEGRAM_PUBLIC_MEMORY_SCOPE_CONTRACT, TELEGRAM_PUBLIC_VISION_STACK_CONTRACT, GROUP_REPLY_DISCRETION_PROMPT, TELEGRAM_CHAT_MODE_PROMPT, ADMIN_CHAT_PROFILE_PROMPT, TELEGRAM_ACTION_RESPONSE_CONTRACT, TELEGRAM_EXTERNAL_ACQUISITION_CONTRACT, TELEGRAM_STUCK_SELF_TALK_PREFIXES, TELEGRAM_CHAT_HISTORY_LIMIT, TELEGRAM_CONTEXT_RECENT_DEFAULT, TELEGRAM_CONTEXT_LINE_LIMIT, TELEGRAM_CONTEXT_SAMPLE_LIMIT, TELEGRAM_MEMORY_CARD_LIMIT, TELEGRAM_MEMORY_NOTE_LIMIT, TELEGRAM_MEMORY_STOPWORDS, TELEGRAM_SUB_AGENT_BOUNDED_OPTIONS, TELEGRAM_PUBLIC_HELP_COMMANDS, TELEGRAM_REMINDER_SLASH_COMMANDS, TELEGRAM_REFLECTION_SLASH_COMMANDS, TELEGRAM_IMAGE_EXTENSIONS, MEDIA_CACHE_TTL_MS, TELEGRAM_CHANNEL_DMN_SWEEP_MS, TELEGRAM_CHANNEL_DMN_IDLE_AFTER_MS, TELEGRAM_CHANNEL_DMN_MIN_INTERVAL_MS, TELEGRAM_CHANNEL_DMN_MIN_MESSAGES, TELEGRAM_PUBLIC_TOOL_QUOTAS, TelegramBridge;
+var TELEGRAM_TOOL_ACTION_GROUPS, TELEGRAM_TOOL_ACTION_GROUP, TELEGRAM_TOOL_MUTATING_GROUPS, DEFAULT_TELEGRAM_TOOL_GROUP_POLICY, TELEGRAM_TOOL_BUTTON_LABELS, TELEGRAM_SAFETY_PROMPT, ADMIN_DM_PROMPT, ADMIN_GROUP_PROMPT, TELEGRAM_PUBLIC_SOUL_PROFILE, TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT, TELEGRAM_PUBLIC_MEMORY_SCOPE_CONTRACT, TELEGRAM_PUBLIC_VISION_STACK_CONTRACT, GROUP_REPLY_DISCRETION_PROMPT, TELEGRAM_CHAT_MODE_PROMPT, ADMIN_CHAT_PROFILE_PROMPT, TELEGRAM_ACTION_RESPONSE_CONTRACT, TELEGRAM_EXTERNAL_ACQUISITION_CONTRACT, TELEGRAM_STUCK_SELF_TALK_PREFIXES, TELEGRAM_CHAT_HISTORY_LIMIT, TELEGRAM_CONTEXT_RECENT_DEFAULT, TELEGRAM_CONTEXT_LINE_LIMIT, TELEGRAM_CONTEXT_SAMPLE_LIMIT, TELEGRAM_MEMORY_CARD_LIMIT, TELEGRAM_MEMORY_NOTE_LIMIT, TELEGRAM_ASSOCIATIVE_FACT_LIMIT, TELEGRAM_ASSOCIATIVE_USER_FACT_LIMIT, TELEGRAM_ASSOCIATIVE_ACTION_LIMIT, TELEGRAM_ASSOCIATIVE_RELATION_LIMIT, TELEGRAM_MEMORY_STOPWORDS, TELEGRAM_SUB_AGENT_BOUNDED_OPTIONS, TELEGRAM_PUBLIC_HELP_COMMANDS, TELEGRAM_REMINDER_SLASH_COMMANDS, TELEGRAM_REFLECTION_SLASH_COMMANDS, TELEGRAM_IMAGE_EXTENSIONS, MEDIA_CACHE_TTL_MS, TELEGRAM_CHANNEL_DMN_SWEEP_MS, TELEGRAM_CHANNEL_DMN_IDLE_AFTER_MS, TELEGRAM_CHANNEL_DMN_MIN_INTERVAL_MS, TELEGRAM_CHANNEL_DMN_MIN_MESSAGES, TELEGRAM_PUBLIC_TOOL_QUOTAS, TelegramBridge;
 var init_telegram_bridge = __esm({
   "packages/cli/src/tui/telegram-bridge.ts"() {
     "use strict";
@@ -610296,7 +610564,9 @@ var init_telegram_bridge = __esm({
     init_visual_identity_association();
     init_telegram_channel_dmn();
     init_telegram_reflection_corpus();
+    init_memory_paths();
     init_telegram_reflection_extraction();
+    init_dist7();
     TELEGRAM_TOOL_ACTION_GROUPS = [
       "read",
       "message",
@@ -610458,6 +610728,7 @@ PUBLIC TELEGRAM MEMORY SCOPE
 
 This turn may use memory and conversation history for the current Telegram group/private chat scope only.
 Users in a shared public group may ask questions about that shared group history and group memory, scoped by the current group id or by a user id/username inside that same group.
+Durable associative memory, participant profiles, relationships, and action ledgers persist on disk across Omnius terminal sessions and package updates. Use those recalled facts when the current sender or topic matches them; treat user assertions as scoped memory evidence, not universal truth.
 Private chats, admin DMs, other groups, local terminal sessions, and fragmented private contexts are not visible from this public group. Do not imply they exist and do not answer from them.
 `.trim();
     TELEGRAM_PUBLIC_VISION_STACK_CONTRACT = `
@@ -610538,12 +610809,16 @@ External acquisition contract:
       /^hmm,?\s+(let me|maybe|wait)\b/i,
       /^ok(ay)?,?\s+let me try\b/i
     ];
-    TELEGRAM_CHAT_HISTORY_LIMIT = 240;
+    TELEGRAM_CHAT_HISTORY_LIMIT = 5e3;
     TELEGRAM_CONTEXT_RECENT_DEFAULT = 36;
     TELEGRAM_CONTEXT_LINE_LIMIT = 320;
     TELEGRAM_CONTEXT_SAMPLE_LIMIT = 10;
-    TELEGRAM_MEMORY_CARD_LIMIT = 80;
-    TELEGRAM_MEMORY_NOTE_LIMIT = 8;
+    TELEGRAM_MEMORY_CARD_LIMIT = 240;
+    TELEGRAM_MEMORY_NOTE_LIMIT = 24;
+    TELEGRAM_ASSOCIATIVE_FACT_LIMIT = 600;
+    TELEGRAM_ASSOCIATIVE_USER_FACT_LIMIT = 80;
+    TELEGRAM_ASSOCIATIVE_ACTION_LIMIT = 5e3;
+    TELEGRAM_ASSOCIATIVE_RELATION_LIMIT = 300;
     TELEGRAM_MEMORY_STOPWORDS = /* @__PURE__ */ new Set([
       "about",
       "after",
@@ -610627,6 +610902,7 @@ External acquisition contract:
         this.telegramToolPolicy = resolveSettings(repoRoot || ".").telegramToolPolicy ?? {};
         this.mediaCacheDir = resolve43(repoRoot || ".", ".omnius", "telegram-media-cache");
         this.telegramConversationDir = resolve43(repoRoot || ".", ".omnius", "telegram-conversations");
+        this.telegramSqlitePath = resolve43(repoRoot || ".", ".omnius", "telegram.sqlite");
         this.telegramToolButtonDir = resolve43(repoRoot || ".", ".omnius", "telegram-tool-buttons");
       }
       botToken;
@@ -610658,6 +610934,8 @@ External acquisition contract:
       chatParticipants = /* @__PURE__ */ new Map();
       /** Lightweight Zettelkasten-style memory cards by chat/guest session key */
       chatMemoryCards = /* @__PURE__ */ new Map();
+      /** Durable associative memory by scoped Telegram chat key. */
+      chatAssociativeMemory = /* @__PURE__ */ new Map();
       /** Generic chronological attention cadence shared by live surfaces. */
       stimulation = new StimulationController();
       /** Throttles noisy "skipped group chatter" waterfall logs */
@@ -610707,6 +610985,15 @@ External acquisition contract:
       mediaCacheDir;
       /** Persistent conversation memory directory */
       telegramConversationDir;
+      /** Durable SQLite mirror for raw Telegram messages and metadata. */
+      telegramSqlitePath;
+      telegramSqliteDb = null;
+      /**
+       * Per-bot ownership lockfile under .omnius/telegram-runner-state/.
+       * Prevents two omnius instances from polling the same bot token concurrently
+       * (which would cause silent 409 conflicts on getUpdates). Released in stop().
+       */
+      telegramOwnerLockFile = null;
       /** Session keys loaded from persistent conversation memory */
       loadedConversationState = /* @__PURE__ */ new Set();
       /** True once persisted Telegram conversation scopes have been bulk-loaded. */
@@ -610993,12 +611280,26 @@ No scoped reflection artifact exists yet for this chat. Use <code>/reflect</code
       }
       recordChatHistory(sessionKey, entry) {
         this.ensureTelegramConversationLoaded(sessionKey);
+        const stamped = { ...entry, ts: entry.ts ?? Date.now() };
         const existing = this.chatHistory.get(sessionKey) ?? [];
-        existing.push({ ...entry, ts: entry.ts ?? Date.now() });
+        existing.push(stamped);
         if (existing.length > TELEGRAM_CHAT_HISTORY_LIMIT) {
           existing.splice(0, existing.length - TELEGRAM_CHAT_HISTORY_LIMIT);
         }
         this.chatHistory.set(sessionKey, existing);
+        this.appendTelegramConversationLedger(sessionKey, stamped);
+      }
+      appendTelegramConversationLedger(sessionKey, entry) {
+        if (!this.repoRoot) return;
+        try {
+          mkdirSync65(this.telegramConversationDir, { recursive: true });
+          appendFileSync9(
+            this.telegramConversationLedgerPath(sessionKey),
+            JSON.stringify({ sessionKey, ...entry }) + "\n",
+            "utf8"
+          );
+        } catch {
+        }
       }
       telegramReplySenderWithSelfFlag(sender) {
         if (!sender) return void 0;
@@ -611226,6 +611527,272 @@ ${mediaContext}` : ""
         const safe = createHash23("sha1").update(sessionKey).digest("hex").slice(0, 20);
         return join127(this.telegramConversationDir, `${safe}.json`);
       }
+      telegramConversationLedgerPath(sessionKey) {
+        const safe = createHash23("sha1").update(sessionKey).digest("hex").slice(0, 20);
+        return join127(this.telegramConversationDir, `${safe}.events.jsonl`);
+      }
+      telegramDb() {
+        if (this.telegramSqliteDb === false) return null;
+        if (this.telegramSqliteDb) return this.telegramSqliteDb;
+        if (!this.repoRoot) {
+          this.telegramSqliteDb = false;
+          return null;
+        }
+        try {
+          mkdirSync65(resolve43(this.repoRoot, ".omnius"), { recursive: true });
+          const db = initDb(this.telegramSqlitePath);
+          db.exec(`
+        CREATE TABLE IF NOT EXISTS telegram_messages (
+          session_key TEXT NOT NULL,
+          chat_id TEXT NOT NULL,
+          chat_type TEXT,
+          chat_title TEXT,
+          message_id INTEGER NOT NULL,
+          message_thread_id INTEGER,
+          update_id INTEGER,
+          telegram_date INTEGER,
+          received_at INTEGER NOT NULL,
+          role TEXT NOT NULL DEFAULT 'user',
+          from_user_id INTEGER,
+          username TEXT,
+          first_name TEXT,
+          text TEXT,
+          raw_json TEXT NOT NULL,
+          normalized_json TEXT NOT NULL,
+          reply_to_message_id INTEGER,
+          reply_to_username TEXT,
+          media_json TEXT,
+          PRIMARY KEY (chat_id, message_id, role)
+        );
+        CREATE INDEX IF NOT EXISTS idx_telegram_messages_session_time ON telegram_messages(session_key, received_at);
+        CREATE INDEX IF NOT EXISTS idx_telegram_messages_user_time ON telegram_messages(session_key, from_user_id, received_at);
+        CREATE INDEX IF NOT EXISTS idx_telegram_messages_username_time ON telegram_messages(session_key, username, received_at);
+        CREATE VIRTUAL TABLE IF NOT EXISTS telegram_messages_fts USING fts5(
+          session_key UNINDEXED,
+          chat_id UNINDEXED,
+          message_id UNINDEXED,
+          username,
+          first_name,
+          text,
+          content='telegram_messages',
+          content_rowid='rowid'
+        );
+        CREATE TRIGGER IF NOT EXISTS telegram_messages_ai AFTER INSERT ON telegram_messages BEGIN
+          INSERT INTO telegram_messages_fts(rowid, session_key, chat_id, message_id, username, first_name, text)
+          VALUES (new.rowid, new.session_key, new.chat_id, new.message_id, new.username, new.first_name, new.text);
+        END;
+        CREATE TRIGGER IF NOT EXISTS telegram_messages_ad AFTER DELETE ON telegram_messages BEGIN
+          INSERT INTO telegram_messages_fts(telegram_messages_fts, rowid, session_key, chat_id, message_id, username, first_name, text)
+          VALUES('delete', old.rowid, old.session_key, old.chat_id, old.message_id, old.username, old.first_name, old.text);
+        END;
+        CREATE TRIGGER IF NOT EXISTS telegram_messages_au AFTER UPDATE ON telegram_messages BEGIN
+          INSERT INTO telegram_messages_fts(telegram_messages_fts, rowid, session_key, chat_id, message_id, username, first_name, text)
+          VALUES('delete', old.rowid, old.session_key, old.chat_id, old.message_id, old.username, old.first_name, old.text);
+          INSERT INTO telegram_messages_fts(rowid, session_key, chat_id, message_id, username, first_name, text)
+          VALUES (new.rowid, new.session_key, new.chat_id, new.message_id, new.username, new.first_name, new.text);
+        END;
+      `);
+          this.telegramSqliteDb = db;
+          return db;
+        } catch {
+          this.telegramSqliteDb = false;
+          return null;
+        }
+      }
+      persistTelegramRawMessage(update2, msg) {
+        const db = this.telegramDb();
+        if (!db) return;
+        const rawMessage = update2.message ?? update2.guest_message ?? update2.edited_message ?? update2.channel_post ?? {};
+        const sessionKey = this.sessionKeyForMessage(msg);
+        const media = msg.media || msg.replyToMedia || msg.livePhoto;
+        try {
+          db.prepare(`
+        INSERT INTO telegram_messages (
+          session_key, chat_id, chat_type, chat_title, message_id, message_thread_id,
+          update_id, telegram_date, received_at, role, from_user_id, username, first_name,
+          text, raw_json, normalized_json, reply_to_message_id, reply_to_username, media_json
+        ) VALUES (
+          @session_key, @chat_id, @chat_type, @chat_title, @message_id, @message_thread_id,
+          @update_id, @telegram_date, @received_at, 'user', @from_user_id, @username, @first_name,
+          @text, @raw_json, @normalized_json, @reply_to_message_id, @reply_to_username, @media_json
+        )
+        ON CONFLICT(chat_id, message_id, role) DO UPDATE SET
+          session_key=excluded.session_key,
+          chat_type=excluded.chat_type,
+          chat_title=excluded.chat_title,
+          message_thread_id=excluded.message_thread_id,
+          update_id=excluded.update_id,
+          telegram_date=excluded.telegram_date,
+          received_at=excluded.received_at,
+          from_user_id=excluded.from_user_id,
+          username=excluded.username,
+          first_name=excluded.first_name,
+          text=excluded.text,
+          raw_json=excluded.raw_json,
+          normalized_json=excluded.normalized_json,
+          reply_to_message_id=excluded.reply_to_message_id,
+          reply_to_username=excluded.reply_to_username,
+          media_json=excluded.media_json
+      `).run({
+            session_key: sessionKey,
+            chat_id: String(msg.chatId),
+            chat_type: msg.chatType,
+            chat_title: msg.chatTitle ?? null,
+            message_id: msg.messageId,
+            message_thread_id: msg.messageThreadId ?? null,
+            update_id: typeof update2.update_id === "number" ? update2.update_id : null,
+            telegram_date: typeof rawMessage.date === "number" ? rawMessage.date : null,
+            received_at: Date.now(),
+            from_user_id: msg.fromUserId ?? null,
+            username: msg.username || null,
+            first_name: msg.firstName || null,
+            text: msg.text || "",
+            raw_json: JSON.stringify(rawMessage),
+            normalized_json: JSON.stringify(msg),
+            reply_to_message_id: msg.replyToMessageId ?? null,
+            reply_to_username: msg.replyToUsername || null,
+            media_json: media ? JSON.stringify(media) : null
+          });
+        } catch {
+        }
+      }
+      persistTelegramAssistantMessage(msg, text, messageId, replyToMessageId) {
+        if (!messageId) return;
+        const db = this.telegramDb();
+        if (!db) return;
+        const sessionKey = this.sessionKeyForMessage(msg);
+        const now = Date.now();
+        const normalized = {
+          role: "assistant",
+          chatId: msg.chatId,
+          chatType: msg.chatType,
+          chatTitle: msg.chatTitle,
+          messageId,
+          messageThreadId: msg.messageThreadId,
+          replyToMessageId,
+          username: this.state.botUsername || "omnius",
+          text
+        };
+        try {
+          db.prepare(`
+        INSERT INTO telegram_messages (
+          session_key, chat_id, chat_type, chat_title, message_id, message_thread_id,
+          update_id, telegram_date, received_at, role, from_user_id, username, first_name,
+          text, raw_json, normalized_json, reply_to_message_id, reply_to_username, media_json
+        ) VALUES (
+          @session_key, @chat_id, @chat_type, @chat_title, @message_id, @message_thread_id,
+          NULL, NULL, @received_at, 'assistant', NULL, @username, 'Omnius',
+          @text, @raw_json, @normalized_json, @reply_to_message_id, NULL, NULL
+        )
+        ON CONFLICT(chat_id, message_id, role) DO UPDATE SET
+          session_key=excluded.session_key,
+          chat_type=excluded.chat_type,
+          chat_title=excluded.chat_title,
+          message_thread_id=excluded.message_thread_id,
+          received_at=excluded.received_at,
+          username=excluded.username,
+          text=excluded.text,
+          raw_json=excluded.raw_json,
+          normalized_json=excluded.normalized_json,
+          reply_to_message_id=excluded.reply_to_message_id
+      `).run({
+            session_key: sessionKey,
+            chat_id: String(msg.chatId),
+            chat_type: msg.chatType,
+            chat_title: msg.chatTitle ?? null,
+            message_id: messageId,
+            message_thread_id: msg.messageThreadId ?? null,
+            received_at: now,
+            username: this.state.botUsername || "omnius",
+            text,
+            raw_json: JSON.stringify(normalized),
+            normalized_json: JSON.stringify(normalized),
+            reply_to_message_id: replyToMessageId ?? null
+          });
+        } catch {
+        }
+      }
+      createTelegramAssociativeMemory() {
+        const now = Date.now();
+        return {
+          version: 1,
+          createdAt: now,
+          updatedAt: now,
+          facts: [],
+          users: {},
+          relationships: [],
+          actions: []
+        };
+      }
+      normalizeTelegramAssociativeMemory(raw) {
+        const created = this.createTelegramAssociativeMemory();
+        const users = {};
+        const rawUsers = raw.users && typeof raw.users === "object" ? raw.users : {};
+        for (const [key, user] of Object.entries(rawUsers)) {
+          if (!user || typeof user !== "object") continue;
+          users[key] = {
+            username: String(user.username || "unknown"),
+            displayName: user.displayName,
+            userId: typeof user.userId === "number" ? user.userId : void 0,
+            aliases: Array.isArray(user.aliases) ? user.aliases.map(String).slice(0, 20) : [],
+            firstSeenTs: typeof user.firstSeenTs === "number" ? user.firstSeenTs : created.createdAt,
+            lastSeenTs: typeof user.lastSeenTs === "number" ? user.lastSeenTs : created.updatedAt,
+            messageCount: typeof user.messageCount === "number" ? user.messageCount : 0,
+            directAddressCount: typeof user.directAddressCount === "number" ? user.directAddressCount : 0,
+            replyCount: typeof user.replyCount === "number" ? user.replyCount : 0,
+            toneTags: Array.isArray(user.toneTags) ? user.toneTags.map(String).slice(0, 20) : [],
+            facts: Array.isArray(user.facts) ? user.facts.slice(0, TELEGRAM_ASSOCIATIVE_USER_FACT_LIMIT).map((fact) => this.normalizeTelegramAssociativeFact(fact)) : [],
+            relationshipHints: Array.isArray(user.relationshipHints) ? user.relationshipHints.map(String).slice(0, 80) : [],
+            recentTopics: Array.isArray(user.recentTopics) ? user.recentTopics.map(String).slice(0, 80) : [],
+            lastMessages: Array.isArray(user.lastMessages) ? user.lastMessages.map(String).slice(-40) : []
+          };
+        }
+        return {
+          version: typeof raw.version === "number" ? raw.version : 1,
+          createdAt: typeof raw.createdAt === "number" ? raw.createdAt : created.createdAt,
+          updatedAt: typeof raw.updatedAt === "number" ? raw.updatedAt : created.updatedAt,
+          facts: Array.isArray(raw.facts) ? raw.facts.slice(0, TELEGRAM_ASSOCIATIVE_FACT_LIMIT).map((fact) => this.normalizeTelegramAssociativeFact(fact)) : [],
+          users,
+          relationships: Array.isArray(raw.relationships) ? raw.relationships.slice(0, TELEGRAM_ASSOCIATIVE_RELATION_LIMIT).map((fact) => this.normalizeTelegramAssociativeFact(fact)) : [],
+          actions: Array.isArray(raw.actions) ? raw.actions.slice(-TELEGRAM_ASSOCIATIVE_ACTION_LIMIT).map((action) => ({
+            id: String(action.id || createHash23("sha1").update(JSON.stringify(action)).digest("hex").slice(0, 12)),
+            ts: typeof action.ts === "number" ? action.ts : Date.now(),
+            role: action.role === "assistant" ? "assistant" : "user",
+            speaker: String(action.speaker || "unknown"),
+            mode: action.mode,
+            text: String(action.text || ""),
+            messageId: typeof action.messageId === "number" ? action.messageId : void 0,
+            replyToMessageId: typeof action.replyToMessageId === "number" ? action.replyToMessageId : void 0,
+            userId: typeof action.userId === "number" ? action.userId : void 0,
+            username: typeof action.username === "string" ? action.username : void 0
+          })) : []
+        };
+      }
+      normalizeTelegramAssociativeFact(raw) {
+        const text = String(raw.text || "").trim();
+        const now = Date.now();
+        return {
+          id: String(raw.id || createHash23("sha1").update(text || String(now)).digest("hex").slice(0, 12)),
+          text,
+          tags: Array.isArray(raw.tags) ? raw.tags.map(String).slice(0, 16) : [],
+          speakers: Array.isArray(raw.speakers) ? raw.speakers.map(String).slice(0, 16) : [],
+          userIds: Array.isArray(raw.userIds) ? raw.userIds.filter((id) => typeof id === "number").slice(0, 32) : [],
+          usernames: Array.isArray(raw.usernames) ? raw.usernames.map(String).slice(0, 32) : [],
+          messageIds: Array.isArray(raw.messageIds) ? raw.messageIds.filter((id) => typeof id === "number").slice(0, 80) : [],
+          createdAt: typeof raw.createdAt === "number" ? raw.createdAt : now,
+          updatedAt: typeof raw.updatedAt === "number" ? raw.updatedAt : now,
+          weight: typeof raw.weight === "number" ? raw.weight : 1
+        };
+      }
+      telegramAssociativeMemoryForSession(sessionKey) {
+        this.ensureTelegramConversationLoaded(sessionKey);
+        let memory = this.chatAssociativeMemory.get(sessionKey);
+        if (!memory) {
+          memory = this.createTelegramAssociativeMemory();
+          this.chatAssociativeMemory.set(sessionKey, memory);
+        }
+        return memory;
+      }
       telegramPersonalityScope(sessionKey, msg) {
         const label = msg.chatType !== "private" ? `${msg.chatTitle || msg.chatType}-${String(msg.chatId)}` : `private-${msg.username || msg.fromUserId || msg.chatId}`;
         return {
@@ -611242,8 +611809,9 @@ ${mediaContext}` : ""
         if (!existsSync112(path12)) return;
         try {
           const parsed = JSON.parse(readFileSync92(path12, "utf8"));
+          const loadedHistory = Array.isArray(parsed.history) ? parsed.history : [];
           if (Array.isArray(parsed.history)) {
-            this.chatHistory.set(sessionKey, parsed.history.slice(-TELEGRAM_CHAT_HISTORY_LIMIT));
+            this.chatHistory.set(sessionKey, loadedHistory.slice(-TELEGRAM_CHAT_HISTORY_LIMIT));
           }
           if (Array.isArray(parsed.participants)) {
             const participants = /* @__PURE__ */ new Map();
@@ -611257,8 +611825,28 @@ ${mediaContext}` : ""
             }
             this.chatParticipants.set(sessionKey, participants);
           }
-          if (Array.isArray(parsed.memoryCards)) {
+          const cardsLookTruncated = Array.isArray(parsed.memoryCards) && parsed.memoryCards.some((card) => Array.isArray(card.notes) && card.notes.some((note) => typeof note === "string" && note.endsWith("...")));
+          if (Array.isArray(parsed.memoryCards) && !cardsLookTruncated) {
             this.chatMemoryCards.set(sessionKey, parsed.memoryCards.slice(0, TELEGRAM_MEMORY_CARD_LIMIT));
+          } else if (loadedHistory.length > 0) {
+            this.chatMemoryCards.set(sessionKey, []);
+            for (const entry of loadedHistory) {
+              this.updateTelegramMemoryCards(sessionKey, entry);
+            }
+          }
+          const associativeLooksTruncated = parsed.associativeMemory && Array.isArray(parsed.associativeMemory.facts) && parsed.associativeMemory.facts.some(
+            (fact) => typeof fact?.text === "string" && fact.text.endsWith("...")
+          );
+          if (parsed.associativeMemory && !associativeLooksTruncated) {
+            this.chatAssociativeMemory.set(
+              sessionKey,
+              this.normalizeTelegramAssociativeMemory(parsed.associativeMemory)
+            );
+          } else if (loadedHistory.length > 0) {
+            this.hydrateTelegramAssociativeMemoryFromHistory(sessionKey, loadedHistory);
+          }
+          if (loadedHistory.length > 0) {
+            this.backfillTelegramLoadedHistory(sessionKey, loadedHistory);
           }
           if (parsed.stimulation) {
             this.stimulation.setState(sessionKey, parsed.stimulation);
@@ -611273,6 +611861,108 @@ ${mediaContext}` : ""
         } catch {
         }
       }
+      hydrateTelegramAssociativeMemoryFromHistory(sessionKey, history) {
+        const memory = this.createTelegramAssociativeMemory();
+        this.chatAssociativeMemory.set(sessionKey, memory);
+        for (const entry of history) {
+          this.updateTelegramAssociativeMemory(sessionKey, entry);
+        }
+      }
+      telegramHistoryBackfillMessageId(sessionKey, entry, index) {
+        if (typeof entry.messageId === "number" && Number.isFinite(entry.messageId)) return entry.messageId;
+        const digest3 = createHash23("sha1").update(`${sessionKey}:${index}:${entry.role}:${entry.ts ?? ""}:${entry.text}`).digest("hex").slice(0, 8);
+        return -Number.parseInt(digest3, 16);
+      }
+      backfillTelegramLoadedHistory(sessionKey, history) {
+        if (!this.repoRoot || history.length === 0) return;
+        const db = this.telegramDb();
+        if (db) {
+          try {
+            const existing = db.prepare("SELECT COUNT(*) AS n FROM telegram_messages WHERE session_key = ?").get(sessionKey);
+            if ((existing?.n ?? 0) < history.length) {
+              const insert = db.prepare(`
+            INSERT INTO telegram_messages (
+              session_key, chat_id, chat_type, chat_title, message_id, message_thread_id,
+              update_id, telegram_date, received_at, role, from_user_id, username, first_name,
+              text, raw_json, normalized_json, reply_to_message_id, reply_to_username, media_json
+            ) VALUES (
+              @session_key, @chat_id, @chat_type, @chat_title, @message_id, @message_thread_id,
+              NULL, NULL, @received_at, @role, @from_user_id, @username, @first_name,
+              @text, @raw_json, @normalized_json, @reply_to_message_id, @reply_to_username, @media_json
+            )
+            ON CONFLICT(chat_id, message_id, role) DO UPDATE SET
+              session_key=excluded.session_key,
+              chat_type=excluded.chat_type,
+              chat_title=excluded.chat_title,
+              message_thread_id=excluded.message_thread_id,
+              received_at=excluded.received_at,
+              from_user_id=excluded.from_user_id,
+              username=excluded.username,
+              first_name=excluded.first_name,
+              text=excluded.text,
+              raw_json=excluded.raw_json,
+              normalized_json=excluded.normalized_json,
+              reply_to_message_id=excluded.reply_to_message_id,
+              reply_to_username=excluded.reply_to_username,
+              media_json=excluded.media_json
+          `);
+              const transaction = db.transaction((entries) => {
+                entries.forEach((entry, index) => {
+                  const messageId = this.telegramHistoryBackfillMessageId(sessionKey, entry, index);
+                  const chatId = entry.chatId !== void 0 ? String(entry.chatId) : sessionKey.replace(/^chat:/, "");
+                  insert.run({
+                    session_key: sessionKey,
+                    chat_id: chatId || "unknown",
+                    chat_type: entry.chatType || null,
+                    chat_title: entry.chatTitle || null,
+                    message_id: messageId,
+                    message_thread_id: entry.messageThreadId ?? null,
+                    received_at: entry.ts ?? Date.now(),
+                    role: entry.role === "assistant" ? "assistant" : "user",
+                    from_user_id: entry.fromUserId ?? null,
+                    username: entry.role === "assistant" ? this.state.botUsername || "omnius" : entry.username || null,
+                    first_name: entry.role === "assistant" ? "Omnius" : entry.firstName || null,
+                    text: entry.text || "",
+                    raw_json: JSON.stringify({ source: "telegram-conversations", sessionKey, entry }),
+                    normalized_json: JSON.stringify({ ...entry, messageId }),
+                    reply_to_message_id: entry.replyToMessageId ?? null,
+                    reply_to_username: entry.replyContext?.sender?.username || null,
+                    media_json: entry.mediaSummary ? JSON.stringify({ summary: entry.mediaSummary }) : null
+                  });
+                });
+              });
+              transaction(history);
+              try {
+                db.exec("INSERT INTO telegram_messages_fts(telegram_messages_fts) VALUES('rebuild')");
+              } catch {
+              }
+            }
+          } catch {
+          }
+        }
+        try {
+          const paths = omniusMemoryDbPaths(this.repoRoot);
+          const graph = new TemporalGraph(paths.knowledge);
+          const store2 = new EpisodeStore(paths.episodes, graph);
+          let existingTelegramEpisodes = 0;
+          try {
+            const row = store2.getDb().prepare(`
+          SELECT COUNT(*) AS n FROM episodes
+          WHERE session_id = ? AND metadata LIKE '%"sourceSurface":"telegram"%'
+        `).get(sessionKey);
+            existingTelegramEpisodes = row?.n ?? 0;
+          } finally {
+            store2.close();
+            graph.close();
+          }
+          if (existingTelegramEpisodes < history.length) {
+            for (const entry of history) {
+              this.upsertTelegramReflectionHistoryEntry(sessionKey, entry);
+            }
+          }
+        } catch {
+        }
+      }
       ensureAllTelegramConversationsLoaded() {
         if (this.loadedAllConversationState) return;
         this.loadedAllConversationState = true;
@@ -611304,6 +611994,7 @@ ${mediaContext}` : ""
             history: this.chatHistory.get(sessionKey) ?? [],
             participants,
             memoryCards: this.chatMemoryCards.get(sessionKey) ?? [],
+            associativeMemory: this.telegramAssociativeMemoryForSession(sessionKey),
             stimulation: this.stimulation.getState(sessionKey),
             reflection: this.channelReflectionState.get(sessionKey) ?? { autoFollowup: false }
           };
@@ -611331,7 +612022,8 @@ ${mediaContext}` : ""
         };
       }
       buildTelegramChannelDaydreamInput(sessionKey, nowMs = Date.now()) {
-        const history = this.chatHistory.get(sessionKey) ?? [];
+        const sqliteHistory = this.telegramSqliteHistoryForSession(sessionKey, 1500);
+        const history = sqliteHistory.length > 0 ? sqliteHistory : this.chatHistory.get(sessionKey) ?? [];
         if (history.length === 0) return null;
         const last2 = [...history].reverse().find((entry) => entry.chatId !== void 0);
         if (!last2) return null;
@@ -611636,6 +612328,7 @@ ${mediaContext}` : ""
         this.upsertTelegramReflectionHistoryEntry(sessionKey, entry);
         this.updateTelegramParticipantProfile(sessionKey, msg, text);
         this.updateTelegramMemoryCards(sessionKey, entry);
+        this.updateTelegramAssociativeMemory(sessionKey, entry);
         try {
           updateScopedPersonality(this.telegramPersonalityScope(sessionKey, msg), {
             speaker: telegramSpeakerLabel(msg),
@@ -611669,9 +612362,16 @@ ${mediaContext}` : ""
           chatTitle: msg.chatTitle
         };
         this.recordChatHistory(sessionKey, entry);
+        this.persistTelegramAssistantMessage(
+          msg,
+          clean5,
+          options2.messageId ?? void 0,
+          options2.replyToMessageId
+        );
         this.upsertTelegramReflectionHistoryEntry(sessionKey, entry);
         this.stimulation.recordAgentOutput(sessionKey);
         this.updateTelegramMemoryCards(sessionKey, entry);
+        this.updateTelegramAssociativeMemory(sessionKey, entry);
         try {
           updateScopedPersonality(this.telegramPersonalityScope(sessionKey, msg), {
             speaker: entry.speaker || "Assistant",
@@ -611847,14 +612547,14 @@ ${mediaContext}` : ""
         profile.fromUserId = msg.fromUserId || profile.fromUserId;
         profile.messageCount += 1;
         profile.lastSeenTs = Date.now();
-        profile.lastMessage = truncateTelegramContextLine(text, 220);
+        profile.lastMessage = stripTelegramHiddenThinking(text).replace(/\s+/g, " ").trim();
         if (msg.replyToMessageId) profile.replyCount += 1;
         if (this.state.botUsername && text.toLowerCase().includes(`@${this.state.botUsername.toLowerCase()}`)) {
           profile.directAddressCount += 1;
         }
         for (const tag of inferTelegramToneTags(text)) profile.toneTags.add(tag);
         if (text.trim()) {
-          profile.samples.push(truncateTelegramContextLine(text, 160));
+          profile.samples.push(stripTelegramHiddenThinking(text).replace(/\s+/g, " ").trim());
           if (profile.samples.length > TELEGRAM_CONTEXT_SAMPLE_LIMIT) {
             profile.samples.splice(0, profile.samples.length - TELEGRAM_CONTEXT_SAMPLE_LIMIT);
           }
@@ -611862,8 +612562,162 @@ ${mediaContext}` : ""
         participants.set(participantKey, profile);
         this.chatParticipants.set(sessionKey, participants);
       }
+      updateTelegramAssociativeMemory(sessionKey, entry) {
+        const memory = this.telegramAssociativeMemoryForSession(sessionKey);
+        const now = entry.ts ?? Date.now();
+        memory.updatedAt = now;
+        const speaker = telegramHistorySpeaker(entry);
+        const actionId = createHash23("sha1").update(`${sessionKey}:${entry.role}:${entry.messageId ?? ""}:${now}:${entry.text}`).digest("hex").slice(0, 16);
+        if (!memory.actions.some((action) => action.id === actionId)) {
+          memory.actions.push({
+            id: actionId,
+            ts: now,
+            role: entry.role,
+            speaker,
+            mode: entry.mode,
+            text: stripTelegramHiddenThinking(entry.text || "").replace(/\s+/g, " ").trim(),
+            messageId: entry.messageId,
+            replyToMessageId: entry.replyToMessageId,
+            userId: entry.fromUserId,
+            username: entry.username
+          });
+          if (memory.actions.length > TELEGRAM_ASSOCIATIVE_ACTION_LIMIT) {
+            memory.actions.splice(
+              0,
+              memory.actions.length - TELEGRAM_ASSOCIATIVE_ACTION_LIMIT
+            );
+          }
+        }
+        if (entry.role === "user") {
+          const userKey = String(entry.fromUserId || entry.username || entry.firstName || speaker);
+          const existing = memory.users[userKey];
+          const userMemory = existing ?? {
+            userId: entry.fromUserId,
+            username: entry.username || "unknown",
+            displayName: entry.firstName || entry.username || speaker,
+            aliases: [],
+            firstSeenTs: now,
+            lastSeenTs: now,
+            messageCount: 0,
+            directAddressCount: 0,
+            replyCount: 0,
+            toneTags: [],
+            facts: [],
+            relationshipHints: [],
+            recentTopics: [],
+            lastMessages: []
+          };
+          userMemory.userId = entry.fromUserId ?? userMemory.userId;
+          userMemory.username = entry.username || userMemory.username;
+          userMemory.displayName = entry.firstName || userMemory.displayName;
+          for (const alias of [entry.username, entry.firstName, speaker].filter(Boolean)) {
+            const clean5 = alias.replace(/^@/, "").trim();
+            if (clean5 && !userMemory.aliases.includes(clean5)) userMemory.aliases.push(clean5);
+          }
+          userMemory.aliases = userMemory.aliases.slice(0, 20);
+          userMemory.lastSeenTs = now;
+          userMemory.messageCount += 1;
+          if (entry.replyToMessageId) userMemory.replyCount += 1;
+          if (this.state.botUsername && entry.text.toLowerCase().includes(`@${this.state.botUsername.toLowerCase()}`)) {
+            userMemory.directAddressCount += 1;
+          }
+          for (const tag of inferTelegramToneTags(entry.text)) {
+            if (!userMemory.toneTags.includes(tag)) userMemory.toneTags.push(tag);
+          }
+          userMemory.toneTags = userMemory.toneTags.slice(0, 20);
+          const compact2 = stripTelegramHiddenThinking(entry.text || "").replace(/\s+/g, " ").trim();
+          if (compact2) {
+            userMemory.lastMessages.push(compact2);
+            userMemory.lastMessages = userMemory.lastMessages.slice(-40);
+          }
+          for (const topic of telegramMemoryTags(entry.text, entry.mediaSummary).slice(0, 6)) {
+            if (!userMemory.recentTopics.includes(topic)) userMemory.recentTopics.push(topic);
+          }
+          userMemory.recentTopics = userMemory.recentTopics.slice(-80);
+          const facts = this.extractTelegramAssociativeFacts(entry, speaker);
+          for (const text of facts) {
+            const fact = this.upsertTelegramAssociativeFact(memory.facts, text, entry, speaker, 1.5);
+            this.upsertTelegramAssociativeFact(userMemory.facts, fact.text, entry, speaker, fact.weight);
+          }
+          if (entry.replyContext?.sender || entry.replyToMessageId) {
+            const target = entry.replyContext?.sender ? telegramReplySenderLabel(entry.replyContext.sender) : `message ${entry.replyToMessageId}`;
+            const hint = `${speaker} replied to ${target}: ${stripTelegramHiddenThinking(entry.text || "").replace(/\s+/g, " ").trim()}`;
+            if (!userMemory.relationshipHints.includes(hint)) {
+              userMemory.relationshipHints.push(hint);
+              userMemory.relationshipHints = userMemory.relationshipHints.slice(-80);
+            }
+            this.upsertTelegramAssociativeFact(memory.relationships, hint, entry, speaker, 1.2);
+          }
+          userMemory.facts.sort((a2, b) => b.weight - a2.weight || b.updatedAt - a2.updatedAt);
+          userMemory.facts = userMemory.facts.slice(0, TELEGRAM_ASSOCIATIVE_USER_FACT_LIMIT);
+          memory.users[userKey] = userMemory;
+        }
+        memory.facts.sort((a2, b) => b.weight - a2.weight || b.updatedAt - a2.updatedAt);
+        memory.facts = memory.facts.slice(0, TELEGRAM_ASSOCIATIVE_FACT_LIMIT);
+        memory.relationships.sort((a2, b) => b.updatedAt - a2.updatedAt);
+        memory.relationships = memory.relationships.slice(0, TELEGRAM_ASSOCIATIVE_RELATION_LIMIT);
+      }
+      extractTelegramAssociativeFacts(entry, speaker) {
+        if (entry.role !== "user") return [];
+        const text = stripTelegramHiddenThinking(entry.text || "").replace(/\s+/g, " ").trim();
+        const facts = /* @__PURE__ */ new Set();
+        const patterns = [
+          /\b(?:remember|note|keep in mind|for future reference)\s+(?:that\s+)?(.{4,260})/i,
+          /\bmy name is\s+(.{2,120})/i,
+          /\bcall me\s+(.{2,120})/i,
+          /\bi\s+(?:am|work as|live in|like|love|prefer|use|run|have|need|want)\b.{0,220}/i,
+          /\b(?:we|this group|our)\s+.{0,220}\b(?:is|are|uses|prefers|likes|works|has|needs)\b.{0,220}/i
+        ];
+        for (const pattern of patterns) {
+          const match = text.match(pattern);
+          if (!match) continue;
+          const body = (match[1] || match[0]).trim().replace(/[.!?]*$/, "");
+          if (body.length >= 3) facts.add(`${speaker}: ${body}`);
+        }
+        if (entry.mediaSummary) {
+          facts.add(`${speaker} shared media: ${entry.mediaSummary}`);
+        }
+        return [...facts].slice(0, 8);
+      }
+      upsertTelegramAssociativeFact(facts, text, entry, speaker, weight = 1) {
+        const clean5 = stripTelegramHiddenThinking(text || "").replace(/\s+/g, " ").trim();
+        const key = clean5.toLowerCase();
+        const now = entry.ts ?? Date.now();
+        let fact = facts.find((item) => item.text.toLowerCase() === key);
+        if (!fact) {
+          fact = {
+            id: createHash23("sha1").update(`${entry.chatId ?? ""}:${key}`).digest("hex").slice(0, 12),
+            text: clean5,
+            tags: telegramMemoryTags(clean5, entry.mediaSummary),
+            speakers: [],
+            userIds: [],
+            usernames: [],
+            messageIds: [],
+            createdAt: now,
+            updatedAt: now,
+            weight
+          };
+          facts.push(fact);
+        }
+        fact.updatedAt = now;
+        fact.weight = Math.min(10, Math.max(fact.weight, weight) + 0.2);
+        if (!fact.speakers.includes(speaker)) fact.speakers.push(speaker);
+        fact.speakers = fact.speakers.slice(0, 16);
+        if (entry.fromUserId && !fact.userIds.includes(entry.fromUserId)) fact.userIds.push(entry.fromUserId);
+        fact.userIds = fact.userIds.slice(0, 32);
+        const username = (entry.username || "").replace(/^@/, "").toLowerCase();
+        if (username && !fact.usernames.includes(username)) fact.usernames.push(username);
+        fact.usernames = fact.usernames.slice(0, 32);
+        if (entry.messageId && !fact.messageIds.includes(entry.messageId)) fact.messageIds.push(entry.messageId);
+        fact.messageIds = fact.messageIds.slice(-80);
+        for (const tag of telegramMemoryTags(clean5, entry.mediaSummary)) {
+          if (!fact.tags.includes(tag)) fact.tags.push(tag);
+        }
+        fact.tags = fact.tags.slice(0, 16);
+        return fact;
+      }
       updateTelegramMemoryCards(sessionKey, entry) {
-        const text = truncateTelegramContextLine(entry.text, 500);
+        const text = stripTelegramHiddenThinking(entry.text || "").replace(/\s+/g, " ").trim();
         if (!text || text.length < 3) return;
         const speaker = telegramHistorySpeaker(entry);
         const tags = telegramMemoryTags(text, entry.mediaSummary);
@@ -611955,6 +612809,304 @@ ${mediaContext}` : ""
           )
         })).sort((a2, b) => b.score - a2.score || b.card.updatedAt - a2.card.updatedAt).slice(0, limit);
       }
+      relevantTelegramAssociativeMemoryContext(sessionKey, msg, limit = 12) {
+        const memory = this.chatAssociativeMemory.get(sessionKey);
+        if (!memory) return "";
+        const queryTokens = telegramMemoryTokens([
+          telegramSpeakerLabel(msg),
+          msg.username || "",
+          msg.firstName || "",
+          msg.text,
+          summarizeTelegramMessageAttachments(msg)
+        ].join(" "));
+        const currentUsername = (msg.username || "").replace(/^@/, "").toLowerCase();
+        const userEntries = Object.entries(memory.users).filter(
+          ([, user]) => msg.fromUserId !== void 0 && user.userId === msg.fromUserId || !!currentUsername && user.username.replace(/^@/, "").toLowerCase() === currentUsername || user.aliases.some((alias) => alias.replace(/^@/, "").toLowerCase() === currentUsername)
+        );
+        const scoredFacts = memory.facts.map((fact) => ({
+          fact,
+          score: telegramMemorySimilarity(
+            queryTokens,
+            telegramMemoryTokens([fact.text, fact.tags.join(" "), fact.speakers.join(" ")].join(" "))
+          ) + (fact.userIds.includes(msg.fromUserId ?? -1) ? 0.35 : 0) + (currentUsername && fact.usernames.includes(currentUsername) ? 0.35 : 0)
+        })).filter((item) => item.score > 0).sort((a2, b) => b.score - a2.score || b.fact.updatedAt - a2.fact.updatedAt).slice(0, limit);
+        const relationshipFacts = memory.relationships.filter(
+          (fact) => fact.userIds.includes(msg.fromUserId ?? -1) || !!currentUsername && fact.usernames.includes(currentUsername)
+        ).slice(0, 6);
+        const recentActions = memory.actions.filter(
+          (action) => action.userId === msg.fromUserId || !!currentUsername && action.username?.replace(/^@/, "").toLowerCase() === currentUsername || action.role === "assistant"
+        ).slice(-8);
+        const sections = [];
+        if (userEntries.length > 0) {
+          const lines = userEntries.map(([, user]) => {
+            const facts = user.facts.slice(0, 6).map((fact) => `    - ${telegramContextJsonString(fact.text, 220)}`).join("\n");
+            const hints = user.relationshipHints.slice(-4).map((hint) => `    - relation=${telegramContextJsonString(hint, 200)}`).join("\n");
+            const topics = user.recentTopics.slice(-8).join(", ") || "none";
+            return [
+              `- ${user.username && user.username !== "unknown" ? `@${user.username}` : user.displayName || "user"}${user.userId ? ` id:${user.userId}` : ""}: messages:${user.messageCount}, direct:${user.directAddressCount}, replies:${user.replyCount}, topics:${topics}`,
+              facts,
+              hints
+            ].filter(Boolean).join("\n");
+          });
+          sections.push(`### Durable Associative User Memory
+${lines.join("\n")}`);
+        }
+        if (scoredFacts.length > 0) {
+          const lines = scoredFacts.map(
+            ({ fact, score }) => `- (${score.toFixed(2)}) ${telegramContextJsonString(fact.text, 260)}${fact.messageIds.length ? ` [messages:${fact.messageIds.slice(-4).join(",")}]` : ""}`
+          );
+          sections.push(`### Durable Associative Memory Recall
+${lines.join("\n")}`);
+        }
+        if (relationshipFacts.length > 0) {
+          const lines = relationshipFacts.map((fact) => `- ${telegramContextJsonString(fact.text, 240)}`);
+          sections.push(`### Durable Relationship Recall
+${lines.join("\n")}`);
+        }
+        if (recentActions.length > 0) {
+          const lines = recentActions.map(
+            (action) => `- ${telegramHistoryTime({ ts: action.ts, role: action.role, text: action.text })} ${action.speaker}/${action.role}${action.mode ? `/${action.mode}` : ""}: ${telegramContextJsonString(action.text, 220)}`
+          );
+          sections.push(`### Durable Recent Action Ledger Recall
+${lines.join("\n")}`);
+        }
+        return sections.join("\n\n");
+      }
+      relevantTelegramSqliteMirrorContext(sessionKey, msg, limit = 12) {
+        const db = this.telegramDb();
+        if (!db) return "";
+        const rows = /* @__PURE__ */ new Map();
+        const addRows = (items) => {
+          for (const row of items) {
+            const key = Number(row.rowid);
+            if (Number.isFinite(key)) rows.set(key, row);
+          }
+        };
+        try {
+          if (msg.fromUserId !== void 0) {
+            addRows(db.prepare(`
+          SELECT rowid, * FROM telegram_messages
+          WHERE session_key = ? AND from_user_id = ?
+          ORDER BY received_at DESC
+          LIMIT ?
+        `).all(sessionKey, msg.fromUserId, limit));
+          }
+          const username = (msg.username || "").replace(/^@/, "").toLowerCase();
+          if (username) {
+            addRows(db.prepare(`
+          SELECT rowid, * FROM telegram_messages
+          WHERE session_key = ? AND lower(username) = ?
+          ORDER BY received_at DESC
+          LIMIT ?
+        `).all(sessionKey, username, Math.max(4, Math.floor(limit / 2))));
+          }
+          const queryTokens = [...telegramMemoryTokens(msg.text)].slice(0, 6);
+          for (const token of queryTokens) {
+            addRows(db.prepare(`
+          SELECT rowid, * FROM telegram_messages
+          WHERE session_key = ? AND text LIKE ?
+          ORDER BY received_at DESC
+          LIMIT 4
+        `).all(sessionKey, `%${token}%`));
+          }
+        } catch {
+          return "";
+        }
+        const selected = [...rows.values()].sort((a2, b) => Number(b.received_at ?? 0) - Number(a2.received_at ?? 0)).slice(0, limit);
+        if (selected.length === 0) return "";
+        const lines = selected.map((row) => {
+          const when = row.received_at ? new Date(Number(row.received_at)).toISOString() : "";
+          const speaker = row.role === "assistant" ? `@${this.state.botUsername || "omnius"}` : row.username ? `@${row.username}` : row.from_user_id ? `user:${row.from_user_id}` : "unknown";
+          const reply = row.reply_to_message_id ? ` reply_to:${row.reply_to_message_id}` : "";
+          return `- ${when} ${speaker}/${row.role || "user"} msg:${row.message_id}${reply}: ${telegramContextJsonString(String(row.text || ""), 260)}`;
+        });
+        return [
+          "### SQLite Telegram Raw Mirror Recall",
+          "Durable local mirror rows for this scoped chat. Use as historical evidence when the rolling context omitted older turns.",
+          lines.join("\n")
+        ].join("\n");
+      }
+      /**
+       * Always-on episodic memory recall for the active Telegram session.
+       * Pulls scored episodes from .omnius/episodes.db where session_id = sessionKey,
+       * including social / tool_result / reflection modalities. This surfaces day-old
+       * context the rolling 36-turn window has already shed.
+       */
+      relevantTelegramEpisodicMemoryContext(sessionKey, msg, limit = 8) {
+        if (!this.repoRoot) return "";
+        const paths = omniusMemoryDbPaths(this.repoRoot);
+        if (!existsSync112(paths.episodes)) return "";
+        let episodes = [];
+        const graph = new TemporalGraph(paths.knowledge);
+        const store2 = new EpisodeStore(paths.episodes, graph);
+        try {
+          const recent = store2.search({ sessionId: sessionKey, limit: Math.max(limit * 3, 24) }) ?? [];
+          const queryText = (msg.text || "").toLowerCase().trim();
+          if (queryText.length > 3) {
+            const qTokens = queryText.split(/\s+/).filter((t2) => t2.length >= 4);
+            const scored = recent.map((ep) => {
+              const content = String(ep.content || "").toLowerCase();
+              const hits = qTokens.filter((t2) => content.includes(t2)).length;
+              return { ep, score: hits };
+            }).sort((a2, b) => b.score - a2.score || b.ep.timestamp - a2.ep.timestamp);
+            episodes = scored.slice(0, limit).map((s2) => s2.ep);
+          } else {
+            episodes = recent.slice(0, limit);
+          }
+        } catch {
+          return "";
+        } finally {
+          try {
+            store2.close();
+          } catch {
+          }
+          try {
+            graph.close();
+          } catch {
+          }
+        }
+        if (episodes.length === 0) return "";
+        const lines = episodes.map((ep) => {
+          const when = ep.timestamp ? new Date(ep.timestamp).toISOString() : "";
+          const meta = ep.metadata || {};
+          const tg = meta.telegram && typeof meta.telegram === "object" ? meta.telegram : {};
+          const speaker = tg.speaker || tg.username || (ep.modality === "tool_result" ? `tool:${ep.toolName || "?"}` : "agent");
+          const mode = tg.mode ? `/${tg.mode}` : "";
+          const text = ep.gist || ep.content;
+          return `- ${when} ${speaker}${mode} [${ep.modality}]: ${telegramContextJsonString(String(text || ""), 260)}`;
+        });
+        return [
+          "### Episodic Memory Recall (durable, day+ scope)",
+          "Scored episodes for this Telegram session from episodes.db. These are PERSISTENT across restarts and survive the rolling-context window. Treat as canonical for older facts.",
+          lines.join("\n")
+        ].join("\n");
+      }
+      telegramSqliteHistoryForSession(sessionKey, limit = 1e3) {
+        const db = this.telegramDb();
+        if (!db) return [];
+        try {
+          const rows = db.prepare(`
+        SELECT * FROM telegram_messages
+        WHERE session_key = ?
+        ORDER BY received_at DESC
+        LIMIT ?
+      `).all(sessionKey, limit);
+          return rows.reverse().map((row) => ({
+            role: row.role === "assistant" ? "assistant" : "user",
+            text: String(row.text || ""),
+            ts: Number(row.received_at || 0) || void 0,
+            chatId: row.chat_id,
+            speaker: row.role === "assistant" ? `@${this.state.botUsername || "omnius"}` : row.username ? `@${row.username}` : row.from_user_id ? `user:${row.from_user_id}` : "unknown",
+            username: row.username || void 0,
+            firstName: row.first_name || void 0,
+            fromUserId: typeof row.from_user_id === "number" ? row.from_user_id : void 0,
+            messageId: typeof row.message_id === "number" ? row.message_id : void 0,
+            messageThreadId: typeof row.message_thread_id === "number" ? row.message_thread_id : void 0,
+            replyToMessageId: typeof row.reply_to_message_id === "number" ? row.reply_to_message_id : void 0,
+            chatType: row.chat_type,
+            chatTitle: row.chat_title || void 0,
+            mediaSummary: row.media_json ? "media attached in raw Telegram SQLite mirror" : void 0
+          }));
+        } catch {
+          return [];
+        }
+      }
+      searchTelegramSqliteMirrorRows(sessionKey, query, options2 = {}) {
+        const db = this.telegramDb();
+        if (!db) return [];
+        const limit = Math.max(1, Math.min(50, Math.floor(options2.limit ?? 12)));
+        const username = (options2.username || "").replace(/^@/, "").trim().toLowerCase();
+        const tokens = [...telegramMemoryTokens(query)].slice(0, 8);
+        const rows = /* @__PURE__ */ new Map();
+        const addRows = (items) => {
+          for (const row of items) {
+            const key = Number(row.rowid);
+            if (Number.isFinite(key)) rows.set(key, row);
+          }
+        };
+        try {
+          if (options2.userId !== void 0) {
+            addRows(db.prepare(`
+          SELECT rowid, * FROM telegram_messages
+          WHERE session_key = ? AND from_user_id = ?
+          ORDER BY received_at DESC
+          LIMIT ?
+        `).all(sessionKey, options2.userId, limit));
+          }
+          if (username) {
+            addRows(db.prepare(`
+          SELECT rowid, * FROM telegram_messages
+          WHERE session_key = ? AND lower(username) = ?
+          ORDER BY received_at DESC
+          LIMIT ?
+        `).all(sessionKey, username, limit));
+          }
+          if (tokens.length > 0) {
+            const clauses = tokens.map(() => "text LIKE ?").join(" OR ");
+            addRows(db.prepare(`
+          SELECT rowid, * FROM telegram_messages
+          WHERE session_key = ? AND (${clauses})
+          ORDER BY received_at DESC
+          LIMIT ?
+        `).all(sessionKey, ...tokens.map((token) => `%${token}%`), limit));
+          }
+          if (rows.size === 0) {
+            addRows(db.prepare(`
+          SELECT rowid, * FROM telegram_messages
+          WHERE session_key = ?
+          ORDER BY received_at DESC
+          LIMIT ?
+        `).all(sessionKey, Math.min(limit, 12)));
+          }
+        } catch {
+          return [];
+        }
+        return [...rows.values()].sort((a2, b) => Number(b.received_at ?? 0) - Number(a2.received_at ?? 0)).slice(0, limit);
+      }
+      formatTelegramSqliteMirrorRows(rows, maxText = 260) {
+        return rows.map((row) => {
+          const when = row.received_at ? new Date(Number(row.received_at)).toISOString() : "";
+          const speaker = row.role === "assistant" ? `@${this.state.botUsername || "omnius"}` : row.username ? `@${row.username}` : row.from_user_id ? `user:${row.from_user_id}` : "unknown";
+          const reply = row.reply_to_message_id ? ` reply_to:${row.reply_to_message_id}` : "";
+          const media = row.media_json ? " media:attached" : "";
+          return `- ${when} ${speaker}/${row.role || "user"} msg:${row.message_id}${reply}${media}: ${telegramContextJsonString(String(row.text || ""), maxText)}`;
+        }).join("\n");
+      }
+      searchTelegramEpisodeMemory(sessionKey, query, limit = 8) {
+        if (!this.repoRoot || !query.trim()) return [];
+        const paths = omniusMemoryDbPaths(this.repoRoot);
+        if (!existsSync112(paths.episodes)) return [];
+        const graph = new TemporalGraph(paths.knowledge);
+        const store2 = new EpisodeStore(paths.episodes, graph);
+        try {
+          return store2.searchWithPPR(
+            {
+              sessionId: sessionKey,
+              query,
+              limit: Math.max(1, Math.min(20, Math.floor(limit))),
+              metadataFilter: { sourceSurface: "telegram" }
+            },
+            { lexicalWeight: 1.25, embeddingWeight: 0 }
+          );
+        } catch {
+          return [];
+        } finally {
+          store2.close();
+          graph.close();
+        }
+      }
+      formatTelegramEpisodeMemoryResults(episodes, maxText = 320) {
+        return episodes.map((episode) => {
+          const meta = episode.metadata;
+          const telegram = meta?.telegram && typeof meta.telegram === "object" ? meta.telegram : {};
+          const when = episode.timestamp ? new Date(episode.timestamp).toISOString() : "";
+          const speaker = telegram.speaker || telegram.username || "unknown";
+          const messageId = telegram.messageId ? ` msg:${telegram.messageId}` : "";
+          const mode = telegram.mode ? `/${telegram.mode}` : "";
+          const text = episode.content.split("\n").filter((line) => !/^(Telegram|session:|chat:|message_id:|thread_id:|speaker:|mode:)/i.test(line.trim())).join(" ").replace(/\s+/g, " ").trim() || episode.content;
+          return `- ${when} ${speaker}${mode}${messageId}: ${telegramContextJsonString(text, maxText)}`;
+        }).join("\n");
+      }
       buildTelegramConversationContextStream(sessionKey, msg, maxRecent = TELEGRAM_CONTEXT_RECENT_DEFAULT) {
         this.ensureTelegramConversationLoaded(sessionKey);
         const history = this.chatHistory.get(sessionKey) ?? [];
@@ -611992,6 +613144,33 @@ ${mediaContext}` : ""
           });
           sections.push(`### Participants And Relationship Signals
 ${participantLines.join("\n")}`);
+        }
+        const associativeContext = this.relevantTelegramAssociativeMemoryContext(
+          sessionKey,
+          msg,
+          isGroup ? 14 : 8
+        );
+        if (associativeContext) {
+          sections.push(associativeContext);
+        }
+        const sqliteMirrorContext = this.relevantTelegramSqliteMirrorContext(
+          sessionKey,
+          msg,
+          isGroup ? 14 : 8
+        );
+        if (sqliteMirrorContext) {
+          sections.push(sqliteMirrorContext);
+        }
+        try {
+          const episodicContext = this.relevantTelegramEpisodicMemoryContext(
+            sessionKey,
+            msg,
+            isGroup ? 10 : 6
+          );
+          if (episodicContext) {
+            sections.push(episodicContext);
+          }
+        } catch {
         }
         const memoryCards = this.relevantTelegramMemoryCards(sessionKey, msg, isGroup ? 10 : 6);
         if (memoryCards.length > 0) {
@@ -612176,7 +613355,8 @@ ${lines.join("\n")}`);
           ``,
           `Reply discretion: infer from the live thread, speaker relationships, direct platform signals, replies, tone, current message, and any private channel daydream artifact supplied in context. Do not use static keyword rules.`,
           `Private chats: should_reply is normally true.`,
-          `Group/public chats: default should_reply to false unless the current message clearly addresses the bot, replies to the bot, continues an active bot-involved exchange, assigns the bot work, or asks for the bot's view. Ambient chatter, third-person discussion about the bot, commands meant for a human, or questions among other people are false. Do not set true just because the bot could help.`,
+          `Group/public chats: default should_reply to false unless the current message clearly addresses the bot, replies to the bot, continues an active bot-involved exchange, assigns the bot work, asks for the bot's view, or is semantically connected to durable memory/current discussion in a way where a concise bot reply is socially useful. Ambient chatter, third-person discussion about the bot, commands meant for a human, or questions among other people are false. Do not set true just because the bot could help.`,
+          `Memory discipline: use durable associative user memory, relationships, prior actions, and recent context to infer whether this speaker is continuing a bot-related thread. A mention is not required when the semantic target is clearly the bot or an ongoing bot-mediated discussion.`,
           `Channel daydream discipline: a daydream artifact may highlight relationship signals, unresolved questions, or possible reply opportunities from idle reflection. It can justify analyzing this turn, but it does not force a reply. Reply only if the current user entry makes the intervention timely and socially appropriate.`,
           `Stimulation discipline: also set attention_state, attention_delta, and optional next_check_after_messages/next_check_after_ms. These control future analysis cadence only; they do not force a reply. Use engaged for active back-and-forth, observing for likely relevant context, cooldown for recently irrelevant context, and idle for ambient chatter.`,
           forcedLine,
@@ -612558,6 +613738,40 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`);
         if (!me?.ok) {
           throw new Error(`Invalid Telegram bot token: ${me?.description || "unknown error"}`);
         }
+        if (this.repoRoot && me.result?.id) {
+          try {
+            const lockDir = resolve43(this.repoRoot, ".omnius", "telegram-runner-state");
+            mkdirSync65(lockDir, { recursive: true });
+            const lockFile = join127(lockDir, `bot-${me.result.id}.owner.lock`);
+            if (existsSync112(lockFile)) {
+              try {
+                const prior = JSON.parse(readFileSync92(lockFile, "utf8"));
+                const priorAlive = typeof prior.pid === "number" && prior.pid !== process.pid ? this.processIsAlive(prior.pid) : false;
+                if (priorAlive) {
+                  throw new Error(
+                    `Telegram bot @${prior.botUsername || me.result.username || "unknown"} is already being polled by pid ${prior.pid} (cwd ${prior.cwd || "?"}). Stop that instance or use a different bot token in this project.`
+                  );
+                }
+              } catch (e2) {
+                if (e2 instanceof Error && e2.message.startsWith("Telegram bot @")) throw e2;
+              }
+            }
+            writeFileSync59(
+              lockFile,
+              JSON.stringify({
+                pid: process.pid,
+                cwd: this.repoRoot,
+                botUsername: me.result.username,
+                botUserId: me.result.id,
+                ts: Date.now()
+              }, null, 2),
+              { encoding: "utf-8", mode: 384 }
+            );
+            this.telegramOwnerLockFile = lockFile;
+          } catch (e2) {
+            if (e2 instanceof Error && e2.message.startsWith("Telegram bot @")) throw e2;
+          }
+        }
         this.state = {
           active: true,
           botUsername: me.result?.username ?? "unknown",
@@ -612601,10 +613815,40 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`);
           agent.aborted = true;
           if (agent.typingInterval) clearInterval(agent.typingInterval);
         }
+        if (this.telegramSqliteDb && this.telegramSqliteDb !== false) {
+          try {
+            this.telegramSqliteDb.close();
+          } catch {
+          }
+          this.telegramSqliteDb = null;
+        }
+        if (this.telegramOwnerLockFile) {
+          try {
+            if (existsSync112(this.telegramOwnerLockFile)) {
+              unlinkSync22(this.telegramOwnerLockFile);
+            }
+          } catch {
+          }
+          this.telegramOwnerLockFile = null;
+        }
         this.subAgents.clear();
         this.activeChatViews.clear();
         this.refreshActiveTelegramInteractionCount();
       }
+      /**
+       * Cheap liveness probe: kill(pid, 0) throws ESRCH when the process is dead
+       * and EPERM when it exists but we can't signal it (still alive from our POV).
+       */
+      processIsAlive(pid) {
+        if (!pid || !Number.isFinite(pid)) return false;
+        try {
+          process.kill(pid, 0);
+          return true;
+        } catch (e2) {
+          if (e2 && e2.code === "EPERM") return true;
+          return false;
+        }
+      }
       // ── Typing indicator ──────────────────────────────────────────────────
       /** Start sending "typing" indicator every 4 seconds */
       startTypingIndicator(chatId) {
@@ -613529,7 +614773,7 @@ ${currentTelegramPrompt}`;
           const toolHint = [
             "You have access to isolated per-chat memory (memory_write, memory_read, memory_search) scoped to this conversation.",
             "memory_search may use scope=group/current_chat for this group or scope=user with user_id/username for a participant in this same group. Other groups, admin chats, and private DMs are not accessible here.",
-            "You can remember facts about users and retrieve them later. You also have web_search and web_fetch to look up information.",
+            "You can remember facts about users and retrieve them later. Durable associative memory in the prompt includes participant profiles, relationships, scoped facts, and prior actions retained across days, sessions, and Omnius updates. You also have web_search and web_fetch to look up information.",
             "You have the full scoped Telegram media-analysis stack by default: telegram_media_recent, image_read, ocr, ocr_image_advanced, vision, pdf_to_text, ocr_pdf, transcribe_file, video_understand, audio_analyze, and identity_memory. For complex textual imagery, screenshots, forms, scans, or dense labels, prefer ocr_image_advanced after resolving media with path='reply' or path='latest'.",
             formatIdentityMemoryContext(chatLabel || "Telegram private chat"),
             reminderToolContract,
@@ -613695,7 +614939,7 @@ ${result.llmContent ?? result.output}` };
           if (tool.name === "memory_search") {
             return {
               ...tool,
-              description: "Search only this Telegram chat's isolated Zettelkasten memory cards. Supports scope=group/current_chat or scope=user with user_id/username, but never crosses into admin/private/global memory.",
+              description: "Search only this Telegram chat's isolated durable memory: raw SQLite message mirror, episode/knowledge graph recall, associative user facts, and memory cards. Supports scope=group/current_chat or scope=user with user_id/username, but never crosses into admin/private/global memory.",
               parameters: (() => {
                 const base3 = tool.parameters ?? {};
                 const props = base3["properties"] && typeof base3["properties"] === "object" && !Array.isArray(base3["properties"]) ? base3["properties"] : {};
@@ -613713,6 +614957,8 @@ ${result.llmContent ?? result.output}` };
               execute: async (args) => {
                 const query = String(args["query"] || "").trim();
                 const maxResults = typeof args["max_results"] === "number" && Number.isFinite(args["max_results"]) ? Math.max(1, Math.min(20, Math.floor(args["max_results"]))) : 8;
+                if (!query) return { success: true, output: "Search query is required." };
+                this.ensureTelegramConversationLoaded(msgSessionKey);
                 const currentGroupId = chatId === void 0 ? "" : String(chatId);
                 const requestedGroupId = String(args["group_id"] ?? args["chat_id"] ?? "").trim();
                 if (requestedGroupId && currentGroupId && requestedGroupId !== currentGroupId) {
@@ -613740,32 +614986,70 @@ ${result.llmContent ?? result.output}` };
                   if (effectiveUsername && haystack.includes(`@${effectiveUsername}`)) return true;
                   return false;
                 });
-                if (!query || cards.length === 0) {
-                  const scopeLabel2 = wantsUserScope ? `user ${effectiveUsername ? `@${effectiveUsername}` : `id ${effectiveUserId}`}` : `chat ${currentGroupId || msgSessionKey}`;
-                  return { success: true, output: cards.length === 0 ? `No scoped memories found for ${scopeLabel2}.` : "Search query is required." };
-                }
                 const queryTokens = telegramMemoryTokens(query);
-                const results = cards.map((card) => ({
+                const cardResults = cards.map((card) => ({
                   card,
                   score: telegramMemorySimilarity(
                     queryTokens,
                     telegramMemoryTokens([card.title, card.tags.join(" "), card.speakers.join(" "), card.notes.join(" ")].join(" "))
                   )
                 })).filter((item) => item.score > 0).sort((a2, b) => b.score - a2.score || b.card.updatedAt - a2.card.updatedAt).slice(0, maxResults);
-                if (results.length === 0) {
-                  return { success: true, output: `No scoped memories matched "${query}" in this Telegram chat.` };
-                }
-                const lines = results.map(({ card, score }) => {
+                const cardLines = cardResults.map(({ card, score }) => {
                   const notes2 = card.notes.slice(-4).map((note) => `  - ${truncateTelegramContextLine(note, 220)}`).join("\n");
                   const tags = card.tags.length ? ` tags:${card.tags.slice(0, 8).join(",")}` : "";
                   const users = Array.isArray(card.userIds) && card.userIds.length ? ` users:${card.userIds.slice(0, 6).join(",")}` : "";
                   return `[${card.id}] ${card.title} (relevance ${score.toFixed(2)}${users}${tags})
 ${notes2}`;
                 });
+                const memory = this.chatAssociativeMemory.get(msgSessionKey);
+                const associativeFacts = memory ? [...memory.facts, ...memory.relationships].filter((fact) => {
+                  if (!wantsUserScope) return true;
+                  if (effectiveUserId !== void 0 && fact.userIds.includes(effectiveUserId)) return true;
+                  return !!effectiveUsername && fact.usernames.includes(effectiveUsername);
+                }).map((fact) => ({
+                  fact,
+                  score: telegramMemorySimilarity(
+                    queryTokens,
+                    telegramMemoryTokens([fact.text, fact.tags.join(" "), fact.speakers.join(" ")].join(" "))
+                  ) + (effectiveUserId !== void 0 && fact.userIds.includes(effectiveUserId) ? 0.3 : 0) + (effectiveUsername && fact.usernames.includes(effectiveUsername) ? 0.3 : 0)
+                })).filter((item) => item.score > 0).sort((a2, b) => b.score - a2.score || b.fact.updatedAt - a2.fact.updatedAt).slice(0, maxResults) : [];
+                const rawRows = this.searchTelegramSqliteMirrorRows(msgSessionKey, query, {
+                  limit: maxResults,
+                  userId: effectiveUserId,
+                  username: effectiveUsername
+                });
+                const episodeResults = this.searchTelegramEpisodeMemory(msgSessionKey, query, maxResults);
                 const scopeLabel = wantsUserScope ? `user ${effectiveUsername ? `@${effectiveUsername}` : `id ${effectiveUserId}`}` : `chat ${currentGroupId || msgSessionKey}`;
-                return { success: true, output: `Scoped Telegram memory search for "${query}" in ${scopeLabel}:
-
-${lines.join("\n\n")}` };
+                const sections = [];
+                if (cardLines.length > 0) {
+                  sections.push(`### Scoped Memory Cards
+${cardLines.join("\n\n")}`);
+                }
+                if (associativeFacts.length > 0) {
+                  const lines = associativeFacts.map(
+                    ({ fact, score }) => `- (${score.toFixed(2)}) ${telegramContextJsonString(fact.text, 300)}${fact.messageIds.length ? ` [messages:${fact.messageIds.slice(-6).join(",")}]` : ""}`
+                  );
+                  sections.push(`### Durable Associative Facts
+${lines.join("\n")}`);
+                }
+                if (episodeResults.length > 0) {
+                  sections.push(`### Episode/Knowledge Graph Recall
+${this.formatTelegramEpisodeMemoryResults(episodeResults)}`);
+                }
+                if (rawRows.length > 0) {
+                  sections.push(`### Raw SQLite Message Mirror
+${this.formatTelegramSqliteMirrorRows(rawRows)}`);
+                }
+                if (sections.length === 0) {
+                  return { success: true, output: `No scoped Telegram memories matched "${query}" in ${scopeLabel}.` };
+                }
+                const output = [
+                  `Scoped Telegram memory search for "${query}" in ${scopeLabel}.`,
+                  "Results are scoped to this Telegram chat and may include raw message evidence, graph episodes, associative facts, and memory cards.",
+                  "",
+                  sections.join("\n\n")
+                ].join("\n");
+                return { success: true, output, llmContent: output };
               }
             };
           }
@@ -616320,6 +617604,7 @@ ${caption}\r
                 }
                 const msg = normalizeTelegramUpdate(update2);
                 if (!msg) continue;
+                this.persistTelegramRawMessage(update2, msg);
                 const isAdmin = this.adminUserId ? String(msg.fromUserId) === this.adminUserId || msg.username === this.adminUserId : false;
                 if (this.adminUserId && !this.agentConfig) {
                   if (!isAdmin) continue;
@@ -616665,8 +617950,8 @@ function appendCheckin(sessionId, steering) {
     mkdirSync66(sessionsDir(), { recursive: true });
     const fp = checkinPath(sessionId);
     const entry = JSON.stringify({ ts: Date.now(), steering }) + "\n";
-    const { appendFileSync: appendFileSync9 } = __require("node:fs");
-    appendFileSync9(fp, entry, "utf-8");
+    const { appendFileSync: appendFileSync12 } = __require("node:fs");
+    appendFileSync12(fp, entry, "utf-8");
   } catch {
   }
 }
@@ -618865,7 +620150,7 @@ __export(audit_log_exports, {
   recordAudit: () => recordAudit,
   sanitizeBody: () => sanitizeBody
 });
-import { mkdirSync as mkdirSync69, appendFileSync as appendFileSync7, readFileSync as readFileSync96, existsSync as existsSync116 } from "node:fs";
+import { mkdirSync as mkdirSync69, appendFileSync as appendFileSync10, readFileSync as readFileSync96, existsSync as existsSync116 } from "node:fs";
 import { join as join131 } from "node:path";
 function initAuditLog(omniusDir) {
   auditDir = join131(omniusDir, "audit");
@@ -618880,7 +620165,7 @@ function recordAudit(record) {
   if (!initialized) return;
   try {
     const line = JSON.stringify(record) + "\n";
-    appendFileSync7(auditFile, line, "utf-8");
+    appendFileSync10(auditFile, line, "utf-8");
   } catch {
   }
 }
@@ -641179,7 +642464,7 @@ import { fileURLToPath as fileURLToPath18 } from "node:url";
 import {
   readFileSync as readFileSync105,
   writeFileSync as writeFileSync70,
-  appendFileSync as appendFileSync8,
+  appendFileSync as appendFileSync11,
   rmSync as rmSync7,
   readdirSync as readdirSync46,
   mkdirSync as mkdirSync78
@@ -645673,7 +646958,7 @@ This is an independent background session started from /background.`
     if (!line.trim()) return;
     try {
       mkdirSync78(HISTORY_DIR, { recursive: true });
-      appendFileSync8(HISTORY_FILE, line + "\n", "utf8");
+      appendFileSync11(HISTORY_FILE, line + "\n", "utf8");
       if (Math.random() < 0.02) {
         const all2 = readFileSync105(HISTORY_FILE, "utf8").trim().split("\n");
         if (all2.length > MAX_HISTORY_LINES) {
@@ -647127,7 +648412,9 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
         ...settings.admin !== void 0 ? { telegramAdmin: settings.admin } : {},
         ...settings.mode !== void 0 ? { telegramMode: settings.mode } : {}
       };
-      if (settings.local) {
+      const projectHasOmnius = existsSync127(join143(repoRoot, ".omnius"));
+      const useProject = settings.local === true || settings.local === void 0 && projectHasOmnius;
+      if (useProject) {
         saveProjectSettings(repoRoot, payload);
       } else {
         saveGlobalSettings(payload);
@@ -651460,12 +652747,12 @@ function crashLog(label, err) {
   const logLine = `[${timestamp}] ${label}: ${msg}
 `;
   try {
-    const { appendFileSync: appendFileSync9, mkdirSync: mkdirSync81 } = __require("node:fs");
+    const { appendFileSync: appendFileSync12, mkdirSync: mkdirSync81 } = __require("node:fs");
     const { join: join148 } = __require("node:path");
     const { homedir: homedir52 } = __require("node:os");
     const logDir = join148(homedir52(), ".omnius");
     mkdirSync81(logDir, { recursive: true });
-    appendFileSync9(join148(logDir, "crash.log"), logLine);
+    appendFileSync12(join148(logDir, "crash.log"), logLine);
   } catch {
   }
   try {