omnius 1.0.71 → 1.0.73

package/dist/index.js

@@ -87766,7 +87766,7 @@ var require_axios = __commonJS({
     }
     var isString = typeOfTest("string");
     var isFunction$1 = typeOfTest("function");
-    var isNumber = typeOfTest("number");
+    var isNumber2 = typeOfTest("number");
     var isObject = (thing) => thing !== null && typeof thing === "object";
     var isBoolean = (thing) => thing === true || thing === false;
     var isPlainObject = (val) => {
@@ -87966,7 +87966,7 @@ var require_axios = __commonJS({
       if (!thing) return null;
       if (isArray(thing)) return thing;
       let i2 = thing.length;
-      if (!isNumber(i2)) return null;
+      if (!isNumber2(i2)) return null;
       const arr = new Array(i2);
       while (i2-- > 0) {
         arr[i2] = thing[i2];
@@ -88107,7 +88107,7 @@ var require_axios = __commonJS({
       isFormData,
       isArrayBufferView,
       isString,
-      isNumber,
+      isNumber: isNumber2,
       isBoolean,
       isObject,
       isPlainObject,
@@ -92298,7 +92298,7 @@ var require_auto = __commonJS({
 // ../node_modules/acme-client/src/client.js
 var require_client = __commonJS({
   "../node_modules/acme-client/src/client.js"(exports, module) {
-    var { createHash: createHash28 } = __require("crypto");
+    var { createHash: createHash29 } = __require("crypto");
     var { getPemBodyAsB64u } = require_crypto();
     var { log: log22 } = require_logger();
     var HttpClient = require_http();
@@ -92609,14 +92609,14 @@ var require_client = __commonJS({
        */
       async getChallengeKeyAuthorization(challenge) {
         const jwk = this.http.getJwk();
-        const keysum = createHash28("sha256").update(JSON.stringify(jwk));
+        const keysum = createHash29("sha256").update(JSON.stringify(jwk));
         const thumbprint = keysum.digest("base64url");
         const result = `${challenge.token}.${thumbprint}`;
         if (challenge.type === "http-01") {
           return result;
         }
         if (challenge.type === "dns-01") {
-          return createHash28("sha256").update(result).digest("base64url");
+          return createHash29("sha256").update(result).digest("base64url");
         }
         if (challenge.type === "tls-alpn-01") {
           return result;
@@ -235296,7 +235296,7 @@ var require_websocket2 = __commonJS({
     var http6 = __require("http");
     var net5 = __require("net");
     var tls2 = __require("tls");
-    var { randomBytes: randomBytes27, createHash: createHash28 } = __require("crypto");
+    var { randomBytes: randomBytes27, createHash: createHash29 } = __require("crypto");
     var { Duplex: Duplex3, Readable } = __require("stream");
     var { URL: URL3 } = __require("url");
     var PerMessageDeflate3 = require_permessage_deflate2();
@@ -235956,7 +235956,7 @@ var require_websocket2 = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest3 = createHash28("sha1").update(key + GUID).digest("base64");
+        const digest3 = createHash29("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest3) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -236323,7 +236323,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter14 = __require("events");
     var http6 = __require("http");
     var { Duplex: Duplex3 } = __require("stream");
-    var { createHash: createHash28 } = __require("crypto");
+    var { createHash: createHash29 } = __require("crypto");
     var extension3 = require_extension2();
     var PerMessageDeflate3 = require_permessage_deflate2();
     var subprotocol3 = require_subprotocol();
@@ -236624,7 +236624,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest3 = createHash28("sha1").update(key + GUID).digest("base64");
+        const digest3 = createHash29("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -243390,15 +243390,15 @@ var require_is_number = __commonJS({
 var require_to_regex_range = __commonJS({
   "../node_modules/to-regex-range/index.js"(exports, module) {
     "use strict";
-    var isNumber = require_is_number();
+    var isNumber2 = require_is_number();
     var toRegexRange = (min, max, options2) => {
-      if (isNumber(min) === false) {
+      if (isNumber2(min) === false) {
         throw new TypeError("toRegexRange: expected the first argument to be a number");
       }
       if (max === void 0 || min === max) {
         return String(min);
       }
-      if (isNumber(max) === false) {
+      if (isNumber2(max) === false) {
         throw new TypeError("toRegexRange: expected the second argument to be a number.");
       }
       let opts = { relaxZeros: true, ...options2 };
@@ -243610,7 +243610,7 @@ var require_fill_range = __commonJS({
     var isValidValue = (value2) => {
       return typeof value2 === "number" || typeof value2 === "string" && value2 !== "";
     };
-    var isNumber = (num) => Number.isInteger(+num);
+    var isNumber2 = (num) => Number.isInteger(+num);
     var zeros = (input) => {
       let value2 = `${input}`;
       let index = -1;
@@ -243738,7 +243738,7 @@ var require_fill_range = __commonJS({
       return range;
     };
     var fillLetters = (start2, end, step = 1, options2 = {}) => {
-      if (!isNumber(start2) && start2.length > 1 || !isNumber(end) && end.length > 1) {
+      if (!isNumber2(start2) && start2.length > 1 || !isNumber2(end) && end.length > 1) {
         return invalidRange(start2, end, options2);
       }
       let format3 = options2.transform || ((val) => String.fromCharCode(val));
@@ -243778,11 +243778,11 @@ var require_fill_range = __commonJS({
       let opts = { ...options2 };
       if (opts.capture === true) opts.wrap = true;
       step = step || opts.step || 1;
-      if (!isNumber(step)) {
+      if (!isNumber2(step)) {
         if (step != null && !isObject(step)) return invalidStep(step, opts);
         return fill(start2, end, 1, step);
       }
-      if (isNumber(start2) && isNumber(end)) {
+      if (isNumber2(start2) && isNumber2(end)) {
         return fillNumbers(start2, end, step, opts);
       }
       return fillLetters(start2, end, Math.max(Math.abs(step), 1), opts);
@@ -249431,13 +249431,13 @@ Justification: ${justification || "(none provided)"}`,
         }
         const snapshot = JSON.stringify(this.selfState, null, 2);
         try {
-          const { createHash: createHash28 } = await import("node:crypto");
+          const { createHash: createHash29 } = await import("node:crypto");
           const snapshotDir = join30(this.cwd, ".omnius", "identity", "snapshots");
           await mkdir7(snapshotDir, { recursive: true });
           const version4 = this.selfState.version;
           const snapshotPath = join30(snapshotDir, `v${version4}.json`);
           await writeFile12(snapshotPath, snapshot, "utf8");
-          const hash = createHash28("sha256").update(snapshot).digest("hex");
+          const hash = createHash29("sha256").update(snapshot).digest("hex");
           await writeFile12(join30(this.cwd, ".omnius", "identity", "latest-hash.txt"), hash, "utf8");
           let ipfsCid = "";
           try {
@@ -249570,8 +249570,8 @@ New: ${newNarrative.slice(0, 200)}...`,
       }
       // ── Helpers ──────────────────────────────────────────────────────────────
       createDefaultState() {
-        const { createHash: createHash28 } = __require("node:crypto");
-        const machineId = createHash28("sha256").update(this.cwd).digest("hex").slice(0, 12);
+        const { createHash: createHash29 } = __require("node:crypto");
+        const machineId = createHash29("sha256").update(this.cwd).digest("hex").slice(0, 12);
         return {
           self_id: `omnius-${machineId}`,
           version: 1,
@@ -249653,9 +249653,9 @@ New: ${newNarrative.slice(0, 200)}...`,
         let cid;
         if (this.selfState.version > prevVersion) {
           try {
-            const { createHash: createHash28 } = await import("node:crypto");
+            const { createHash: createHash29 } = await import("node:crypto");
             const stateJson = JSON.stringify(this.selfState);
-            const hash = createHash28("sha256").update(stateJson).digest("hex").slice(0, 32);
+            const hash = createHash29("sha256").update(stateJson).digest("hex").slice(0, 32);
             const cidsPath = join30(this.cwd, ".omnius", "identity", "cids.json");
             const cidsData = { latest: "", hash, version: this.selfState.version };
             try {
@@ -270064,7 +270064,7 @@ var require_typescript = __commonJS({
         commandLineOptionOfCustomType: () => commandLineOptionOfCustomType,
         commentPragmas: () => commentPragmas,
         commonOptionsWithBuild: () => commonOptionsWithBuild,
-        compact: () => compact2,
+        compact: () => compact3,
         compareBooleans: () => compareBooleans,
         compareComparableValues: () => compareComparableValues,
         compareDataObjects: () => compareDataObjects,
@@ -271372,7 +271372,7 @@ var require_typescript = __commonJS({
         isNonStaticMethodOrAccessorWithPrivateName: () => isNonStaticMethodOrAccessorWithPrivateName,
         isNotEmittedStatement: () => isNotEmittedStatement,
         isNullishCoalesce: () => isNullishCoalesce,
-        isNumber: () => isNumber,
+        isNumber: () => isNumber2,
         isNumericLiteral: () => isNumericLiteral,
         isNumericLiteralName: () => isNumericLiteralName,
         isObjectBindingElementWithoutPropertyName: () => isObjectBindingElementWithoutPropertyName,
@@ -272579,7 +272579,7 @@ var require_typescript = __commonJS({
         }
         return true;
       }
-      function compact2(array) {
+      function compact3(array) {
         let result;
         if (array !== void 0) {
           for (let i2 = 0; i2 < array.length; i2++) {
@@ -273114,7 +273114,7 @@ var require_typescript = __commonJS({
       function isString(text) {
         return typeof text === "string";
       }
-      function isNumber(x) {
+      function isNumber2(x) {
         return typeof x === "number";
       }
       function tryCast(value2, test) {
@@ -378650,7 +378650,7 @@ ${lanes.join("\n")}
               node.operatorToken,
               visitNode(node.right, visitor, isExpression)
             );
-            const expr = some(pendingExpressions) ? factory2.inlineExpressions(compact2([...pendingExpressions, node])) : node;
+            const expr = some(pendingExpressions) ? factory2.inlineExpressions(compact3([...pendingExpressions, node])) : node;
             pendingExpressions = savedPendingExpressions;
             return expr;
           }
@@ -398919,7 +398919,7 @@ ${lanes.join("\n")}
               let parameterProperties;
               if (ctor) {
                 const oldDiag2 = getSymbolAccessibilityDiagnostic;
-                parameterProperties = compact2(flatMap(ctor.parameters, (param) => {
+                parameterProperties = compact3(flatMap(ctor.parameters, (param) => {
                   if (!hasSyntacticModifier(
                     param,
                     31
@@ -410266,8 +410266,8 @@ ${lanes.join("\n")}
         return result;
       }
       function getPendingEmitKind(optionsOrEmitKind, oldOptionsOrEmitKind) {
-        const oldEmitKind = oldOptionsOrEmitKind && (isNumber(oldOptionsOrEmitKind) ? oldOptionsOrEmitKind : getBuilderFileEmit(oldOptionsOrEmitKind));
-        const emitKind = isNumber(optionsOrEmitKind) ? optionsOrEmitKind : getBuilderFileEmit(optionsOrEmitKind);
+        const oldEmitKind = oldOptionsOrEmitKind && (isNumber2(oldOptionsOrEmitKind) ? oldOptionsOrEmitKind : getBuilderFileEmit(oldOptionsOrEmitKind));
+        const emitKind = isNumber2(optionsOrEmitKind) ? optionsOrEmitKind : getBuilderFileEmit(optionsOrEmitKind);
         if (oldEmitKind === emitKind) return 0;
         if (!oldEmitKind || !emitKind) return emitKind;
         const diff = oldEmitKind ^ emitKind;
@@ -410998,7 +410998,7 @@ ${lanes.join("\n")}
           if (isLastStartEnd && last22[1] === fileId - 1) return last22[1] = fileId;
           if (isLastStartEnd || root.length === 1 || last22 !== fileId - 1) return root.push(fileId);
           const lastButOne = root[root.length - 2];
-          if (!isNumber(lastButOne) || lastButOne !== last22 - 1) return root.push(fileId);
+          if (!isNumber2(lastButOne) || lastButOne !== last22 - 1) return root.push(fileId);
           root[root.length - 2] = [lastButOne, fileId];
           return root.length = root.length - 1;
         }
@@ -411598,7 +411598,7 @@ ${lanes.join("\n")}
         return isString(fileInfo) ? { version: fileInfo, signature: fileInfo, affectsGlobalScope: void 0, impliedFormat: void 0 } : isString(fileInfo.signature) ? fileInfo : { version: fileInfo.version, signature: fileInfo.signature === false ? void 0 : fileInfo.version, affectsGlobalScope: fileInfo.affectsGlobalScope, impliedFormat: fileInfo.impliedFormat };
       }
       function toBuilderFileEmit(value2, fullEmitForOptions) {
-        return isNumber(value2) ? fullEmitForOptions : value2[1] || 24;
+        return isNumber2(value2) ? fullEmitForOptions : value2[1] || 24;
       }
       function toProgramEmitPending(value2, options2) {
         return !value2 ? getBuilderFileEmit(options2 || {}) : value2;
@@ -411641,7 +411641,7 @@ ${lanes.join("\n")}
             if (emitSignatures && stateFileInfo.signature) emitSignatures.set(path12, stateFileInfo.signature);
           });
           (_d = buildInfo.emitSignatures) == null ? void 0 : _d.forEach((value2) => {
-            if (isNumber(value2)) emitSignatures.delete(toFilePath(value2));
+            if (isNumber2(value2)) emitSignatures.delete(toFilePath(value2));
             else {
               const key = toFilePath(value2[0]);
               emitSignatures.set(
@@ -411662,7 +411662,7 @@ ${lanes.join("\n")}
             emitDiagnosticsPerFile: toPerFileEmitDiagnostics(buildInfo.emitDiagnosticsPerFile),
             hasReusableDiagnostic: true,
             changedFilesSet,
-            affectedFilesPendingEmit: buildInfo.affectedFilesPendingEmit && arrayToMap(buildInfo.affectedFilesPendingEmit, (value2) => toFilePath(isNumber(value2) ? value2 : value2[0]), (value2) => toBuilderFileEmit(value2, fullEmitForOptions)),
+            affectedFilesPendingEmit: buildInfo.affectedFilesPendingEmit && arrayToMap(buildInfo.affectedFilesPendingEmit, (value2) => toFilePath(isNumber2(value2) ? value2 : value2[0]), (value2) => toBuilderFileEmit(value2, fullEmitForOptions)),
             latestChangedDtsFile,
             emitSignatures: (emitSignatures == null ? void 0 : emitSignatures.size) ? emitSignatures : void 0,
             hasErrors: buildInfo.errors,
@@ -411718,7 +411718,7 @@ ${lanes.join("\n")}
             )
           );
           diagnostics == null ? void 0 : diagnostics.forEach((value2) => {
-            if (isNumber(value2)) semanticDiagnostics.delete(toFilePath(value2));
+            if (isNumber2(value2)) semanticDiagnostics.delete(toFilePath(value2));
             else semanticDiagnostics.set(toFilePath(value2[0]), value2[1]);
           });
           return semanticDiagnostics;
@@ -435962,7 +435962,7 @@ ${newComment.split("\n").map((c9) => ` * ${c9}`).join("\n")}
         return decl;
       }
       function getIsMatchingAsyncError(span, errorCode) {
-        return ({ start: start2, length: length22, relatedInformation, code: code8 }) => isNumber(start2) && isNumber(length22) && textSpansEqual({ start: start2, length: length22 }, span) && code8 === errorCode && !!relatedInformation && some(relatedInformation, (related) => related.code === Diagnostics.Did_you_mean_to_mark_this_function_as_async.code);
+        return ({ start: start2, length: length22, relatedInformation, code: code8 }) => isNumber2(start2) && isNumber2(length22) && textSpansEqual({ start: start2, length: length22 }, span) && code8 === errorCode && !!relatedInformation && some(relatedInformation, (related) => related.code === Diagnostics.Did_you_mean_to_mark_this_function_as_async.code);
       }
       var fixId3 = "addMissingAwait";
       var propertyAccessCode = Diagnostics.Property_0_does_not_exist_on_type_1.code;
@@ -436000,7 +436000,7 @@ ${newComment.split("\n").map((c9) => ` * ${c9}`).join("\n")}
           }
           const checker = context2.program.getTypeChecker();
           const trackChanges = (cb) => ts_textChanges_exports.ChangeTracker.with(context2, cb);
-          return compact2([
+          return compact3([
             getDeclarationSiteFix(context2, expression, errorCode, checker, trackChanges),
             getUseSiteFix(context2, expression, errorCode, checker, trackChanges)
           ]);
@@ -436047,7 +436047,7 @@ ${newComment.split("\n").map((c9) => ` * ${c9}`).join("\n")}
       function isMissingAwaitError(sourceFile, errorCode, span, cancellationToken, program) {
         const checker = program.getTypeChecker();
         const diagnostics = checker.getDiagnostics(sourceFile, cancellationToken);
-        return some(diagnostics, ({ start: start2, length: length22, relatedInformation, code: code8 }) => isNumber(start2) && isNumber(length22) && textSpansEqual({ start: start2, length: length22 }, span) && code8 === errorCode && !!relatedInformation && some(relatedInformation, (related) => related.code === Diagnostics.Did_you_forget_to_use_await.code));
+        return some(diagnostics, ({ start: start2, length: length22, relatedInformation, code: code8 }) => isNumber2(start2) && isNumber2(length22) && textSpansEqual({ start: start2, length: length22 }, span) && code8 === errorCode && !!relatedInformation && some(relatedInformation, (related) => related.code === Diagnostics.Did_you_forget_to_use_await.code));
       }
       function findAwaitableInitializers(expression, sourceFile, cancellationToken, program, checker) {
         const identifiers = getIdentifiersFromErrorSpanExpression(expression, checker);
@@ -459591,7 +459591,7 @@ ${content}
         const lastToken = last2(children2);
         const separateLastToken = separateTrailingSemicolon && lastToken.kind === 27;
         const rightChildren = children2.slice(splitTokenIndex + 1, separateLastToken ? children2.length - 1 : void 0);
-        const result = compact2([
+        const result = compact3([
           leftChildren.length ? createSyntaxList2(leftChildren) : void 0,
           splitToken,
           rightChildren.length ? createSyntaxList2(rightChildren) : void 0
@@ -466315,7 +466315,7 @@ ${options2.prefix}` : "\n" : options2.prefix
         commandLineOptionOfCustomType: () => commandLineOptionOfCustomType,
         commentPragmas: () => commentPragmas,
         commonOptionsWithBuild: () => commonOptionsWithBuild,
-        compact: () => compact2,
+        compact: () => compact3,
         compareBooleans: () => compareBooleans,
         compareComparableValues: () => compareComparableValues,
         compareDataObjects: () => compareDataObjects,
@@ -467623,7 +467623,7 @@ ${options2.prefix}` : "\n" : options2.prefix
         isNonStaticMethodOrAccessorWithPrivateName: () => isNonStaticMethodOrAccessorWithPrivateName,
         isNotEmittedStatement: () => isNotEmittedStatement,
         isNullishCoalesce: () => isNullishCoalesce,
-        isNumber: () => isNumber,
+        isNumber: () => isNumber2,
         isNumericLiteral: () => isNumericLiteral,
         isNumericLiteralName: () => isNumericLiteralName,
         isObjectBindingElementWithoutPropertyName: () => isObjectBindingElementWithoutPropertyName,
@@ -544024,8 +544024,8 @@ If you're stuck, try a completely different approach. Do NOT repeat what failed
               if (process.env["OMNIUS_DISABLE_ADAPTIVE_RETRIEVAL"] !== "1") {
                 const goalForSig = (this._taskState.goal || "").slice(0, 200);
                 const recentTools = this._toolSequence.slice(-5).join("|");
-                const { createHash: createHash28 } = await import("node:crypto");
-                const sig = createHash28("sha256").update(`${goalForSig}::${recentTools}`).digest("hex").slice(0, 16);
+                const { createHash: createHash29 } = await import("node:crypto");
+                const sig = createHash29("sha256").update(`${goalForSig}::${recentTools}`).digest("hex").slice(0, 16);
                 if (this._lastPprSig === sig && this._lastPprMemoryLines.length > 0) {
                   compacted.push({
                     role: "system",
@@ -559204,7 +559204,7 @@ var require_websocket3 = __commonJS({
     var http6 = __require("http");
     var net5 = __require("net");
     var tls2 = __require("tls");
-    var { randomBytes: randomBytes27, createHash: createHash28 } = __require("crypto");
+    var { randomBytes: randomBytes27, createHash: createHash29 } = __require("crypto");
     var { Duplex: Duplex3, Readable } = __require("stream");
     var { URL: URL3 } = __require("url");
     var PerMessageDeflate3 = require_permessage_deflate3();
@@ -559864,7 +559864,7 @@ var require_websocket3 = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest3 = createHash28("sha1").update(key + GUID).digest("base64");
+        const digest3 = createHash29("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest3) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -560231,7 +560231,7 @@ var require_websocket_server2 = __commonJS({
     var EventEmitter14 = __require("events");
     var http6 = __require("http");
     var { Duplex: Duplex3 } = __require("stream");
-    var { createHash: createHash28 } = __require("crypto");
+    var { createHash: createHash29 } = __require("crypto");
     var extension3 = require_extension3();
     var PerMessageDeflate3 = require_permessage_deflate3();
     var subprotocol3 = require_subprotocol2();
@@ -560532,7 +560532,7 @@ var require_websocket_server2 = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest3 = createHash28("sha1").update(key + GUID).digest("base64");
+        const digest3 = createHash29("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -563932,9 +563932,9 @@ function keywords(text) {
   return out;
 }
 function compactLine(text, limit = 220) {
-  const compact2 = text.replace(/\s+/g, " ").trim();
-  if (compact2.length <= limit) return compact2;
-  return `${compact2.slice(0, Math.max(0, limit - 3)).trimEnd()}...`;
+  const compact3 = text.replace(/\s+/g, " ").trim();
+  if (compact3.length <= limit) return compact3;
+  return `${compact3.slice(0, Math.max(0, limit - 3)).trimEnd()}...`;
 }
 function newDocument(scope) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -567606,9 +567606,9 @@ function formatCaps(caps) {
   if (caps.thinking) tags.push("think");
   return tags.join("+");
 }
-function formatRelativeTime(iso) {
+function formatRelativeTime(iso2) {
   const now = Date.now();
-  const then = new Date(iso).getTime();
+  const then = new Date(iso2).getTime();
   const diffMs = now - then;
   const minutes = Math.floor(diffMs / 6e4);
   if (minutes < 1) return "just now";
@@ -573449,10 +573449,10 @@ ${CONTENT_BG_SEQ}`);
         if (this._telegramStatus.active) {
           const suffix = this._telegramStatus.activeSubAgents > 0 ? ` ${this._telegramStatus.activeSubAgents}` : "";
           const label = `✈ tg${suffix}`;
-          const compact2 = `✈${suffix}`;
+          const compact3 = `✈${suffix}`;
           sections.push({
             expanded: `\x1B[38;5;45m${label}\x1B[0m`,
-            compact: `\x1B[38;5;45m${compact2}\x1B[0m`,
+            compact: `\x1B[38;5;45m${compact3}\x1B[0m`,
             expandedW: 2 + 3 + suffix.length,
             compactW: 2 + suffix.length,
             empty: false
@@ -608152,26 +608152,38 @@ function buildOpenQuestions(input) {
 }
 function buildReplyOpportunities(input, openQuestions) {
   const opportunities = [];
+  const lifecycleUpdatedAt = new Date(input.generatedAtMs).toISOString();
   for (const question of openQuestions.slice(-3)) {
+    const trigger = question;
     opportunities.push({
-      trigger: question,
+      id: daydreamOpportunityId(input, trigger),
+      trigger,
       rationale: "The group left a question or uncertainty that may benefit from a concise clarification.",
       suggestedTone: "brief, contextual, ask one concrete follow-up if needed",
-      confidence: 0.62
+      confidence: 0.62,
+      lifecycle: "proposed",
+      lifecycleUpdatedAt
     });
   }
   const recent = recentUserMessages(input);
   const last2 = recent[recent.length - 1];
   if (last2 && /\b(omnius|bot|agent)\b/i.test(last2.text) && opportunities.length < 4) {
+    const trigger = `${last2.speaker || last2.username || "user"} mentioned the agent: ${compactLine2(last2.text, 160)}`;
     opportunities.push({
-      trigger: `${last2.speaker || last2.username || "user"} mentioned the agent: ${compactLine2(last2.text, 160)}`,
+      id: daydreamOpportunityId(input, trigger),
+      trigger,
       rationale: "A later live-router pass should consider whether this is a direct social opening or just third-person chatter.",
       suggestedTone: "low-intrusion, do not assume the turn belongs to the agent",
-      confidence: 0.48
+      confidence: 0.48,
+      lifecycle: "proposed",
+      lifecycleUpdatedAt
     });
   }
   return opportunities;
 }
+function daydreamOpportunityId(input, trigger) {
+  return createHash21("sha1").update(`${input.sessionKey}:${input.generatedAtMs}:${trigger}`).digest("hex").slice(0, 16);
+}
 function clamp018(value2) {
   if (!Number.isFinite(value2)) return 0;
   return Math.max(0, Math.min(1, value2));
@@ -608607,6 +608619,8 @@ Selected seed: ${artifact.selectedSeed.nodeText} (${artifact.selectedSeed.nodeTy
     "",
     "## Reply Opportunities",
     artifact.replyOpportunities.length ? artifact.replyOpportunities.map((item) => `- ${item.trigger}
+  - id: ${item.id}
+  - lifecycle: ${item.lifecycle}${item.lifecycleUpdatedAt ? ` at ${item.lifecycleUpdatedAt}` : ""}
   - rationale: ${item.rationale}
   - tone: ${item.suggestedTone}
   - confidence: ${item.confidence.toFixed(2)}`).join("\n") : "- None",
@@ -608690,7 +608704,7 @@ ${artifact.contextEngineeringNotes.slice(0, 5).map((line) => `- ${line}`).join("
     artifact.openQuestions.length ? `Open questions:
 ${artifact.openQuestions.slice(0, 4).map((line) => `- ${line}`).join("\n")}` : "",
     artifact.replyOpportunities.length ? `Possible reply opportunities:
-${artifact.replyOpportunities.slice(0, 3).map((item) => `- ${item.trigger} (confidence ${item.confidence.toFixed(2)}; ${item.suggestedTone})`).join("\n")}` : ""
+${artifact.replyOpportunities.slice(0, 3).map((item) => `- ${item.id} [${item.lifecycle}] ${item.trigger} (confidence ${item.confidence.toFixed(2)}; ${item.suggestedTone})`).join("\n")}` : ""
   ].filter(Boolean);
   return lines.join("\n");
 }
@@ -609415,6 +609429,600 @@ var init_telegram_reflection_extraction = __esm({
   }
 });
 
+// packages/cli/src/tui/telegram-social-state-types.ts
+import { createHash as createHash23 } from "node:crypto";
+function telegramSocialActorKey(actor) {
+  if (!actor) return "unknown";
+  if (typeof actor.userId === "number") return `user:${actor.userId}`;
+  const username = cleanUsername(actor.username);
+  if (username) return `username:${username.toLowerCase()}`;
+  const first2 = compact2(actor.firstName, 80).toLowerCase();
+  return first2 ? `name:${first2}` : "unknown";
+}
+function telegramSocialActorKind(actor) {
+  if (actor.isSelf || actor.isBot) return "bot";
+  if (actor.userId || actor.username || actor.firstName) return "human";
+  return "unknown";
+}
+function telegramSocialThreadKey(input) {
+  return input.messageThreadId !== void 0 ? `chat:${String(input.chatId)}:thread:${input.messageThreadId}` : `chat:${String(input.chatId)}`;
+}
+function appendUnique(items, value2, max) {
+  if (value2 === void 0 || value2 === null) return items.slice(-max);
+  const next = items.filter((item) => item !== value2);
+  next.push(value2);
+  return next.slice(-max);
+}
+function hashTelegramSocialId(parts) {
+  return createHash23("sha1").update(parts.map((part) => String(part ?? "")).join(":")).digest("hex").slice(0, 16);
+}
+function cleanUsername(value2) {
+  if (typeof value2 !== "string") return void 0;
+  const clean5 = value2.trim().replace(/^@/, "");
+  return clean5 ? clean5.slice(0, 80) : void 0;
+}
+function compactOptional(value2, max) {
+  const clean5 = compact2(value2, max);
+  return clean5 || void 0;
+}
+function compact2(value2, max) {
+  if (value2 === void 0 || value2 === null) return "";
+  const clean5 = String(value2).replace(/\s+/g, " ").trim();
+  return clean5.length > max ? `${clean5.slice(0, Math.max(0, max - 3)).trimEnd()}...` : clean5;
+}
+function jsonLine(value2, max) {
+  return JSON.stringify(compact2(value2, max));
+}
+function numberOr(value2, fallback) {
+  return typeof value2 === "number" && Number.isFinite(value2) ? value2 : fallback;
+}
+function isNumber(value2) {
+  return typeof value2 === "number" && Number.isFinite(value2);
+}
+function clamp019(value2) {
+  return Math.max(0, Math.min(1, Number.isFinite(value2) ? value2 : 0));
+}
+function iso(ts) {
+  try {
+    return new Date(ts).toISOString();
+  } catch {
+    return "";
+  }
+}
+var TELEGRAM_SOCIAL_LIMITS;
+var init_telegram_social_state_types = __esm({
+  "packages/cli/src/tui/telegram-social-state-types.ts"() {
+    "use strict";
+    TELEGRAM_SOCIAL_LIMITS = {
+      relationships: 240,
+      salience: 180,
+      outcomes: 160,
+      daydreamOpportunities: 120,
+      daydreamStaleMs: 6 * 60 * 6e4
+    };
+  }
+});
+
+// packages/cli/src/tui/telegram-social-state-context.ts
+function formatTelegramSocialStateContext(state, input) {
+  const limit = Math.max(3, Math.min(12, Math.floor(input.limit ?? 8)));
+  const senderKey3 = telegramSocialActorKey(input);
+  const selfKey = input.self ? telegramSocialActorKey(input.self) : void 0;
+  const replyKey = input.replySender ? telegramSocialActorKey(input.replySender) : void 0;
+  const thread = state.threads[telegramSocialThreadKey(input)];
+  const participant = state.participants[senderKey3];
+  const relevantKeys = new Set([senderKey3, selfKey, replyKey].filter(Boolean));
+  const edges = state.relationships.filter((edge) => relevantKeys.has(edge.fromKey) || relevantKeys.has(edge.toKey)).sort((a2, b) => b.lastSeenAt - a2.lastSeenAt).slice(0, limit);
+  const outcomes = state.outcomes.filter((outcome) => outcome.senderKey === senderKey3 || outcome.chatId === String(input.chatId)).sort((a2, b) => b.ts - a2.ts).slice(0, limit);
+  const salience = state.salience.filter((item) => item.senderKey === senderKey3 || item.chatId === String(input.chatId)).sort((a2, b) => b.ts - a2.ts).slice(0, limit);
+  const daydreams = Object.values(state.daydreamOpportunities).filter((item) => item.lifecycle !== "retired").sort((a2, b) => b.updatedAt - a2.updatedAt).slice(0, Math.min(5, limit));
+  const preferences = preferenceLines(state.preferences[senderKey3]);
+  return [
+    "### Telegram Structured Social State",
+    `Current actor node: ${senderKey3} [${participant?.actorKind || telegramSocialActorKind(input)}] messages=${participant?.messageCount ?? 0}${participant?.lastText ? ` last=${jsonLine(participant.lastText, 140)}` : ""}`,
+    thread ? `Active channel/thread: ${thread.key}; messages=${thread.messageCount}; participants=${thread.participantKeys.slice(-8).join(", ") || "none"}; last_outcomes=${thread.lastOutcomeIds.slice(-5).join(", ") || "none"}` : "",
+    preferences.length ? `Relevant preference vector for ${senderKey3}:
+${preferences.join("\n")}` : `Relevant preference vector for ${senderKey3}: no durable preferences yet`,
+    salience.length ? `Recent salience observations:
+${salience.map((item) => `- ${iso(item.ts)} ${item.senderKey}: ${item.signals.join(", ") || "none"}; text=${jsonLine(item.textPreview, 120)}`).join("\n")}` : "",
+    edges.length ? `Relevant relationship edges:
+${edges.map(formatEdge).join("\n")}` : "Relevant relationship edges: none yet",
+    outcomes.length ? `Prior response outcomes:
+${outcomes.map(formatOutcome).join("\n")}` : "Prior response outcomes: none yet",
+    daydreams.length ? `Active daydream opportunity lifecycle:
+${daydreams.map((item) => `- ${item.id} [${item.lifecycle}] confidence=${item.confidence.toFixed(2)} trigger=${jsonLine(item.trigger, 140)}`).join("\n")}` : ""
+  ].filter(Boolean).join("\n");
+}
+function preferenceLines(vector) {
+  if (!vector) return [];
+  return Object.entries(vector).map(([key, evidence]) => {
+    const item = evidence;
+    return `- ${key}: value=${item.value.toFixed(2)} confidence=${item.confidence.toFixed(2)} evidence=${item.evidenceMessageIds.join(",") || "none"}${item.note ? ` note=${jsonLine(item.note, 120)}` : ""}`;
+  });
+}
+function formatEdge(edge) {
+  const evidence = edge.evidenceMessageIds.length ? ` evidence=${edge.evidenceMessageIds.join(",")}` : "";
+  const note = edge.note ? ` note=${jsonLine(edge.note, 140)}` : "";
+  return `- ${edge.fromKey} --${edge.kind}--> ${edge.toKey} confidence=${edge.confidence.toFixed(2)} weight=${edge.weight.toFixed(2)}${evidence}${note}`;
+}
+function formatOutcome(outcome) {
+  const action = outcome.shouldReply ? `replied via ${outcome.route}` : "silent";
+  const note = outcome.mentalNote || outcome.memoryNote || outcome.relationshipNote || outcome.silentDisposition || outcome.reason;
+  return `- ${iso(outcome.ts)} message=${outcome.messageId ?? "?"} ${action} confidence=${outcome.confidence.toFixed(2)} reason=${jsonLine(note, 160)}`;
+}
+var init_telegram_social_state_context = __esm({
+  "packages/cli/src/tui/telegram-social-state-context.ts"() {
+    "use strict";
+    init_telegram_social_state_types();
+  }
+});
+
+// packages/cli/src/tui/telegram-social-state-normalize.ts
+function createTelegramSocialState(now = Date.now()) {
+  return {
+    version: 1,
+    createdAt: now,
+    updatedAt: now,
+    participants: {},
+    relationships: [],
+    preferences: {},
+    threads: {},
+    salience: [],
+    outcomes: [],
+    daydreamOpportunities: {}
+  };
+}
+function normalizeTelegramSocialState(raw) {
+  const now = Date.now();
+  if (!raw || typeof raw !== "object") return createTelegramSocialState(now);
+  const value2 = raw;
+  const state = createTelegramSocialState(now);
+  state.createdAt = numberOr(value2.createdAt, state.createdAt);
+  state.updatedAt = numberOr(value2.updatedAt, state.updatedAt);
+  state.participants = normalizeRecord(value2.participants, normalizeParticipant);
+  state.relationships = Array.isArray(value2.relationships) ? value2.relationships.map(normalizeRelationship).filter(Boolean).slice(-TELEGRAM_SOCIAL_LIMITS.relationships) : [];
+  state.preferences = normalizePreferences(value2.preferences);
+  state.threads = normalizeRecord(value2.threads, normalizeThread);
+  state.salience = Array.isArray(value2.salience) ? value2.salience.map(normalizeSalience).filter(Boolean).slice(-TELEGRAM_SOCIAL_LIMITS.salience) : [];
+  state.outcomes = Array.isArray(value2.outcomes) ? value2.outcomes.map(normalizeOutcome).filter(Boolean).slice(-TELEGRAM_SOCIAL_LIMITS.outcomes) : [];
+  state.daydreamOpportunities = normalizeRecord(value2.daydreamOpportunities, normalizeDaydreamOpportunity);
+  return state;
+}
+function normalizeRecord(raw, fn) {
+  const output = {};
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return output;
+  for (const [key, value2] of Object.entries(raw)) {
+    const normalized = fn(value2);
+    if (normalized) output[key] = normalized;
+  }
+  return output;
+}
+function normalizeParticipant(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const value2 = raw;
+  const key = String(value2.key || "").trim();
+  if (!key) return null;
+  return {
+    key,
+    userId: typeof value2.userId === "number" ? value2.userId : void 0,
+    username: cleanUsername(value2.username),
+    displayName: compactOptional(value2.displayName, 120),
+    actorKind: value2.actorKind === "bot" || value2.actorKind === "human" ? value2.actorKind : "unknown",
+    aliases: Array.isArray(value2.aliases) ? value2.aliases.map(String).slice(0, 20) : [],
+    firstSeenAt: numberOr(value2.firstSeenAt, Date.now()),
+    lastSeenAt: numberOr(value2.lastSeenAt, Date.now()),
+    messageCount: numberOr(value2.messageCount, 0),
+    lastMessageIds: Array.isArray(value2.lastMessageIds) ? value2.lastMessageIds.filter(isNumber).slice(-30) : [],
+    lastText: compactOptional(value2.lastText, 500)
+  };
+}
+function normalizeRelationship(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const value2 = raw;
+  if (!value2.kind || !value2.fromKey || !value2.toKey) return null;
+  return {
+    id: String(value2.id || hashTelegramSocialId(["edge", value2.kind, value2.fromKey, value2.toKey])),
+    kind: value2.kind,
+    fromKey: String(value2.fromKey),
+    toKey: String(value2.toKey),
+    confidence: clamp019(numberOr(value2.confidence, 0)),
+    weight: clamp019(numberOr(value2.weight, 0)),
+    firstSeenAt: numberOr(value2.firstSeenAt, Date.now()),
+    lastSeenAt: numberOr(value2.lastSeenAt, Date.now()),
+    evidenceMessageIds: Array.isArray(value2.evidenceMessageIds) ? value2.evidenceMessageIds.filter(isNumber).slice(-40) : [],
+    note: compactOptional(value2.note, 260),
+    source: value2.source === "router" || value2.source === "daydream" ? value2.source : "message"
+  };
+}
+function normalizePreferences(raw) {
+  const out = {};
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return out;
+  for (const [actorKey, vector] of Object.entries(raw)) {
+    if (!vector || typeof vector !== "object") continue;
+    out[actorKey] = {};
+    for (const key of ["verbosity", "depth", "silence", "directness", "botToBotTolerance"]) {
+      const evidence = vector[key];
+      if (!evidence || typeof evidence !== "object") continue;
+      out[actorKey][key] = {
+        value: Math.max(-1, Math.min(1, numberOr(evidence.value, 0))),
+        confidence: clamp019(numberOr(evidence.confidence, 0)),
+        updatedAt: numberOr(evidence.updatedAt, Date.now()),
+        evidenceMessageIds: Array.isArray(evidence.evidenceMessageIds) ? evidence.evidenceMessageIds.filter(isNumber).slice(-12) : [],
+        note: compactOptional(evidence.note, 220)
+      };
+    }
+  }
+  return out;
+}
+function normalizeThread(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const value2 = raw;
+  const key = String(value2.key || "").trim();
+  if (!key) return null;
+  return {
+    key,
+    chatId: String(value2.chatId || ""),
+    chatType: compactOptional(value2.chatType, 40),
+    chatTitle: compactOptional(value2.chatTitle, 120),
+    messageThreadId: typeof value2.messageThreadId === "number" ? value2.messageThreadId : void 0,
+    firstSeenAt: numberOr(value2.firstSeenAt, Date.now()),
+    lastSeenAt: numberOr(value2.lastSeenAt, Date.now()),
+    messageCount: numberOr(value2.messageCount, 0),
+    participantKeys: Array.isArray(value2.participantKeys) ? value2.participantKeys.map(String).slice(-40) : [],
+    lastMessageIds: Array.isArray(value2.lastMessageIds) ? value2.lastMessageIds.filter(isNumber).slice(-40) : [],
+    lastOutcomeIds: Array.isArray(value2.lastOutcomeIds) ? value2.lastOutcomeIds.map(String).slice(-30) : []
+  };
+}
+function normalizeSalience(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const value2 = raw;
+  if (!value2.senderKey) return null;
+  return {
+    id: String(value2.id || hashTelegramSocialId(["salience", value2.senderKey, value2.messageId ?? Date.now()])),
+    ts: numberOr(value2.ts, Date.now()),
+    chatId: String(value2.chatId || ""),
+    messageId: typeof value2.messageId === "number" ? value2.messageId : void 0,
+    messageThreadId: typeof value2.messageThreadId === "number" ? value2.messageThreadId : void 0,
+    senderKey: String(value2.senderKey),
+    actorKind: value2.actorKind === "bot" || value2.actorKind === "human" ? value2.actorKind : "unknown",
+    signals: Array.isArray(value2.signals) ? value2.signals.map(String).slice(0, 16) : [],
+    textPreview: compact2(value2.textPreview || "", 240)
+  };
+}
+function normalizeOutcome(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const value2 = raw;
+  if (!value2.senderKey) return null;
+  return {
+    id: String(value2.id || hashTelegramSocialId(["outcome", value2.senderKey, value2.messageId ?? Date.now()])),
+    ts: numberOr(value2.ts, Date.now()),
+    chatId: String(value2.chatId || ""),
+    messageId: typeof value2.messageId === "number" ? value2.messageId : void 0,
+    messageThreadId: typeof value2.messageThreadId === "number" ? value2.messageThreadId : void 0,
+    senderKey: String(value2.senderKey),
+    replyToMessageId: typeof value2.replyToMessageId === "number" ? value2.replyToMessageId : void 0,
+    route: value2.route === "action" ? "action" : "chat",
+    shouldReply: value2.shouldReply === true,
+    confidence: clamp019(numberOr(value2.confidence, 0)),
+    reason: compact2(value2.reason || "", 280),
+    source: compact2(value2.source || "unknown", 80),
+    silentDisposition: compactOptional(value2.silentDisposition, 280),
+    mentalNote: compactOptional(value2.mentalNote, 360),
+    memoryNote: compactOptional(value2.memoryNote, 360),
+    relationshipNote: compactOptional(value2.relationshipNote, 360),
+    salienceSignals: Array.isArray(value2.salienceSignals) ? value2.salienceSignals.map(String).slice(0, 16) : [],
+    daydreamOpportunityIds: Array.isArray(value2.daydreamOpportunityIds) ? value2.daydreamOpportunityIds.map(String).slice(0, 16) : []
+  };
+}
+function normalizeDaydreamOpportunity(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const value2 = raw;
+  const id = String(value2.id || "").trim();
+  if (!id) return null;
+  const lifecycle = ["proposed", "considered", "acted", "suppressed", "retired"].includes(String(value2.lifecycle)) ? value2.lifecycle : "proposed";
+  return {
+    id,
+    artifactId: String(value2.artifactId || "unknown"),
+    generatedAt: String(value2.generatedAt || (/* @__PURE__ */ new Date()).toISOString()),
+    trigger: compact2(value2.trigger || "", 240),
+    confidence: clamp019(numberOr(value2.confidence, 0)),
+    lifecycle,
+    firstSeenAt: numberOr(value2.firstSeenAt, Date.now()),
+    updatedAt: numberOr(value2.updatedAt, Date.now()),
+    consideredMessageIds: Array.isArray(value2.consideredMessageIds) ? value2.consideredMessageIds.filter(isNumber).slice(-20) : [],
+    actedMessageIds: Array.isArray(value2.actedMessageIds) ? value2.actedMessageIds.filter(isNumber).slice(-20) : [],
+    suppressedMessageIds: Array.isArray(value2.suppressedMessageIds) ? value2.suppressedMessageIds.filter(isNumber).slice(-20) : [],
+    retiredAt: typeof value2.retiredAt === "number" ? value2.retiredAt : void 0
+  };
+}
+var init_telegram_social_state_normalize = __esm({
+  "packages/cli/src/tui/telegram-social-state-normalize.ts"() {
+    "use strict";
+    init_telegram_social_state_types();
+  }
+});
+
+// packages/cli/src/tui/telegram-social-state.ts
+function observeTelegramSocialMessage(state, input) {
+  const now = input.ts ?? Date.now();
+  state.updatedAt = now;
+  const senderKey3 = upsertParticipant(state, input, now, true);
+  const thread = upsertThread(state, input, senderKey3, now, true);
+  const text = compact2(input.text || "", 500);
+  const participant = state.participants[senderKey3];
+  if (participant) {
+    participant.lastText = text || participant.lastText;
+    participant.lastMessageIds = appendUnique(participant.lastMessageIds, input.messageId, 30);
+  }
+  addSalience(state, input, senderKey3, now, text);
+  if (input.replySender || input.replyToMessageId !== void 0) {
+    const targetKey = input.replySender ? upsertParticipant(state, input.replySender, now, false) : `message:${input.replyToMessageId}`;
+    upsertRelationship(state, "replied_to", senderKey3, targetKey, input.messageId, 0.86, "message", replyNote(input), now);
+  }
+  const selfKey = input.self ? upsertParticipant(state, { ...input.self, isBot: true }, now, false) : void 0;
+  addMessageDerivedEdges(state, input, senderKey3, selfKey, text, now);
+  updatePreferencesFromText(state, senderKey3, text, input.messageId, now, telegramSocialActorKind(input));
+  thread.lastMessageIds = appendUnique(thread.lastMessageIds, input.messageId, 30);
+  trimSocialState(state, now);
+}
+function commitTelegramSocialDecision(state, input) {
+  const now = input.ts ?? Date.now();
+  state.updatedAt = now;
+  const senderKey3 = upsertParticipant(state, input.sender, now, false);
+  const selfKey = input.self ? upsertParticipant(state, { ...input.self, isBot: true }, now, false) : void 0;
+  const opportunities = registerDaydreamOpportunities(state, input.daydreamOpportunities ?? [], now);
+  const opportunityIds = markDecisionOpportunities(opportunities, input.shouldReply, input.messageId, now);
+  const outcome = {
+    id: hashTelegramSocialId(["outcome", input.sessionKey, input.chatId, input.messageId ?? now, now, input.reason]),
+    ts: now,
+    chatId: String(input.chatId),
+    messageId: input.messageId,
+    messageThreadId: input.messageThreadId,
+    senderKey: senderKey3,
+    replyToMessageId: input.replyToMessageId,
+    route: input.route,
+    shouldReply: input.shouldReply,
+    confidence: clamp019(input.confidence),
+    reason: compact2(input.reason, 280),
+    source: compact2(input.source, 80),
+    silentDisposition: compactOptional(input.silentDisposition, 280),
+    mentalNote: compactOptional(input.mentalNote, 360),
+    memoryNote: compactOptional(input.memoryNote, 360),
+    relationshipNote: compactOptional(input.relationshipNote, 360),
+    salienceSignals: [...new Set((input.salienceSignals ?? []).map(String))].slice(0, 16),
+    daydreamOpportunityIds: opportunityIds
+  };
+  state.outcomes.push(outcome);
+  state.outcomes = state.outcomes.slice(-TELEGRAM_SOCIAL_LIMITS.outcomes);
+  const thread = upsertThread(state, input, senderKey3, now, false);
+  thread.lastOutcomeIds = appendUnique(thread.lastOutcomeIds, outcome.id, 30);
+  commitDecisionEdges(state, input, senderKey3, selfKey, now);
+  trimSocialState(state, now);
+  return outcome;
+}
+function registerDaydreamOpportunities(state, opportunities, now = Date.now()) {
+  const registered = [];
+  for (const opportunity of opportunities) {
+    const id = opportunity.id || hashTelegramSocialId(["daydream", opportunity.artifactId || "", opportunity.generatedAt || "", opportunity.trigger]);
+    const existing = state.daydreamOpportunities[id];
+    const item = existing ?? {
+      id,
+      artifactId: opportunity.artifactId || "unknown",
+      generatedAt: opportunity.generatedAt || new Date(now).toISOString(),
+      trigger: compact2(opportunity.trigger, 240),
+      confidence: clamp019(opportunity.confidence),
+      lifecycle: "proposed",
+      firstSeenAt: now,
+      updatedAt: now,
+      consideredMessageIds: [],
+      actedMessageIds: [],
+      suppressedMessageIds: []
+    };
+    if (existing) {
+      item.trigger = compact2(opportunity.trigger, 240) || item.trigger;
+      item.confidence = clamp019(opportunity.confidence);
+      item.updatedAt = now;
+    }
+    state.daydreamOpportunities[id] = item;
+    registered.push(item);
+  }
+  retireStaleDaydreamOpportunities(state, now);
+  return registered;
+}
+function markTelegramDaydreamOpportunitiesConsidered(state, opportunities, messageId, now = Date.now()) {
+  const registered = registerDaydreamOpportunities(state, opportunities, now);
+  for (const opportunity of registered) {
+    if (opportunity.lifecycle === "proposed") opportunity.lifecycle = "considered";
+    opportunity.updatedAt = now;
+    opportunity.consideredMessageIds = appendUnique(opportunity.consideredMessageIds, messageId, 20);
+  }
+  return registered;
+}
+function commitDecisionEdges(state, input, senderKey3, selfKey, now) {
+  if (!selfKey) return;
+  if (input.shouldReply) {
+    upsertRelationship(state, "addressed", selfKey, senderKey3, input.messageId, input.confidence, "router", input.reason, now);
+  } else {
+    upsertRelationship(state, "ignored", selfKey, senderKey3, input.messageId, input.confidence, "router", input.silentDisposition || input.reason, now);
+  }
+  if (input.relationshipNote) {
+    upsertRelationship(state, "addressed", senderKey3, selfKey, input.messageId, Math.max(0.35, input.confidence), "router", input.relationshipNote, now);
+  }
+}
+function markDecisionOpportunities(opportunities, shouldReply, messageId, now) {
+  for (const opportunity of opportunities) {
+    opportunity.lifecycle = shouldReply ? "acted" : "suppressed";
+    opportunity.updatedAt = now;
+    opportunity.consideredMessageIds = appendUnique(opportunity.consideredMessageIds, messageId, 20);
+    if (shouldReply) {
+      opportunity.actedMessageIds = appendUnique(opportunity.actedMessageIds, messageId, 20);
+    } else {
+      opportunity.suppressedMessageIds = appendUnique(opportunity.suppressedMessageIds, messageId, 20);
+    }
+  }
+  return opportunities.map((item) => item.id);
+}
+function addMessageDerivedEdges(state, input, senderKey3, selfKey, text, now) {
+  if (!selfKey) return;
+  const signals = input.salienceSignals ?? [];
+  const direct = signals.some((signal) => !signal.startsWith("private_dm_delivery"));
+  if (direct) upsertRelationship(state, "addressed", senderKey3, selfKey, input.messageId, 0.78, "message", signals.join(", "), now);
+  if (telegramSocialActorKind(input) === "bot" && direct) {
+    upsertRelationship(state, "bot_to_bot_reference", senderKey3, selfKey, input.messageId, 0.7, "message", signals.join(", "), now);
+  }
+  if (/\b(deep dive|go deeper|more detail|be thorough|proper analysis|full breakdown|analyze this)\b/i.test(text)) {
+    upsertRelationship(state, "asked_for_depth", senderKey3, selfKey, input.messageId, 0.68, "message", text, now);
+  }
+  if (/\b(don't reply|do not reply|listen only|stay silent|no response needed|just observe)\b/i.test(text)) {
+    upsertRelationship(state, "asked_for_silence", senderKey3, selfKey, input.messageId, 0.72, "message", text, now);
+  }
+  if (/\b(yes|exactly|correct|good point|that works|agreed)\b/i.test(text)) {
+    upsertRelationship(state, "affirmed", senderKey3, selfKey, input.messageId, 0.52, "message", text, now);
+  }
+  if (/\b(no,|wrong|incorrect|not what|missing|regression|failed|doesn't work|dont do that|don't do that)\b/i.test(text)) {
+    upsertRelationship(state, "corrected", senderKey3, selfKey, input.messageId, 0.56, "message", text, now);
+  }
+}
+function updatePreferencesFromText(state, actorKey, text, messageId, now, actorKind) {
+  const vector = state.preferences[actorKey] ?? {};
+  if (/\b(concise|short|brief|tl;dr|summarize)\b/i.test(text)) setPreference(vector, "verbosity", -0.55, 0.58, messageId, now, "prefers concise replies");
+  if (/\b(verbose|long form|exhaustive|full breakdown|deep dive|proper analysis|thorough)\b/i.test(text)) setPreference(vector, "verbosity", 0.65, 0.62, messageId, now, "accepts longer detailed replies");
+  if (/\b(deep dive|go deeper|analyze|reason through|proper analysis|full breakdown)\b/i.test(text)) setPreference(vector, "depth", 0.72, 0.68, messageId, now, "prefers deeper analysis");
+  if (/\b(don't reply|do not reply|stay silent|listen only|just observe|silent reflection)\b/i.test(text)) setPreference(vector, "silence", 0.76, 0.7, messageId, now, "explicitly values silence/observation");
+  if (/\b(direct|straight answer|no fluff|be clear|plainly)\b/i.test(text)) setPreference(vector, "directness", 0.68, 0.62, messageId, now, "prefers direct language");
+  if (actorKind === "bot") setPreference(vector, "botToBotTolerance", 0.25, 0.4, messageId, now, "peer bot observed; keep bot-to-bot exchanges low-intrusion");
+  state.preferences[actorKey] = vector;
+}
+function upsertParticipant(state, actor, now, countMessage) {
+  const key = telegramSocialActorKey(actor);
+  const username = cleanUsername(actor.username);
+  const displayName = compactOptional(actor.firstName, 120);
+  const node = state.participants[key] ?? {
+    key,
+    userId: actor.userId,
+    username,
+    displayName,
+    actorKind: telegramSocialActorKind(actor),
+    aliases: [],
+    firstSeenAt: now,
+    lastSeenAt: now,
+    messageCount: 0,
+    lastMessageIds: []
+  };
+  node.userId = actor.userId ?? node.userId;
+  node.username = username || node.username;
+  node.displayName = displayName || node.displayName;
+  node.actorKind = actor.isSelf || actor.isBot ? "bot" : node.actorKind === "bot" ? "bot" : telegramSocialActorKind(actor);
+  for (const alias of [username, displayName, actor.userId !== void 0 ? String(actor.userId) : ""].filter(Boolean)) {
+    if (!node.aliases.includes(alias)) node.aliases.push(alias);
+  }
+  node.aliases = node.aliases.slice(0, 20);
+  node.lastSeenAt = now;
+  if (countMessage) node.messageCount += 1;
+  state.participants[key] = node;
+  return key;
+}
+function upsertThread(state, input, senderKey3, now, countMessage) {
+  const key = telegramSocialThreadKey(input);
+  const thread = state.threads[key] ?? {
+    key,
+    chatId: String(input.chatId),
+    chatType: input.chatType,
+    chatTitle: input.chatTitle,
+    messageThreadId: input.messageThreadId,
+    firstSeenAt: now,
+    lastSeenAt: now,
+    messageCount: 0,
+    participantKeys: [],
+    lastMessageIds: [],
+    lastOutcomeIds: []
+  };
+  thread.chatType = input.chatType || thread.chatType;
+  thread.chatTitle = input.chatTitle || thread.chatTitle;
+  thread.lastSeenAt = now;
+  if (countMessage) thread.messageCount += 1;
+  thread.participantKeys = appendUnique(thread.participantKeys, senderKey3, 40);
+  thread.lastMessageIds = appendUnique(thread.lastMessageIds, input.messageId, 40);
+  state.threads[key] = thread;
+  return thread;
+}
+function upsertRelationship(state, kind, fromKey, toKey, messageId, confidence2, source, note, now) {
+  const id = hashTelegramSocialId(["edge", kind, fromKey, toKey]);
+  const edge = state.relationships.find((item) => item.id === id) ?? {
+    id,
+    kind,
+    fromKey,
+    toKey,
+    confidence: 0,
+    weight: 0,
+    firstSeenAt: now,
+    lastSeenAt: now,
+    evidenceMessageIds: [],
+    source
+  };
+  edge.confidence = Math.max(edge.confidence, clamp019(confidence2));
+  edge.weight = Math.min(1, edge.weight + 0.12 + clamp019(confidence2) * 0.2);
+  edge.lastSeenAt = now;
+  edge.evidenceMessageIds = appendUnique(edge.evidenceMessageIds, messageId, 40);
+  edge.note = compactOptional(note, 260) || edge.note;
+  edge.source = source;
+  if (!state.relationships.some((item) => item.id === id)) state.relationships.push(edge);
+}
+function addSalience(state, input, senderKey3, now, text) {
+  const signals = [...new Set((input.salienceSignals ?? []).map(String))].slice(0, 16);
+  state.salience.push({
+    id: hashTelegramSocialId(["salience", input.sessionKey, input.messageId ?? now, signals.join("|")]),
+    ts: now,
+    chatId: String(input.chatId),
+    messageId: input.messageId,
+    messageThreadId: input.messageThreadId,
+    senderKey: senderKey3,
+    actorKind: telegramSocialActorKind(input),
+    signals,
+    textPreview: compact2(text, 240)
+  });
+  state.salience = state.salience.slice(-TELEGRAM_SOCIAL_LIMITS.salience);
+}
+function retireStaleDaydreamOpportunities(state, now) {
+  for (const item of Object.values(state.daydreamOpportunities)) {
+    if (item.lifecycle === "retired" || now - item.updatedAt <= TELEGRAM_SOCIAL_LIMITS.daydreamStaleMs) continue;
+    item.lifecycle = "retired";
+    item.retiredAt = now;
+    item.updatedAt = now;
+  }
+  const entries = Object.values(state.daydreamOpportunities).sort((a2, b) => b.updatedAt - a2.updatedAt);
+  state.daydreamOpportunities = Object.fromEntries(entries.slice(0, TELEGRAM_SOCIAL_LIMITS.daydreamOpportunities).map((item) => [item.id, item]));
+}
+function trimSocialState(state, now) {
+  state.relationships = state.relationships.sort((a2, b) => b.lastSeenAt - a2.lastSeenAt).slice(0, TELEGRAM_SOCIAL_LIMITS.relationships);
+  state.salience = state.salience.slice(-TELEGRAM_SOCIAL_LIMITS.salience);
+  state.outcomes = state.outcomes.slice(-TELEGRAM_SOCIAL_LIMITS.outcomes);
+  retireStaleDaydreamOpportunities(state, now);
+}
+function setPreference(vector, key, value2, confidence2, messageId, now, note) {
+  const existing = vector[key];
+  vector[key] = {
+    value: existing ? existing.value * 0.7 + value2 * 0.3 : value2,
+    confidence: Math.max(existing?.confidence ?? 0, clamp019(confidence2)),
+    updatedAt: now,
+    evidenceMessageIds: appendUnique(existing?.evidenceMessageIds ?? [], messageId, 12),
+    note
+  };
+}
+function replyNote(input) {
+  const target = input.replySender ? input.replySender.username || input.replySender.firstName || String(input.replySender.userId || "unknown") : `message ${input.replyToMessageId}`;
+  return `reply relationship to ${target}`;
+}
+var init_telegram_social_state = __esm({
+  "packages/cli/src/tui/telegram-social-state.ts"() {
+    "use strict";
+    init_telegram_social_state_types();
+    init_telegram_social_state_types();
+    init_telegram_social_state_context();
+    init_telegram_social_state_normalize();
+  }
+});
+
 // packages/cli/src/tui/vision-ingress.ts
 var vision_ingress_exports = {};
 __export(vision_ingress_exports, {
@@ -609573,7 +610181,29 @@ import { mkdirSync as mkdirSync65, existsSync as existsSync113, unlinkSync as un
 import { join as join127, resolve as resolve43, basename as basename27, relative as relative13, isAbsolute as isAbsolute8, extname as extname16 } from "node:path";
 import { homedir as homedir40 } from "node:os";
 import { writeFile as writeFileAsync } from "node:fs/promises";
-import { createHash as createHash23, randomBytes as randomBytes22, randomInt } from "node:crypto";
+import { createHash as createHash24, randomBytes as randomBytes22, randomInt } from "node:crypto";
+function cleanTelegramDecisionNote(value2, maxLength = 260) {
+  if (typeof value2 !== "string") return void 0;
+  const clean5 = stripTelegramHiddenThinking(value2).replace(/\s+/g, " ").trim();
+  if (!clean5) return void 0;
+  return clean5.length > maxLength ? `${clean5.slice(0, Math.max(0, maxLength - 3)).trimEnd()}...` : clean5;
+}
+function telegramDecisionNote(parsed, keys, nestedKeys = ["internal_notes", "internalNotes", "notes"]) {
+  for (const key of keys) {
+    const direct = cleanTelegramDecisionNote(parsed[key]);
+    if (direct) return direct;
+  }
+  for (const nestedKey of nestedKeys) {
+    const nested = parsed[nestedKey];
+    if (!nested || typeof nested !== "object" || Array.isArray(nested)) continue;
+    const record = nested;
+    for (const key of keys) {
+      const value2 = cleanTelegramDecisionNote(record[key]);
+      if (value2) return value2;
+    }
+  }
+  return void 0;
+}
 function parseTelegramInteractionDecision(text, forcedRoute, options2 = {}) {
   const cleaned = stripTelegramHiddenThinking(text).replace(/```(?:json)?/gi, "").replace(/```/g, "").trim();
   const jsonText = cleaned.startsWith("{") ? cleaned : cleaned.match(/\{[\s\S]*\}/)?.[0] ?? "";
@@ -609603,7 +610233,11 @@ function parseTelegramInteractionDecision(text, forcedRoute, options2 = {}) {
       attentionDelta: Number.isFinite(attentionDeltaRaw) ? Math.max(-1, Math.min(1, attentionDeltaRaw)) : void 0,
       attentionScore: Number.isFinite(attentionScoreRaw) ? Math.max(0, Math.min(1, attentionScoreRaw)) : void 0,
       nextCheckAfterMessages: Number.isFinite(nextMessagesRaw) ? Math.max(1, Math.floor(nextMessagesRaw)) : void 0,
-      nextCheckAfterMs: Number.isFinite(nextMsRaw) ? Math.max(0, Math.floor(nextMsRaw)) : void 0
+      nextCheckAfterMs: Number.isFinite(nextMsRaw) ? Math.max(0, Math.floor(nextMsRaw)) : void 0,
+      silentDisposition: telegramDecisionNote(parsed, ["silent_disposition", "silentDisposition", "disposition"]),
+      mentalNote: telegramDecisionNote(parsed, ["mental_note", "mentalNote", "observation", "insight"]),
+      memoryNote: telegramDecisionNote(parsed, ["memory_note", "memoryNote", "memory"]),
+      relationshipNote: telegramDecisionNote(parsed, ["relationship_note", "relationshipNote", "relationship"])
     };
   } catch {
     return null;
@@ -609817,8 +610451,8 @@ function stripTelegramHiddenThinking(text) {
   return withoutClosedThink.replace(/<think>[\s\S]*$/gi, "");
 }
 function sanitizeTelegramProgressText(text, maxLength) {
-  const compact2 = stripTelegramHiddenThinking(text).replace(/\s+/g, " ").trim();
-  return compact2.length > maxLength ? compact2.slice(0, Math.max(0, maxLength - 3)) + "..." : compact2;
+  const compact3 = stripTelegramHiddenThinking(text).replace(/\s+/g, " ").trim();
+  return compact3.length > maxLength ? compact3.slice(0, Math.max(0, maxLength - 3)) + "..." : compact3;
 }
 function isCodebaseMemoryStatus(text) {
   return /^\s*\[CODEBASE MEMORY\]/i.test(stripTelegramHiddenThinking(text));
@@ -609860,26 +610494,26 @@ function isTelegramNoReplySentinel(text) {
   return lower === "no_reply" || lower.startsWith("no_reply");
 }
 function isTelegramInternalStatusText(text) {
-  const compact2 = compactTelegramVisibleText(text);
-  if (!compact2) return false;
-  const lower = compact2.toLowerCase();
-  if (isTelegramNoReplySentinel(compact2)) return true;
+  const compact3 = compactTelegramVisibleText(text);
+  if (!compact3) return false;
+  const lower = compact3.toLowerCase();
+  if (isTelegramNoReplySentinel(compact3)) return true;
   if (lower === "complete" || lower === "completed") return true;
-  if (/^memory stage:/i.test(compact2)) return true;
-  if (/^\[ppr[-_\s]?skip\]/i.test(compact2)) return true;
-  if (/^(casual|ambient|group)\b.{0,180}\b(skipping|skipped|not directed|no action needed|no reply)\b/i.test(compact2)) return true;
-  if (/^no further action needed\b/i.test(compact2)) return true;
-  if (/^no action needed\b.{0,120}\b(task|complete|completed|done)\b/i.test(compact2)) return true;
-  if (/^(there'?s|there is) no active task\b/i.test(compact2)) return true;
-  if (/^everything'?s (done|complete|completed|wrapped up)\b/i.test(compact2)) return true;
-  if (/\balready (been )?(provided|answered|handled|delivered) above\b/i.test(compact2)) return true;
-  if (/\b(no remaining work|nothing left to do|task is complete|task has been completed)\b/i.test(compact2)) return true;
+  if (/^memory stage:/i.test(compact3)) return true;
+  if (/^\[ppr[-_\s]?skip\]/i.test(compact3)) return true;
+  if (/^(casual|ambient|group)\b.{0,180}\b(skipping|skipped|not directed|no action needed|no reply)\b/i.test(compact3)) return true;
+  if (/^no further action needed\b/i.test(compact3)) return true;
+  if (/^no action needed\b.{0,120}\b(task|complete|completed|done)\b/i.test(compact3)) return true;
+  if (/^(there'?s|there is) no active task\b/i.test(compact3)) return true;
+  if (/^everything'?s (done|complete|completed|wrapped up)\b/i.test(compact3)) return true;
+  if (/\balready (been )?(provided|answered|handled|delivered) above\b/i.test(compact3)) return true;
+  if (/\b(no remaining work|nothing left to do|task is complete|task has been completed)\b/i.test(compact3)) return true;
   return false;
 }
 function isTelegramStuckSelfTalkSegment(text) {
-  const compact2 = text.trim();
-  if (!compact2) return false;
-  return TELEGRAM_STUCK_SELF_TALK_PREFIXES.some((re) => re.test(compact2));
+  const compact3 = text.trim();
+  if (!compact3) return false;
+  return TELEGRAM_STUCK_SELF_TALK_PREFIXES.some((re) => re.test(compact3));
 }
 function stripTelegramStuckSelfTalk(text) {
   if (!text) return "";
@@ -609947,9 +610581,12 @@ function truncateTelegramContext(text, maxLength) {
 [Telegram context truncated; use tools for full detail.]`;
 }
 function truncateTelegramContextLine(text, maxLength = TELEGRAM_CONTEXT_LINE_LIMIT) {
-  const compact2 = stripTelegramHiddenThinking(text).replace(/\s+/g, " ").trim();
-  if (compact2.length <= maxLength) return compact2;
-  return `${compact2.slice(0, Math.max(0, maxLength - 3)).trimEnd()}...`;
+  const compact3 = stripTelegramHiddenThinking(text).replace(/\s+/g, " ").trim();
+  if (compact3.length <= maxLength) return compact3;
+  return `${compact3.slice(0, Math.max(0, maxLength - 3)).trimEnd()}...`;
+}
+function telegramRegexEscape(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function redactTelegramLocalPaths(text) {
   return text.replace(/\/(?:home|root|tmp|var|etc|usr|opt|mnt|media|srv|run)\/[^\s"'`<>)]*/g, "[local-path-redacted]");
@@ -610156,7 +610793,7 @@ function buildTelegramRuntimeContext(now = /* @__PURE__ */ new Date(), repoRoot)
   ].filter(Boolean).join("\n");
 }
 function telegramSessionIdFromKey(sessionKey) {
-  return `telegram-${createHash23("sha1").update(sessionKey).digest("hex").slice(0, 16)}`;
+  return `telegram-${createHash24("sha1").update(sessionKey).digest("hex").slice(0, 16)}`;
 }
 function selectTelegramFinalResponse(args) {
   const committedVisibleReply = cleanTelegramVisibleReply(args.visibleReplyText || "");
@@ -610983,6 +611620,7 @@ var init_telegram_bridge = __esm({
     init_telegram_reflection_corpus();
     init_memory_paths();
     init_telegram_reflection_extraction();
+    init_telegram_social_state();
     init_dist7();
     TELEGRAM_TOOL_ACTION_GROUPS = [
       "read",
@@ -611379,6 +612017,7 @@ External acquisition contract:
       lastUpdateId = 0;
       state = {
         active: false,
+        botUserId: void 0,
         botUsername: "",
         botFirstName: void 0,
         supportsGuestQueries: false,
@@ -611403,6 +612042,8 @@ External acquisition contract:
       chatMemoryCards = /* @__PURE__ */ new Map();
       /** Durable associative memory by scoped Telegram chat key. */
       chatAssociativeMemory = /* @__PURE__ */ new Map();
+      /** Durable social cognition state by scoped Telegram chat key. */
+      chatSocialState = /* @__PURE__ */ new Map();
       /** Generic chronological attention cadence shared by live surfaces. */
       stimulation = new StimulationController();
       /** Throttles noisy "skipped group chatter" waterfall logs */
@@ -611550,6 +612191,38 @@ External acquisition contract:
       get botUsername() {
         return this.state.botUsername;
       }
+      currentTelegramBotUserId() {
+        const stateId = this.state.botUserId;
+        if (typeof stateId === "number" && Number.isFinite(stateId)) return stateId;
+        if (typeof this.botUserId === "number" && Number.isFinite(this.botUserId)) return this.botUserId;
+        return void 0;
+      }
+      telegramSelfIdentitySignals() {
+        const username = this.state.botUsername.trim().replace(/^@/, "");
+        const firstName = this.state.botFirstName?.trim() ?? "";
+        const botUserId = this.currentTelegramBotUserId();
+        return [
+          username ? `@${username}` : "",
+          username,
+          firstName,
+          botUserId !== void 0 ? `telegram_user_id:${botUserId}` : ""
+        ];
+      }
+      buildTelegramSelfIdentityContext() {
+        const username = this.state.botUsername.trim().replace(/^@/, "");
+        const firstName = this.state.botFirstName?.trim() ?? "";
+        const botUserId = this.currentTelegramBotUserId();
+        const detail = [
+          botUserId !== void 0 ? `user_id=${botUserId}` : "user_id=unknown",
+          username ? `username=@${username}` : "username=unknown",
+          firstName ? `display_name=${firstName}` : "display_name=unknown"
+        ].join(", ");
+        return [
+          `Telegram bot self identity: ${detail}.`,
+          `Known self identity signals (context only, not triggers): ${formatTelegramIdentitySignals(this.telegramSelfIdentitySignals())}.`,
+          `Use these signals to infer whether heard text is probably aimed at this bot; identity matches raise salience but never force should_reply.`
+        ].join("\n");
+      }
       beginAdminAuthChallenge(ttlMs = 5 * 60 * 1e3) {
         const code8 = String(randomInt(1e5, 1e6));
         this.adminAuthChallenge = {
@@ -611572,11 +612245,61 @@ External acquisition contract:
         return !!this.adminAuthChallenge && this.adminAuthChallenge.expiresAtMs > Date.now();
       }
       hashAdminAuthCode(code8) {
-        return createHash23("sha256").update(`omnius-telegram-admin:${code8.trim()}`).digest("hex");
+        return createHash24("sha256").update(`omnius-telegram-admin:${code8.trim()}`).digest("hex");
       }
       viewIdForMessage(msg) {
         return `telegram-${this.sessionKeyForMessage(msg).replace(/[^A-Za-z0-9_-]/g, "-")}`;
       }
+      attentionViewIdForMessage(msg) {
+        const id = Number.isFinite(msg.messageId) ? msg.messageId : Date.now();
+        return `${this.viewIdForMessage(msg)}-heard-${id}`;
+      }
+      registerTelegramAttentionView(msg, toolContext, detail = "heard message") {
+        if (!this.subAgentViewCallbacks) return null;
+        const viewId = this.attentionViewIdForMessage(msg);
+        const preview = truncateTelegramContextLine(msg.text || summarizeTelegramMessageAttachments(msg) || "[non-text Telegram message]", 160);
+        const chat = msg.chatTitle || msg.chatType;
+        this.subAgentViewCallbacks.onRegister(
+          viewId,
+          `✈ heard @${msg.username || "telegram"}`,
+          `Telegram attention: ${preview}`
+        );
+        this.subAgentViewCallbacks.onWrite(
+          viewId,
+          `heard: @${msg.username || "unknown"} [${telegramActorKindLabel(msg)}] in ${chat}: ${preview}`
+        );
+        const replyEdge = this.formatTelegramReplyEdgeForTui(this.sessionKeyForMessage(msg), msg);
+        if (replyEdge) this.subAgentViewCallbacks.onWrite(viewId, replyEdge);
+        this.subAgentViewCallbacks.onWrite(viewId, `context: ${detail}; tool_context=${toolContext}; assessing attention, memory, and relationship state`);
+        this.subAgentViewCallbacks.onStatus(viewId, "running");
+        return viewId;
+      }
+      writeTelegramAttentionDecision(viewId, decision) {
+        if (!viewId || !this.subAgentViewCallbacks) return;
+        const route = decision.shouldReply ? `reply via ${decision.route}` : "silent";
+        const attention = [
+          decision.attentionState ? `state=${decision.attentionState}` : "",
+          decision.attentionDelta !== void 0 ? `delta=${decision.attentionDelta.toFixed(2)}` : "",
+          decision.attentionScore !== void 0 ? `score=${decision.attentionScore.toFixed(2)}` : ""
+        ].filter(Boolean).join(", ");
+        const cadence = [
+          decision.nextCheckAfterMessages !== void 0 ? `after ${decision.nextCheckAfterMessages} message(s)` : "",
+          decision.nextCheckAfterMs !== void 0 ? `after ${Math.round(decision.nextCheckAfterMs / 1e3)}s` : ""
+        ].filter(Boolean).join(" or ");
+        const lines = [
+          `decision: ${route} (${decision.source}, confidence ${decision.confidence.toFixed(2)})`,
+          attention ? `attention: ${attention}` : "",
+          `reason: ${decision.reason}`,
+          decision.silentDisposition ? `silent disposition: ${decision.silentDisposition}` : "",
+          decision.mentalNote ? `mental note: ${decision.mentalNote}` : "",
+          decision.memoryNote ? `memory note: ${decision.memoryNote}` : "",
+          decision.relationshipNote ? `relationship note: ${decision.relationshipNote}` : "",
+          cadence ? `next attention sample: ${cadence}` : ""
+        ].filter(Boolean);
+        this.subAgentViewCallbacks.onWrite(viewId, lines.join("\n"));
+        this.subAgentViewCallbacks.onStatus(viewId, "completed");
+        this.subAgentViewCallbacks.onComplete(viewId);
+      }
       normalizeTelegramCommandText(input) {
         const trimmed = input.trim();
         if (!trimmed.startsWith("/")) return input;
@@ -611776,7 +612499,10 @@ No scoped reflection artifact exists yet for this chat. Use <code>/reflect</code
         if (!sender) return void 0;
         const bot = this.state.botUsername.trim().replace(/^@/, "").toLowerCase();
         const senderUsername = sender.username?.trim().replace(/^@/, "").toLowerCase();
-        const isSelf = Boolean(sender.isSelf || bot && senderUsername === bot);
+        const botUserId = this.currentTelegramBotUserId();
+        const isSelf = Boolean(
+          sender.isSelf || bot && senderUsername === bot || botUserId !== void 0 && sender.id === botUserId
+        );
         return isSelf === sender.isSelf ? sender : { ...sender, isSelf };
       }
       telegramReplyContextFromHistoryEntry(entry) {
@@ -611995,11 +612721,11 @@ ${mediaContext}` : ""
         return payload;
       }
       telegramConversationPath(sessionKey) {
-        const safe = createHash23("sha1").update(sessionKey).digest("hex").slice(0, 20);
+        const safe = createHash24("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);
+        const safe = createHash24("sha1").update(sessionKey).digest("hex").slice(0, 20);
         return join127(this.telegramConversationDir, `${safe}.events.jsonl`);
       }
       telegramDb() {
@@ -612227,7 +612953,7 @@ ${mediaContext}` : ""
           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)),
+            id: String(action.id || createHash24("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"),
@@ -612244,7 +612970,7 @@ ${mediaContext}` : ""
         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)),
+          id: String(raw.id || createHash24("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) : [],
@@ -612265,6 +612991,98 @@ ${mediaContext}` : ""
         }
         return memory;
       }
+      telegramSocialStateForSession(sessionKey) {
+        this.ensureTelegramConversationLoaded(sessionKey);
+        let state = this.chatSocialState.get(sessionKey);
+        if (!state) {
+          state = createTelegramSocialState();
+          this.chatSocialState.set(sessionKey, state);
+        }
+        return state;
+      }
+      telegramSelfSocialActorInput() {
+        return {
+          userId: this.currentTelegramBotUserId(),
+          username: this.state.botUsername || void 0,
+          firstName: this.state.botFirstName || "Omnius",
+          isBot: true,
+          isSelf: true
+        };
+      }
+      telegramMessageSocialActorInput(msg) {
+        return {
+          userId: msg.fromUserId,
+          username: msg.username,
+          firstName: msg.firstName,
+          isBot: Boolean(msg.isBot)
+        };
+      }
+      telegramReplySocialActorInput(msg) {
+        const sender = msg.replyContext?.sender;
+        if (sender) {
+          return {
+            userId: sender.id,
+            username: sender.username,
+            firstName: sender.firstName || sender.title,
+            isBot: Boolean(sender.isBot || sender.isSelf),
+            isSelf: Boolean(sender.isSelf)
+          };
+        }
+        if (!msg.replyToUsername) return void 0;
+        return {
+          username: msg.replyToUsername,
+          isBot: Boolean(msg.replyToBot)
+        };
+      }
+      observeTelegramSocialMessage(sessionKey, msg, text, salienceSignals) {
+        try {
+          observeTelegramSocialMessage(this.telegramSocialStateForSession(sessionKey), {
+            sessionKey,
+            chatId: msg.chatId,
+            chatType: msg.chatType,
+            chatTitle: msg.chatTitle,
+            text,
+            messageId: msg.messageId,
+            messageThreadId: msg.messageThreadId,
+            replyToMessageId: msg.replyToMessageId,
+            replySender: this.telegramReplySocialActorInput(msg),
+            salienceSignals: salienceSignals ?? this.telegramMessageIdentitySalienceSignals(msg),
+            self: this.telegramSelfSocialActorInput(),
+            ...this.telegramMessageSocialActorInput(msg)
+          });
+        } catch {
+        }
+      }
+      hydrateTelegramSocialStateFromHistory(sessionKey, history) {
+        const state = createTelegramSocialState();
+        this.chatSocialState.set(sessionKey, state);
+        for (const entry of history) {
+          if (entry.role !== "user") continue;
+          observeTelegramSocialMessage(state, {
+            sessionKey,
+            chatId: entry.chatId ?? sessionKey.replace(/^chat:/, ""),
+            chatType: entry.chatType,
+            chatTitle: entry.chatTitle,
+            text: entry.text,
+            messageId: entry.messageId,
+            messageThreadId: entry.messageThreadId,
+            replyToMessageId: entry.replyToMessageId,
+            replySender: entry.replyContext?.sender ? {
+              userId: entry.replyContext.sender.id,
+              username: entry.replyContext.sender.username,
+              firstName: entry.replyContext.sender.firstName || entry.replyContext.sender.title,
+              isBot: Boolean(entry.replyContext.sender.isBot || entry.replyContext.sender.isSelf),
+              isSelf: Boolean(entry.replyContext.sender.isSelf)
+            } : void 0,
+            self: this.telegramSelfSocialActorInput(),
+            userId: entry.fromUserId,
+            username: entry.username,
+            firstName: entry.firstName,
+            isBot: Boolean(entry.isBot),
+            ts: entry.ts
+          });
+        }
+      }
       telegramPersonalityScope(sessionKey, msg) {
         const label = msg.chatType !== "private" ? `${msg.chatTitle || msg.chatType}-${String(msg.chatId)}` : `private-${msg.username || msg.fromUserId || msg.chatId}`;
         return {
@@ -612324,6 +613142,11 @@ ${mediaContext}` : ""
           } else if (loadedHistory.length > 0) {
             this.hydrateTelegramAssociativeMemoryFromHistory(sessionKey, loadedHistory);
           }
+          if (parsed.socialState) {
+            this.chatSocialState.set(sessionKey, normalizeTelegramSocialState(parsed.socialState));
+          } else if (loadedHistory.length > 0) {
+            this.hydrateTelegramSocialStateFromHistory(sessionKey, loadedHistory);
+          }
           if (loadedHistory.length > 0) {
             this.backfillTelegramLoadedHistory(sessionKey, loadedHistory);
           }
@@ -612349,7 +613172,7 @@ ${mediaContext}` : ""
       }
       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);
+        const digest3 = createHash24("sha1").update(`${sessionKey}:${index}:${entry.role}:${entry.ts ?? ""}:${entry.text}`).digest("hex").slice(0, 8);
         return -Number.parseInt(digest3, 16);
       }
       backfillTelegramLoadedHistory(sessionKey, history) {
@@ -612496,6 +613319,7 @@ ${mediaContext}` : ""
             participants,
             memoryCards: this.chatMemoryCards.get(sessionKey) ?? [],
             associativeMemory: this.telegramAssociativeMemoryForSession(sessionKey),
+            socialState: this.telegramSocialStateForSession(sessionKey),
             stimulation: this.stimulation.getState(sessionKey),
             reflection: this.channelReflectionState.get(sessionKey) ?? { autoFollowup: false }
           };
@@ -612768,6 +613592,7 @@ ${mediaContext}` : ""
         }
       }
       formatLatestTelegramChannelDaydreamContext(sessionKey) {
+        this.registerLatestTelegramDaydreamOpportunities(sessionKey);
         return formatTelegramChannelDaydreamContext(this.latestTelegramChannelDaydream(sessionKey));
       }
       shouldForceAnalysisFromChannelDaydream(sessionKey) {
@@ -612781,6 +613606,81 @@ ${mediaContext}` : ""
         this.channelDmnPromptedArtifactAt.set(sessionKey, artifact.generatedAt);
         return true;
       }
+      latestTelegramDaydreamOpportunityInputs(sessionKey) {
+        const artifact = this.latestTelegramChannelDaydream(sessionKey);
+        if (!artifact || artifact.replyOpportunities.length === 0) return [];
+        return artifact.replyOpportunities.map((opportunity) => ({
+          id: opportunity.id,
+          trigger: opportunity.trigger,
+          confidence: opportunity.confidence,
+          artifactId: artifact.id,
+          generatedAt: artifact.generatedAt
+        }));
+      }
+      registerLatestTelegramDaydreamOpportunities(sessionKey) {
+        const opportunities = this.latestTelegramDaydreamOpportunityInputs(sessionKey);
+        if (opportunities.length === 0) return;
+        try {
+          registerDaydreamOpportunities(this.telegramSocialStateForSession(sessionKey), opportunities);
+        } catch {
+        }
+      }
+      markLatestTelegramDaydreamOpportunitiesConsidered(sessionKey, msg) {
+        const opportunities = this.latestTelegramDaydreamOpportunityInputs(sessionKey);
+        if (opportunities.length === 0) return [];
+        try {
+          markTelegramDaydreamOpportunitiesConsidered(this.telegramSocialStateForSession(sessionKey), opportunities, msg.messageId);
+        } catch {
+        }
+        return opportunities;
+      }
+      commitTelegramSocialDecision(sessionKey, msg, decision, salienceSignals, daydreamOpportunities = this.latestTelegramDaydreamOpportunityInputs(sessionKey)) {
+        try {
+          commitTelegramSocialDecision(this.telegramSocialStateForSession(sessionKey), {
+            sessionKey,
+            chatId: msg.chatId,
+            messageId: msg.messageId,
+            messageThreadId: msg.messageThreadId,
+            sender: this.telegramMessageSocialActorInput(msg),
+            replyToMessageId: msg.replyToMessageId,
+            route: decision.route,
+            shouldReply: decision.shouldReply,
+            confidence: decision.confidence,
+            reason: decision.reason,
+            source: decision.source,
+            silentDisposition: decision.silentDisposition,
+            mentalNote: decision.mentalNote,
+            memoryNote: decision.memoryNote,
+            relationshipNote: decision.relationshipNote,
+            salienceSignals,
+            self: this.telegramSelfSocialActorInput(),
+            daydreamOpportunities
+          });
+          this.saveTelegramConversationState(sessionKey);
+        } catch {
+        }
+      }
+      buildTelegramSocialStateContext(sessionKey, msg, salienceSignals = []) {
+        try {
+          this.registerLatestTelegramDaydreamOpportunities(sessionKey);
+          return formatTelegramSocialStateContext(this.telegramSocialStateForSession(sessionKey), {
+            sessionKey,
+            chatId: msg.chatId,
+            chatType: msg.chatType,
+            chatTitle: msg.chatTitle,
+            text: msg.text,
+            messageId: msg.messageId,
+            messageThreadId: msg.messageThreadId,
+            replyToMessageId: msg.replyToMessageId,
+            replySender: this.telegramReplySocialActorInput(msg),
+            salienceSignals,
+            self: this.telegramSelfSocialActorInput(),
+            ...this.telegramMessageSocialActorInput(msg)
+          });
+        } catch {
+          return "";
+        }
+      }
       renderTelegramScopedPersonality(sessionKey, msg) {
         try {
           return buildScopedPersonalityContext(this.telegramPersonalityScope(sessionKey, msg));
@@ -612856,6 +613756,7 @@ ${mediaContext}` : ""
         this.updateTelegramParticipantProfile(sessionKey, msg, text);
         this.updateTelegramMemoryCards(sessionKey, entry);
         this.updateTelegramAssociativeMemory(sessionKey, entry);
+        this.observeTelegramSocialMessage(sessionKey, msg, text);
         try {
           updateScopedPersonality(this.telegramPersonalityScope(sessionKey, msg), {
             speaker: telegramSpeakerLabel(msg),
@@ -613097,7 +613998,7 @@ ${mediaContext}` : ""
         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);
+        const actionId = createHash24("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,
@@ -613158,9 +614059,9 @@ ${mediaContext}` : ""
             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);
+          const compact3 = stripTelegramHiddenThinking(entry.text || "").replace(/\s+/g, " ").trim();
+          if (compact3) {
+            userMemory.lastMessages.push(compact3);
             userMemory.lastMessages = userMemory.lastMessages.slice(-40);
           }
           for (const topic of telegramMemoryTags(entry.text, entry.mediaSummary).slice(0, 6)) {
@@ -613219,7 +614120,7 @@ ${mediaContext}` : ""
         let fact = facts.find((item) => item.text.toLowerCase() === key);
         if (!fact) {
           fact = {
-            id: createHash23("sha1").update(`${entry.chatId ?? ""}:${key}`).digest("hex").slice(0, 12),
+            id: createHash24("sha1").update(`${entry.chatId ?? ""}:${key}`).digest("hex").slice(0, 12),
             text: clean5,
             tags: telegramMemoryTags(clean5, entry.mediaSummary),
             speakers: [],
@@ -613274,7 +614175,7 @@ ${mediaContext}` : ""
           const titleTags = tags.slice(0, 4);
           const title = titleTags.length > 0 ? `${speaker} / ${titleTags.join(" ")}` : `${speaker} / conversation`;
           const card = {
-            id: createHash23("sha1").update(`${sessionKey}:${now}:${speaker}:${text}`).digest("hex").slice(0, 12),
+            id: createHash24("sha1").update(`${sessionKey}:${now}:${speaker}:${text}`).digest("hex").slice(0, 12),
             title,
             notes: [],
             tags: [],
@@ -614050,7 +614951,7 @@ ${lines.join("\n")}`);
         lines.push("  5. memory_search accepts NATURAL-LANGUAGE TIME phrases inside the `query` argument or explicit `since`/`until`/`bucket` args. Examples: query='what did manitcor say yesterday', query='last 3 hours', query='earlier today', query='2 days ago', query='since 2026-05-15', query='between 2026-05-15 and 2026-05-16', query='oldest memory about github', query='most recent flux discussion'. Use these for chronological/'how far back' style queries instead of guessing — the tool parses the phrase, filters by time, and returns the right window.");
         return lines.join("\n");
       }
-      buildTelegramConversationContextStream(sessionKey, msg, maxRecent = TELEGRAM_CONTEXT_RECENT_DEFAULT) {
+      buildTelegramConversationContextStream(sessionKey, msg, maxRecent = TELEGRAM_CONTEXT_RECENT_DEFAULT, salienceSignals = []) {
         this.ensureTelegramConversationLoaded(sessionKey);
         const history = this.chatHistory.get(sessionKey) ?? [];
         const participants = [...this.chatParticipants.get(sessionKey)?.values() ?? []].sort((a2, b) => b.lastSeenTs - a2.lastSeenTs);
@@ -614082,6 +614983,10 @@ ${lines.join("\n")}`);
         if (scopedPersonality) {
           sections.push(scopedPersonality);
         }
+        const socialStateContext = this.buildTelegramSocialStateContext(sessionKey, msg, salienceSignals);
+        if (socialStateContext) {
+          sections.push(socialStateContext);
+        }
         if (participants.length > 0) {
           const participantLines = participants.slice(0, 12).map((profile) => {
             const label = profile.username && profile.username !== "unknown" ? `@${profile.username}` : profile.firstName || `user:${profile.fromUserId}`;
@@ -614215,26 +615120,45 @@ ${lines.join("\n")}`);
         this.groupSkipLogAt.set(sessionKey, now);
         this.tuiWrite(() => renderTelegramSubAgentEvent(msg.username, `${reason} (context retained)`));
       }
-      telegramMessageAddressesBot(msg) {
-        const bot = this.state.botUsername.trim().replace(/^@/, "").toLowerCase();
-        if (!bot) return false;
-        const mentioned = (msg.mentionedUsernames ?? []).some(
-          (name10) => name10.trim().replace(/^@/, "").toLowerCase() === bot
-        );
-        if (mentioned) return true;
-        if (msg.replyToUsername && msg.replyToUsername.trim().replace(/^@/, "").toLowerCase() === bot) return true;
-        const replyUsername = msg.replyContext?.sender?.username?.trim().replace(/^@/, "").toLowerCase();
-        if (replyUsername && replyUsername === bot) return true;
+      telegramMessageIdentitySalienceSignals(msg) {
+        const signals = /* @__PURE__ */ new Set();
+        const username = this.state.botUsername.trim().replace(/^@/, "");
+        const usernameLower = username.toLowerCase();
+        const displayName = this.state.botFirstName?.trim() ?? "";
+        const botUserId = this.currentTelegramBotUserId();
+        const text = msg.text || "";
+        if (msg.chatType === "private") signals.add("private_dm_delivery");
+        if (usernameLower) {
+          const mentioned = (msg.mentionedUsernames ?? []).some(
+            (name10) => name10.trim().replace(/^@/, "").toLowerCase() === usernameLower
+          );
+          if (mentioned) signals.add(`entity_mention:@${username}`);
+          const rawMention = new RegExp(`(^|[^A-Za-z0-9_@])@${telegramRegexEscape(username)}(?![A-Za-z0-9_])`, "i");
+          if (rawMention.test(text)) signals.add(`raw_text_mention:@${username}`);
+          if (msg.replyToUsername && msg.replyToUsername.trim().replace(/^@/, "").toLowerCase() === usernameLower) {
+            signals.add(`reply_to_username:@${username}`);
+          }
+          const replyUsername = msg.replyContext?.sender?.username?.trim().replace(/^@/, "").toLowerCase();
+          if (replyUsername && replyUsername === usernameLower) signals.add(`reply_context_username:@${username}`);
+        }
+        if (displayName.length >= 3) {
+          const displayPattern = new RegExp(`(^|[^\\p{L}\\p{N}_])${telegramRegexEscape(displayName)}(?![\\p{L}\\p{N}_])`, "iu");
+          if (displayPattern.test(text)) signals.add(`display_name:${displayName}`);
+        }
+        if (botUserId !== void 0 && msg.replyContext?.sender?.id === botUserId) {
+          signals.add(`reply_context_user_id:${botUserId}`);
+        }
         const resolvedReply = this.resolveTelegramReplyContext(this.sessionKeyForMessage(msg), msg);
-        if (resolvedReply?.sender?.isSelf) return true;
-        return false;
+        if (resolvedReply?.sender?.isSelf) signals.add("reply_to_self_history");
+        return [...signals];
       }
       telegramMessageRepliesToBot(msg) {
         const bot = this.state.botUsername.trim().replace(/^@/, "").toLowerCase();
-        if (!bot) return false;
+        const botUserId = this.currentTelegramBotUserId();
         const legacyReply = msg.replyToUsername?.trim().replace(/^@/, "").toLowerCase();
         const contextReply = msg.replyContext?.sender?.username?.trim().replace(/^@/, "").toLowerCase();
-        if (legacyReply === bot || contextReply === bot) return true;
+        if (bot && (legacyReply === bot || contextReply === bot)) return true;
+        if (botUserId !== void 0 && msg.replyContext?.sender?.id === botUserId) return true;
         const resolvedReply = this.resolveTelegramReplyContext(this.sessionKeyForMessage(msg), msg);
         return Boolean(resolvedReply?.sender?.isSelf);
       }
@@ -614252,7 +615176,8 @@ ${lines.join("\n")}`);
         const config = this.agentConfig;
         const forcedRoute = this.interactionMode === "chat" || this.interactionMode === "action" ? this.interactionMode : null;
         const isGroup = msg.chatType !== "private";
-        const addressesBot = this.telegramMessageAddressesBot(msg);
+        const identitySalienceSignals = this.telegramMessageIdentitySalienceSignals(msg);
+        const addressesBot = identitySalienceSignals.length > 0;
         const sessionKey = this.sessionKeyForMessage(msg);
         const daydreamForceCheck = isGroup && this.shouldForceAnalysisFromChannelDaydream(sessionKey);
         const stimulationProbe = this.stimulation.observe({
@@ -614269,7 +615194,9 @@ ${lines.join("\n")}`);
             shouldReply: false,
             confidence: 0,
             reason: "router inference unavailable; no model-derived reply decision",
-            source: "inference-unavailable"
+            source: "inference-unavailable",
+            silentDisposition: "retained as context without replying",
+            mentalNote: "router unavailable, so no model-derived attention note was produced"
           };
           this.applyTelegramStimulationDecision(sessionKey, fallback2);
           return fallback2;
@@ -614280,19 +615207,14 @@ ${lines.join("\n")}`);
           config.apiKey
         );
         const forcedLine = forcedRoute ? `The operator selected Telegram mode "${forcedRoute}". The route field MUST be "${forcedRoute}", but should_reply must still be inferred live from context.` : `The operator selected Telegram mode "auto". Infer route live from context.`;
-        const context2 = this.buildTelegramConversationContextStream(sessionKey, msg, isGroup ? 36 : 20);
+        const context2 = this.buildTelegramConversationContextStream(sessionKey, msg, isGroup ? 36 : 20, identitySalienceSignals);
         const currentReplyContext = this.buildTelegramCurrentReplyContext(sessionKey, msg);
-        const botUsername = this.state.botUsername || "unknown";
-        const botIdentitySignals = [
-          botUsername && botUsername !== "unknown" ? `@${botUsername}` : "",
-          botUsername && botUsername !== "unknown" ? botUsername.replace(/^@/, "") : "",
-          this.state.botFirstName || ""
-        ];
+        const selfIdentityContext = this.buildTelegramSelfIdentityContext();
         const userPrompt = [
           `You are the Telegram live routing and reply-discretion model.`,
           `Return JSON only, with no markdown and no explanation outside JSON.`,
           ``,
-          `Schema: {"route":"chat"|"action","should_reply":true|false,"confidence":0.0-1.0,"reason":"short reason","attention_state":"idle"|"observing"|"engaged"|"cooldown","attention_delta":-1.0..1.0,"next_check_after_messages":1..12}`,
+          `Schema: {"route":"chat"|"action","should_reply":true|false,"confidence":0.0-1.0,"reason":"short reason","attention_state":"idle"|"observing"|"engaged"|"cooldown","attention_delta":-1.0..1.0,"next_check_after_messages":1..12,"silent_disposition":"short outcome-level disposition","mental_note":"short outcome-level observation","memory_note":"short memory/summary update","relationship_note":"short relationship/thread note"}`,
           ``,
           `Route meanings:`,
           `- chat: a short conversational answer can be produced without tools.`,
@@ -614301,7 +615223,9 @@ ${lines.join("\n")}`);
           ``,
           `Reply discretion: make a human-like attention decision from the full social context. Observe the message, relationship stream, reply graph, conversation momentum, prior bot involvement, speaker intent, and notification-like signals, then decide whether a visible reply would be natural.`,
           `No hard triggers: direct address, @mentions, name/identity references, private-chat delivery, replies, active threads, and stimulation score are evidence only. They may raise or lower salience, but none guarantees should_reply=true or should_reply=false.`,
+          `High-salience evidence: private DMs, exact @username matches, display-name self references, and replies to this bot are notification-like signals. They should usually move attention toward deeper processing and a likely response unless the surrounding context makes silence more natural.`,
           `No keyword routing: do not use static keyword rules. Infer whether identity references are actually aimed at this bot from syntax, tone, recent turns, and relationships.`,
+          `Observation notes: always fill silent_disposition, mental_note, memory_note, and relationship_note with concise outcome-level notes for the TUI. Do not expose hidden chain-of-thought; summarize what the bot did with the heard message.`,
           `Bot-to-bot discipline: sender labels include [bot] or [human]. Treat peer bots as autonomous actors, not human users. Avoid bot loops by replying only when the exchange context makes a response socially useful.`,
           `Ingress discipline: this Telegram message has already been retained as chat context. should_reply controls only whether to emit a visible reply.`,
           `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.`,
@@ -614310,8 +615234,9 @@ ${lines.join("\n")}`);
           forcedLine,
           ``,
           `Tool context: ${toolContext}`,
-          `Known self identity signals (context only, not triggers): ${formatTelegramIdentitySignals(botIdentitySignals)}`,
+          selfIdentityContext,
           `Platform notification/direct-address signal (salience evidence only, not a decision): ${addressesBot ? "yes" : "no"}`,
+          `Platform salience signals (context only, not triggers): ${identitySalienceSignals.length ? identitySalienceSignals.join(", ") : "none"}`,
           `Current chat type: ${msg.chatType}`,
           `Current sender: ${telegramSpeakerLabel(msg)} [${telegramActorKindLabel(msg)}]`,
           msg.replyToMessageId ? `Current message replies to message_id ${msg.replyToMessageId}` : "",
@@ -614359,7 +615284,9 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
           shouldReply: false,
           confidence: 0,
           reason: "router inference failed; no model-derived reply decision",
-          source: "inference-unavailable"
+          source: "inference-unavailable",
+          silentDisposition: "retained as context without replying",
+          mentalNote: "router failed, so no model-derived attention note was produced"
         };
         this.applyTelegramStimulationDecision(sessionKey, fallback);
         return fallback;
@@ -614490,7 +615417,7 @@ ${list}` : "No shared group target is currently known for this sender. Ask in th
       }
       telegramRunnerStateDir(sessionKey) {
         if (!this.repoRoot) return void 0;
-        const safe = createHash23("sha1").update(sessionKey).digest("hex").slice(0, 20);
+        const safe = createHash24("sha1").update(sessionKey).digest("hex").slice(0, 20);
         return join127(this.repoRoot, ".omnius", "telegram-runner-state", safe);
       }
       buildTelegramAdminOverviewContext(currentSessionKey) {
@@ -614709,6 +615636,7 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`);
         }
         this.state = {
           active: true,
+          botUserId: typeof me.result?.id === "number" ? me.result.id : void 0,
           botUsername: me.result?.username ?? "unknown",
           botFirstName: typeof me.result?.first_name === "string" ? me.result.first_name : void 0,
           supportsGuestQueries: Boolean(me.result?.supports_guest_queries),
@@ -614958,10 +615886,8 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`);
         if (startsWithSlash && isAdminAuthSecretCommand && await this.handleAdminAuthCommand({ ...msg, text: normalizedCommandText })) {
           return;
         }
-        if (msg.chatType !== "private") {
-          this.recordTelegramUserMessage(msg, "ambient");
-          this.tuiWrite(() => renderTelegramIngressMessage(msg));
-        }
+        this.recordTelegramUserMessage(msg, "ambient");
+        this.tuiWrite(() => renderTelegramIngressMessage(msg));
         if (startsWithSlash && !isAdminAuthSecretCommand && await this.handleAdminAuthCommand({ ...msg, text: normalizedCommandText })) {
           return;
         }
@@ -615083,8 +616009,16 @@ Join: ${newUrl}`);
         if (existing && !existing.aborted) {
           const isGroup = msg.chatType !== "private";
           if (isGroup) {
-            this.recordTelegramUserMessage(msg, "ambient");
+            const attentionViewId2 = this.registerTelegramAttentionView(msg, existing.toolContext || toolContext, "active Telegram thread");
             const decision2 = await this.inferTelegramInteractionDecision(msg, existing.toolContext || toolContext);
+            this.writeTelegramAttentionDecision(attentionViewId2, decision2);
+            this.commitTelegramSocialDecision(
+              sessionKey,
+              msg,
+              decision2,
+              this.telegramMessageIdentitySalienceSignals(msg),
+              this.markLatestTelegramDaydreamOpportunitiesConsidered(sessionKey, msg)
+            );
             this.markLastTelegramUserMessageMode(msg, decision2.shouldReply ? "steering" : "ambient");
             this.subAgentViewCallbacks?.onWrite(
               existing.viewId,
@@ -615119,8 +616053,16 @@ Join: ${newUrl}`);
           }
           return;
         }
-        this.recordTelegramUserMessage(msg, "ambient");
+        const attentionViewId = this.registerTelegramAttentionView(msg, toolContext);
         const decision = await this.inferTelegramInteractionDecision(msg, toolContext);
+        this.writeTelegramAttentionDecision(attentionViewId, decision);
+        this.commitTelegramSocialDecision(
+          sessionKey,
+          msg,
+          decision,
+          this.telegramMessageIdentitySalienceSignals(msg),
+          this.markLatestTelegramDaydreamOpportunitiesConsidered(sessionKey, msg)
+        );
         this.markLastTelegramUserMessageMode(msg, decision.shouldReply ? decision.route : "ambient");
         this.subAgentViewCallbacks?.onWrite(
           this.viewIdForMessage(msg),
@@ -615502,6 +616444,7 @@ ${TELEGRAM_PUBLIC_MEMORY_SCOPE_CONTRACT}
 ${TELEGRAM_PUBLIC_VISION_STACK_CONTRACT}`;
         const groupHint = isGroup ? `Telegram group: ${msg.chatTitle || "unknown"}. The live router selected this turn as reply-worthy; keep the reply short and relevant. Never output a skip decision, no_reply marker, memory-stage note, or completion status.` : "Telegram private chat.";
         const runtime = buildTelegramRuntimeContext(/* @__PURE__ */ new Date());
+        const selfIdentityContext = this.buildTelegramSelfIdentityContext();
         const messages2 = [
           {
             role: "system",
@@ -615511,6 +616454,8 @@ ${TELEGRAM_PUBLIC_VISION_STACK_CONTRACT}`;
 
 ${runtime}
 
+${selfIdentityContext}
+
 ${safety}
 
 ${groupHint}
@@ -615548,12 +616493,17 @@ ${conversationStream}`
         };
         let accumulated = "";
         const streamable = backend;
-        if (typeof streamable.chatCompletionStream === "function") {
-          for await (const chunk of streamable.chatCompletionStream(request)) {
-            if (chunk.type === "content" && !chunk.thinking && chunk.content) {
-              accumulated += chunk.content;
-              await onToken(accumulated);
+        const stream = typeof streamable.chatCompletionStream === "function" ? streamable.chatCompletionStream(request) : null;
+        if (stream && typeof stream[Symbol.asyncIterator] === "function") {
+          try {
+            for await (const chunk of stream) {
+              if (chunk.type === "content" && !chunk.thinking && chunk.content) {
+                accumulated += chunk.content;
+                await onToken(accumulated);
+              }
             }
+          } catch {
+            accumulated = "";
           }
         }
         if (!accumulated.trim()) {
@@ -615787,10 +616737,13 @@ Respond concisely and safely. Send the actual chat reply, not router/status/comp
 [Media attached — processed content below]
 ${mediaContext}`;
         }
+        const selfIdentityContext = this.buildTelegramSelfIdentityContext();
         const systemCtx = isAdminDM ? `${runtimeContext}
+${selfIdentityContext}
 Telegram admin: @${msg.username}
 Telegram profile: ${profile}
 Todo/session id: ${sessionContext.sessionId}` : `${runtimeContext}
+${selfIdentityContext}
 Telegram ${isGroup ? "group" : "public"} chat. Respond concisely. Safety filter: ACTIVE.${creativeWorkspace ? `
 
 ${creativeWorkspace}` : ""}`;
@@ -617201,7 +618154,9 @@ Scoped workspace: ${scopedRoot}`,
         }
         const botId = result.result.id;
         this.botUserId = botId;
+        this.state.botUserId = botId;
         if (typeof result.result.username === "string") this.state.botUsername = result.result.username;
+        if (typeof result.result.first_name === "string") this.state.botFirstName = result.result.first_name;
         return botId;
       }
       async getChatMember(chatId, userId) {
@@ -617795,9 +618750,9 @@ ${knownList}` : "Private-user telegram_send_file target must be this DM or a kno
         }
         const target = String(rawTarget).trim();
         if (/^-?\d+$/.test(target)) return { ok: true, chatId: target };
-        const cleanUsername = target.replace(/^@/, "");
-        if (/^[A-Za-z0-9_]{5,32}$/.test(cleanUsername)) {
-          return { ok: true, chatId: `@${cleanUsername}` };
+        const cleanUsername2 = target.replace(/^@/, "");
+        if (/^[A-Za-z0-9_]{5,32}$/.test(cleanUsername2)) {
+          return { ok: true, chatId: `@${cleanUsername2}` };
         }
         return { ok: false, error: "Expected chat_id/user_id as digits, or a valid @username." };
       }
@@ -620342,14 +621297,14 @@ var init_access_policy = __esm({
 });
 
 // packages/cli/src/api/project-preferences.ts
-import { createHash as createHash24 } from "node:crypto";
+import { createHash as createHash25 } from "node:crypto";
 import { existsSync as existsSync116, mkdirSync as mkdirSync68, readFileSync as readFileSync95, renameSync as renameSync8, writeFileSync as writeFileSync62, unlinkSync as unlinkSync24 } from "node:fs";
 import { homedir as homedir43 } from "node:os";
 import { join as join130, resolve as resolve45 } from "node:path";
 import { randomUUID as randomUUID15 } from "node:crypto";
 function projectKey(root) {
   const canonical = resolve45(root);
-  return createHash24("sha256").update(canonical).digest("hex").slice(0, 16);
+  return createHash25("sha256").update(canonical).digest("hex").slice(0, 16);
 }
 function projectDir(root) {
   return join130(PROJECTS_DIR, projectKey(root));
@@ -620441,7 +621396,7 @@ __export(voicechat_exports, {
   VoiceChatSession: () => VoiceChatSession
 });
 import { EventEmitter as EventEmitter12 } from "node:events";
-function clamp019(x) {
+function clamp0110(x) {
   return x < 0 ? 0 : x > 1 ? 1 : x;
 }
 function alnumRatio(s2) {
@@ -620480,9 +621435,9 @@ function computeSignalFromText(text, confidence2) {
   else score = 0.15;
   score -= repeatingCharPenalty(t2) * 0.4;
   if (typeof confidence2 === "number" && !Number.isNaN(confidence2)) {
-    score = 0.7 * score + 0.3 * clamp019(confidence2);
+    score = 0.7 * score + 0.3 * clamp0110(confidence2);
   }
-  return clamp019(score);
+  return clamp0110(score);
 }
 function truncateForLog(s2, n2) {
   return s2.length <= n2 ? s2 : s2.slice(0, n2 - 1) + "…";
@@ -620752,7 +621707,7 @@ Rules:
           }, MAX_SEGMENT_MS);
         }
         this.captureBuffer = text;
-        this.lastSignalScore = typeof snr === "number" && !Number.isNaN(snr) ? clamp019(snr) : computeSignalFromText(text, confidence2);
+        this.lastSignalScore = typeof snr === "number" && !Number.isNaN(snr) ? clamp0110(snr) : computeSignalFromText(text, confidence2);
         this.emit("snr", { score: this.lastSignalScore });
         this.onPartialTranscript(text);
         if (this.silenceTimer) clearTimeout(this.silenceTimer);
@@ -621527,7 +622482,7 @@ var init_disk_task_output = __esm({
 });
 
 // packages/cli/src/api/http.ts
-import { createHash as createHash25 } from "node:crypto";
+import { createHash as createHash26 } from "node:crypto";
 function problemDetails(opts) {
   const p2 = {
     type: opts.type ?? "about:blank",
@@ -621590,7 +622545,7 @@ function paginated(items, page2, total) {
 }
 function computeEtag(payload) {
   const json = typeof payload === "string" ? payload : JSON.stringify(payload);
-  const hash = createHash25("sha1").update(json).digest("hex").slice(0, 16);
+  const hash = createHash26("sha1").update(json).digest("hex").slice(0, 16);
   return `W/"${hash}"`;
 }
 function checkNotModified(req2, res, etag) {
@@ -635861,7 +636816,7 @@ import { homedir as homedir50 } from "node:os";
 import { spawn as spawn30, execSync as execSync57 } from "node:child_process";
 import { mkdirSync as mkdirSync76, writeFileSync as writeFileSync68, readFileSync as readFileSync103, readdirSync as readdirSync45, existsSync as existsSync127, watch as fsWatch3, renameSync as renameSync9, unlinkSync as unlinkSync26 } from "node:fs";
 import { randomBytes as randomBytes25, randomUUID as randomUUID16 } from "node:crypto";
-import { createHash as createHash27 } from "node:crypto";
+import { createHash as createHash28 } from "node:crypto";
 function memoryDbPaths3(baseDir = process.cwd()) {
   const dir = join141(baseDir, ".omnius");
   return {
@@ -641741,7 +642696,7 @@ function listScheduledTasks() {
               const schedule = String(t2?.schedule || t2?.cron || t2?.when || "");
               const enabled2 = typeof t2?.enabled === "boolean" ? t2.enabled : true;
               const realId = typeof t2?.id === "string" && t2.id ? t2.id : null;
-              const fallbackId = createHash27("sha1").update(`${file}#${i2}`).digest("hex").slice(0, 16);
+              const fallbackId = createHash28("sha1").update(`${file}#${i2}`).digest("hex").slice(0, 16);
               const uid = realId || fallbackId;
               const key = `${uid}`;
               if (seen.has(key)) return;
@@ -641858,8 +642813,8 @@ function deleteScheduledById(id) {
     if (id) candidates.push(id);
     if (typeof entry?.id === "string" && entry.id && !candidates.includes(entry.id)) candidates.push(entry.id);
     try {
-      const { createHash: createHash28 } = require4("node:crypto");
-      const fallback = createHash28("sha1").update(`${target.file}#${target.index}`).digest("hex").slice(0, 16);
+      const { createHash: createHash29 } = require4("node:crypto");
+      const fallback = createHash29("sha1").update(`${target.file}#${target.index}`).digest("hex").slice(0, 16);
       if (!candidates.includes(fallback)) candidates.push(fallback);
     } catch {
     }
@@ -651775,13 +652730,13 @@ NEW TASK: ${fullInput}`;
       writeContent(() => renderError(errMsg));
       if (failureStore) {
         try {
-          const { createHash: createHash28 } = await import("node:crypto");
+          const { createHash: createHash29 } = await import("node:crypto");
           failureStore.insert({
             taskId: "",
             sessionId: `${Date.now()}`,
             repoRoot,
             failureType: "runtime-error",
-            fingerprint: createHash28("sha256").update(errMsg.slice(0, 200)).digest("hex").slice(0, 16),
+            fingerprint: createHash29("sha256").update(errMsg.slice(0, 200)).digest("hex").slice(0, 16),
             filePath: null,
             errorMessage: errMsg.slice(0, 500),
             context: null,