omnius 1.0.157 → 1.0.158

package/dist/index.js

@@ -572826,6 +572826,7 @@ function newDocument(scope) {
     updatedAt: now,
     messageCount: 0,
     participants: {},
+    preferences: {},
     dominantTone: [],
     responseStyle: [
       "Prefer concise, direct answers unless the user asks for depth.",
@@ -572859,6 +572860,7 @@ function normalizeDocument(scope, parsed) {
       label: scope.label || parsed.scope?.label || fresh.scope.label
     },
     participants: parsed.participants && typeof parsed.participants === "object" ? parsed.participants : {},
+    preferences: parsed.preferences && typeof parsed.preferences === "object" ? parsed.preferences : {},
     dominantTone: Array.isArray(parsed.dominantTone) ? parsed.dominantTone : [],
     responseStyle: Array.isArray(parsed.responseStyle) && parsed.responseStyle.length > 0 ? parsed.responseStyle : fresh.responseStyle,
     relationshipModel: Array.isArray(parsed.relationshipModel) && parsed.relationshipModel.length > 0 ? parsed.relationshipModel : fresh.relationshipModel,
@@ -572878,6 +572880,41 @@ function normalizeDocument(scope, parsed) {
   }
   return doc;
 }
+function updateScopedPersonalityReplyPreference(scope, preference) {
+  const doc = loadScopedPersonality(scope);
+  const now = new Date(preference.ts ?? Date.now()).toISOString();
+  const existing = doc.preferences?.replyMode;
+  const evidence = preference.evidenceMessageId === void 0 ? existing?.evidenceMessageIds ?? [] : [.../* @__PURE__ */ new Set([...existing?.evidenceMessageIds ?? [], preference.evidenceMessageId])].slice(-12);
+  doc.preferences = {
+    ...doc.preferences ?? {},
+    replyMode: {
+      mode: preference.mode,
+      scope: preference.preferenceScope,
+      updatedAt: now,
+      confidence: Math.max(existing?.confidence ?? 0, Math.max(0, Math.min(1, preference.confidence ?? 0.84))),
+      evidenceMessageIds: evidence,
+      note: preference.note ? compactLine(preference.note, 220) : existing?.note,
+      source: preference.source ? compactLine(preference.source, 80) : existing?.source
+    }
+  };
+  doc.updatedAt = now;
+  const line = `${now} preference/reply_mode: ${preference.mode} (${preference.preferenceScope})${preference.note ? ` - ${compactLine(preference.note, 160)}` : ""}`;
+  if (!doc.durableObservations.includes(line)) doc.durableObservations.push(line);
+  doc.durableObservations = doc.durableObservations.slice(-MAX_PROFILE_DURABLE_OBSERVATIONS);
+  appendScopedPersonalityEvent(scope, {
+    ts: preference.ts ?? Date.now(),
+    iso: now,
+    role: "system",
+    mode: "reply-preference",
+    replyMode: preference.mode,
+    preferenceScope: preference.preferenceScope,
+    evidenceMessageId: preference.evidenceMessageId,
+    note: preference.note,
+    source: preference.source
+  });
+  saveScopedPersonality(scope, doc);
+  return doc;
+}
 function loadScopedPersonality(scope) {
   const paths = scopedPersonalityPaths(scope);
   if (!existsSync88(paths.json)) return newDocument(scope);
@@ -573001,6 +573038,7 @@ ${samples}` : ""}`;
   const topTopics = Object.entries(doc.topicCounts ?? {}).sort((a2, b) => b[1] - a2[1]).slice(0, 18).map(([topic, count]) => `- ${topic}: ${count}`);
   const durable = doc.durableObservations.slice(-18).map((line) => `- ${line}`);
   const relationships = doc.relationshipEvents.slice(-10).map((line) => `- ${line}`);
+  const replyMode = doc.preferences?.replyMode;
   return [
     `# Scoped Personality Profile`,
     ``,
@@ -573014,6 +573052,9 @@ ${samples}` : ""}`;
     `## Response Style`,
     doc.responseStyle.map((line) => `- ${line}`).join("\n"),
     ``,
+    `## Stored Preferences`,
+    replyMode ? `- reply_mode: ${replyMode.mode}; scope=${replyMode.scope}; confidence=${replyMode.confidence.toFixed(2)}; updated=${replyMode.updatedAt}${replyMode.note ? `; note=${replyMode.note}` : ""}` : "- none",
+    ``,
     `## Relationship Model`,
     doc.relationshipModel.map((line) => `- ${line}`).join("\n"),
     ``,
@@ -620429,10 +620470,10 @@ function formatSystemObservations(sessionKey) {
     if (recent.length > 0) {
       const sends = recent.filter((e2) => e2.kind.startsWith("telegram.send."));
       const reactions = recent.filter((e2) => e2.kind.startsWith("emoji."));
-      const forbidden = sends.filter((e2) => e2.kind === "telegram.send.forbidden").length;
-      const rateLimited = sends.filter((e2) => e2.kind === "telegram.send.rate_limited").length;
-      if (forbidden > 0) lines.push(`This chat has refused ${forbidden} recent send attempt(s) (e.g. no rights to post). Treat as a strong silence signal.`);
-      if (rateLimited > 0) lines.push(`This chat rate-limited ${rateLimited} recent send(s). Slow cadence.`);
+      const failures = sends.filter((e2) => e2.kind === "telegram.send.failed");
+      if (failures.length > 0) {
+        lines.push(`This chat has ${failures.length} recent raw Telegram send failure(s). Latest raw failure: ${failures[failures.length - 1]?.reason ?? "unknown"}.`);
+      }
       if (reactions.length > 0) {
         const reactSummary = reactions.filter((e2) => e2.kind === "emoji.reaction.received").map((e2) => e2.emoji).join("");
         if (reactSummary) lines.push(`Recent inbound reactions in this chat: ${reactSummary}`);
@@ -621879,6 +621920,15 @@ function telegramSocialActorKind(actor) {
 function telegramSocialThreadKey(input) {
   return input.messageThreadId !== void 0 ? `chat:${String(input.chatId)}:thread:${input.messageThreadId}` : `chat:${String(input.chatId)}`;
 }
+function telegramSocialChatPreferenceKey(chatId) {
+  return `chat:${String(chatId)}`;
+}
+function telegramSocialUserInChatPreferenceKey(chatId, actorKey) {
+  return `${telegramSocialChatPreferenceKey(chatId)}:${actorKey}`;
+}
+function telegramTextDeliveryCapabilityKey(input) {
+  return input.messageThreadId !== void 0 ? `${telegramSocialChatPreferenceKey(input.chatId)}:thread:${input.messageThreadId}:text` : `${telegramSocialChatPreferenceKey(input.chatId)}:text`;
+}
 function appendUnique(items, value2, max) {
   if (value2 === void 0 || value2 === null) return items.slice(-max);
   const next = items.filter((item) => item !== value2);
@@ -621951,14 +622001,29 @@ function formatTelegramSocialStateContext(state, input) {
   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]);
+  const chatPreferenceKey = telegramSocialChatPreferenceKey(input.chatId);
+  const userChatPreferenceKey = telegramSocialUserInChatPreferenceKey(input.chatId, senderKey3);
+  const scopedPreferences = [
+    ...preferenceLines(state.preferences[userChatPreferenceKey], "user-in-chat"),
+    ...preferenceLines(state.preferences[chatPreferenceKey], "chat")
+  ];
+  const resolvedReplyMode = resolveReplyModePreferenceForContext(state, input.chatId, senderKey3);
+  const delivery = state.deliveryCapabilities[telegramTextDeliveryCapabilityKey({
+    chatId: input.chatId,
+    messageThreadId: input.messageThreadId
+  })] ?? state.deliveryCapabilities[telegramTextDeliveryCapabilityKey({ chatId: input.chatId })];
   return [
     "### Telegram Structured Social State",
     selfKey ? `Agent self node: ${selfKey}` : "Agent self node: unknown",
     `Identity boundary: the agent is the self node only. Current actor ${senderKey3} is ${senderIdentity}; reply target ${replyKey ?? "none"} is ${replyIdentity}. Participant first-person claims belong to their actor node, not the agent, unless that actor is the self node.`,
     `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"}` : "",
+    delivery ? `Telegram text delivery raw warning stream: ${delivery.status}; key=${telegramTextDeliveryCapabilityKey({ chatId: input.chatId, messageThreadId: input.messageThreadId })}${delivery.reason ? `; raw=${jsonLine(delivery.reason, 180)}` : ""}` : "Telegram text delivery raw warning stream: none recorded",
+    resolvedReplyMode ? `Resolved reply mode: ${resolvedReplyMode.item.mode} from ${resolvedReplyMode.item.scope} (${resolvedReplyMode.key}); confidence=${resolvedReplyMode.item.confidence.toFixed(2)}${resolvedReplyMode.item.note ? ` note=${jsonLine(resolvedReplyMode.item.note, 120)}` : ""}` : "Resolved reply mode: notes_then_reply (system default)",
     preferences.length ? `Relevant preference vector for ${senderKey3}:
 ${preferences.join("\n")}` : `Relevant preference vector for ${senderKey3}: no durable preferences yet`,
+    scopedPreferences.length ? `Scoped reply preferences:
+${scopedPreferences.join("\n")}` : "",
     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:
@@ -621969,11 +622034,26 @@ ${outcomes.map(formatOutcome).join("\n")}` : "Prior response outcomes: none yet"
 ${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) {
+function resolveReplyModePreferenceForContext(state, chatId, senderKey3) {
+  for (const key of [
+    telegramSocialUserInChatPreferenceKey(chatId, senderKey3),
+    senderKey3,
+    telegramSocialChatPreferenceKey(chatId)
+  ]) {
+    const item = state.preferences[key]?.replyMode;
+    if (item) return { key, item };
+  }
+  return void 0;
+}
+function preferenceLines(vector, prefix) {
   if (!vector) return [];
   return Object.entries(vector).map(([key, evidence]) => {
+    if (key === "replyMode") {
+      const item2 = evidence;
+      return `- ${prefix ? `${prefix}.` : ""}${key}: mode=${item2.mode} scope=${item2.scope} confidence=${item2.confidence.toFixed(2)} evidence=${item2.evidenceMessageIds.join(",") || "none"}${item2.note ? ` note=${jsonLine(item2.note, 120)}` : ""}`;
+    }
     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)}` : ""}`;
+    return `- ${prefix ? `${prefix}.` : ""}${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) {
@@ -622003,6 +622083,7 @@ function createTelegramSocialState(now = Date.now()) {
     participants: {},
     relationships: [],
     preferences: {},
+    deliveryCapabilities: {},
     threads: {},
     salience: [],
     outcomes: [],
@@ -622019,6 +622100,7 @@ function normalizeTelegramSocialState(raw) {
   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.deliveryCapabilities = normalizeRecord(value2.deliveryCapabilities, normalizeDeliveryCapability);
   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) : [];
@@ -622088,9 +622170,55 @@ function normalizePreferences(raw) {
         note: compactOptional(evidence.note, 220)
       };
     }
+    const replyMode = vector["replyMode"];
+    if (replyMode && typeof replyMode === "object" && !Array.isArray(replyMode)) {
+      const record = replyMode;
+      const mode = normalizeReplyMode(record["mode"]);
+      if (mode) {
+        out[actorKey].replyMode = {
+          mode,
+          scope: normalizeReplyPreferenceScope(record["scope"]),
+          confidence: clamp0110(numberOr(record["confidence"], 0.8)),
+          updatedAt: numberOr(record["updatedAt"], Date.now()),
+          evidenceMessageIds: Array.isArray(record["evidenceMessageIds"]) ? record["evidenceMessageIds"].filter(isNumber).slice(-12) : [],
+          note: compactOptional(record["note"], 220),
+          source: compactOptional(record["source"], 80)
+        };
+      }
+    }
   }
   return out;
 }
+function normalizeReplyMode(raw) {
+  return raw === "reply_then_notes" || raw === "notes_then_reply" || raw === "reply_only" ? raw : void 0;
+}
+function normalizeReplyPreferenceScope(raw) {
+  return raw === "chat" || raw === "user_in_chat" || raw === "user" ? raw : "user_in_chat";
+}
+function normalizeDeliveryCapability(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const value2 = raw;
+  const key = compact2(value2.key || "", 180);
+  const chatId = compact2(value2.chatId || "", 120);
+  if (!key || !chatId) return null;
+  const status = normalizeDeliveryStatus(value2.status);
+  return {
+    key,
+    chatId,
+    messageThreadId: typeof value2.messageThreadId === "number" ? value2.messageThreadId : void 0,
+    status,
+    canSendText: typeof value2.canSendText === "boolean" ? value2.canSendText : status === "allowed" ? true : void 0,
+    checkedAt: numberOr(value2.checkedAt, Date.now()),
+    lastSuccessAt: typeof value2.lastSuccessAt === "number" ? value2.lastSuccessAt : void 0,
+    lastFailureAt: typeof value2.lastFailureAt === "number" ? value2.lastFailureAt : void 0,
+    reason: compactOptional(value2.reason, 320),
+    retryAfterSec: typeof value2.retryAfterSec === "number" ? Math.max(0, Math.floor(value2.retryAfterSec)) : void 0,
+    source: compactOptional(value2.source, 80)
+  };
+}
+function normalizeDeliveryStatus(raw) {
+  return raw === "allowed" || raw === "failed" ? raw : "unknown";
+}
 function normalizeThread(raw) {
   if (!raw || typeof raw !== "object") return null;
   const value2 = raw;
@@ -622291,6 +622419,73 @@ function markTelegramDaydreamOpportunitiesConsidered(state, opportunities, messa
   }
   return registered;
 }
+function setTelegramReplyModePreference(state, input) {
+  const now = input.ts ?? Date.now();
+  const actorKey = input.actor ? telegramSocialActorKey(input.actor) : void 0;
+  const key = input.scope === "chat" ? telegramSocialChatPreferenceKey(input.chatId) : input.scope === "user_in_chat" && actorKey ? telegramSocialUserInChatPreferenceKey(input.chatId, actorKey) : actorKey ?? telegramSocialChatPreferenceKey(input.chatId);
+  const vector = state.preferences[key] ?? {};
+  const existing = vector.replyMode;
+  const next = {
+    mode: input.mode,
+    scope: input.scope,
+    confidence: Math.max(existing?.confidence ?? 0, clamp0110(input.confidence ?? 0.84)),
+    updatedAt: now,
+    evidenceMessageIds: appendUnique(existing?.evidenceMessageIds ?? [], input.messageId, 12),
+    note: compactOptional(input.note, 220),
+    source: compactOptional(input.source, 80)
+  };
+  vector.replyMode = next;
+  state.preferences[key] = vector;
+  state.updatedAt = now;
+  return next;
+}
+function resolveTelegramReplyModePreference(state, input) {
+  const actorKey = input.actor ? telegramSocialActorKey(input.actor) : void 0;
+  const keys = [
+    actorKey ? telegramSocialUserInChatPreferenceKey(input.chatId, actorKey) : "",
+    actorKey ?? "",
+    telegramSocialChatPreferenceKey(input.chatId)
+  ].filter(Boolean);
+  for (const key of keys) {
+    const pref = state.preferences[key]?.replyMode;
+    if (!pref) continue;
+    return {
+      key,
+      mode: pref.mode,
+      scope: pref.scope,
+      confidence: pref.confidence,
+      updatedAt: pref.updatedAt,
+      note: pref.note,
+      source: pref.source
+    };
+  }
+  return void 0;
+}
+function setTelegramTextDeliveryCapability(state, input) {
+  const now = input.ts ?? Date.now();
+  const key = telegramTextDeliveryCapabilityKey(input);
+  const existing = state.deliveryCapabilities[key];
+  const canSendText = input.status === "allowed" ? true : input.status === "failed" ? void 0 : input.canSendText ?? existing?.canSendText;
+  const next = {
+    key,
+    chatId: String(input.chatId),
+    messageThreadId: input.messageThreadId,
+    status: input.status,
+    canSendText,
+    checkedAt: now,
+    lastSuccessAt: input.status === "allowed" ? now : existing?.lastSuccessAt,
+    lastFailureAt: input.status === "failed" ? now : existing?.lastFailureAt,
+    reason: compactOptional(input.reason, 320) || existing?.reason,
+    retryAfterSec: input.retryAfterSec,
+    source: compactOptional(input.source, 80)
+  };
+  state.deliveryCapabilities[key] = next;
+  state.updatedAt = now;
+  return next;
+}
+function telegramTextDeliveryCapabilityFor(state, input) {
+  return state.deliveryCapabilities[telegramTextDeliveryCapabilityKey(input)] ?? state.deliveryCapabilities[telegramTextDeliveryCapabilityKey({ chatId: input.chatId })];
+}
 function commitDecisionEdges(state, input, senderKey3, selfKey, now) {
   if (!selfKey) return;
   if (input.shouldReply) {
@@ -622706,6 +622901,28 @@ function telegramDecisionNumber(parsed, keys, nestedKeys = ["internal_notes", "i
   }
   return void 0;
 }
+function parseTelegramReplyMode(raw) {
+  return raw === "reply_then_notes" || raw === "notes_then_reply" || raw === "reply_only" ? raw : void 0;
+}
+function parseTelegramReplyPreferenceToolScope(raw) {
+  return raw === "current_user_in_chat" || raw === "current_user_global" || raw === "current_group" ? raw : void 0;
+}
+function parseTelegramReplyPreferenceUpdate(parsed) {
+  const raw = parsed["reply_mode_preference"] ?? parsed["replyModePreference"] ?? parsed["preference_update"] ?? parsed["preferenceUpdate"];
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+  const record = raw;
+  const replyMode = parseTelegramReplyMode(record["reply_mode"] ?? record["replyMode"] ?? record["mode"]);
+  const scope = parseTelegramReplyPreferenceToolScope(record["scope"]);
+  if (!replyMode || !scope) return void 0;
+  const confidence2 = Number(record["confidence"]);
+  return {
+    scope,
+    replyMode,
+    confidence: Number.isFinite(confidence2) ? Math.max(0, Math.min(1, confidence2)) : void 0,
+    note: cleanTelegramDecisionNote(record["note"] ?? record["reason"] ?? record["rationale"]),
+    source: cleanTelegramDecisionNote(record["source"])
+  };
+}
 function uniqueTelegramJsonCandidates(candidates) {
   const seen = /* @__PURE__ */ new Set();
   const unique = [];
@@ -623048,7 +623265,8 @@ function parseTelegramInteractionDecision(text, forcedRoute, options2 = {}) {
         scenarioLabel: telegramDecisionNote(parsed, ["scenario_label", "scenarioLabel", "label"], ["scenario", "classification"]),
         scenarioConfidence: telegramDecisionNumber(parsed, ["scenario_confidence", "scenarioConfidence", "confidence"], ["scenario", "classification"]),
         scenarioObjective: telegramDecisionNote(parsed, ["scenario_objective", "scenarioObjective", "objective"], ["scenario", "classification"]),
-        scenarioStateLoop: telegramDecisionNote(parsed, ["scenario_state_loop", "scenarioStateLoop", "state_loop", "stateLoop"], ["scenario", "classification"])
+        scenarioStateLoop: telegramDecisionNote(parsed, ["scenario_state_loop", "scenarioStateLoop", "state_loop", "stateLoop"], ["scenario", "classification"]),
+        replyPreferenceUpdate: parseTelegramReplyPreferenceUpdate(parsed)
       };
     } catch {
       continue;
@@ -625273,6 +625491,7 @@ External acquisition contract:
           decision2.voiceNote ? `voice note: ${decision2.voiceNote}` : "",
           decision2.scenarioNote ? `scenario note: ${decision2.scenarioNote}` : "",
           decision2.scenarioId ? `scenario classification: ${decision2.scenarioId}${decision2.scenarioLabel ? ` (${decision2.scenarioLabel})` : ""}` : "",
+          decision2.replyPreferenceUpdate ? `reply preference update: ${decision2.replyPreferenceUpdate.replyMode} (${this.telegramReplyPreferenceScopeLabel(decision2.replyPreferenceUpdate.scope)})` : "",
           cadence ? `next attention sample: ${cadence}` : ""
         ].filter(Boolean);
         if (viewId && this.subAgentViewCallbacks) {
@@ -625293,7 +625512,8 @@ External acquisition contract:
           decision2.procedureNote ? `procedure note: ${decision2.procedureNote}` : "",
           decision2.voiceNote ? `voice note: ${decision2.voiceNote}` : "",
           decision2.scenarioNote ? `scenario note: ${decision2.scenarioNote}` : "",
-          decision2.scenarioId ? `scenario classification: ${decision2.scenarioId}${decision2.scenarioLabel ? ` (${decision2.scenarioLabel})` : ""}` : ""
+          decision2.scenarioId ? `scenario classification: ${decision2.scenarioId}${decision2.scenarioLabel ? ` (${decision2.scenarioLabel})` : ""}` : "",
+          decision2.replyPreferenceUpdate ? `reply preference update: ${decision2.replyPreferenceUpdate.replyMode} (${this.telegramReplyPreferenceScopeLabel(decision2.replyPreferenceUpdate.scope)})` : ""
         ].filter(Boolean);
         this.tuiWrite(() => {
           renderTelegramSubAgentEvent(msg.username, primary);
@@ -625710,6 +625930,7 @@ ${message2}`)
           decision2.voiceNote ? `voice_note: ${decision2.voiceNote}` : "",
           decision2.memoryNote ? `memory_note: ${decision2.memoryNote}` : "",
           decision2.relationshipNote ? `relationship_note: ${decision2.relationshipNote}` : "",
+          decision2.replyPreferenceUpdate ? `reply_preference_update: ${decision2.replyPreferenceUpdate.replyMode} (${this.telegramReplyPreferenceScopeLabel(decision2.replyPreferenceUpdate.scope)})` : "",
           "Use this as classifier output from the prior attention stage, not as a new instruction to spawn or route again."
         ].filter(Boolean).join("\n");
       }
@@ -626515,6 +626736,158 @@ ${mediaContext}` : ""
           repoRoot: this.repoRoot || "."
         };
       }
+      telegramUserPersonalityScope(msg) {
+        const id = msg.fromUserId ? `telegram-user:${msg.fromUserId}` : `telegram-user:${msg.username || msg.firstName || "unknown"}`;
+        const label = `user-${msg.username || msg.firstName || msg.fromUserId || "unknown"}`;
+        return {
+          kind: "telegram-user",
+          id,
+          label,
+          repoRoot: this.repoRoot || "."
+        };
+      }
+      telegramUserInChatPersonalityScope(sessionKey, msg) {
+        const user = msg.fromUserId ? `user:${msg.fromUserId}` : `user:${msg.username || msg.firstName || "unknown"}`;
+        const chat = msg.chatTitle || msg.chatType || String(msg.chatId);
+        return {
+          kind: "telegram-user-in-chat",
+          id: `${sessionKey}:${user}`,
+          label: `${chat}-${msg.username || msg.firstName || msg.fromUserId || "unknown"}`,
+          repoRoot: this.repoRoot || "."
+        };
+      }
+      telegramSocialPreferenceScope(scope) {
+        if (scope === "current_group") return "chat";
+        if (scope === "current_user_global") return "user";
+        return "user_in_chat";
+      }
+      telegramReplyPreferenceScopeLabel(scope) {
+        if (scope === "current_group") return "current group";
+        if (scope === "current_user_global") return "current user globally";
+        return "current user in this group/chat";
+      }
+      scopedPersonalityForReplyPreference(sessionKey, msg, scope) {
+        if (scope === "current_group") return this.telegramPersonalityScope(sessionKey, msg);
+        if (scope === "current_user_global") return this.telegramUserPersonalityScope(msg);
+        return this.telegramUserInChatPersonalityScope(sessionKey, msg);
+      }
+      applyTelegramReplyPreferenceUpdate(sessionKey, msg, update2, source) {
+        if (!update2) return void 0;
+        const preferenceScope = this.telegramSocialPreferenceScope(update2.scope);
+        const evidence = setTelegramReplyModePreference(this.telegramSocialStateForSession(sessionKey), {
+          chatId: msg.chatId,
+          actor: this.telegramMessageSocialActorInput(msg),
+          scope: preferenceScope,
+          mode: update2.replyMode,
+          confidence: update2.confidence,
+          messageId: msg.messageId,
+          note: update2.note,
+          source: update2.source || source
+        });
+        try {
+          updateScopedPersonalityReplyPreference(
+            this.scopedPersonalityForReplyPreference(sessionKey, msg, update2.scope),
+            {
+              mode: update2.replyMode,
+              preferenceScope,
+              confidence: evidence.confidence,
+              evidenceMessageId: msg.messageId,
+              note: update2.note,
+              source: update2.source || source
+            }
+          );
+        } catch {
+        }
+        this.saveTelegramConversationState(sessionKey);
+        return `stored reply_mode=${update2.replyMode} for ${this.telegramReplyPreferenceScopeLabel(update2.scope)}`;
+      }
+      hydrateTelegramReplyPreferencesFromPersona(sessionKey, msg) {
+        for (const [scope, personalityScope] of [
+          ["current_group", this.telegramPersonalityScope(sessionKey, msg)],
+          ["current_user_global", this.telegramUserPersonalityScope(msg)],
+          ["current_user_in_chat", this.telegramUserInChatPersonalityScope(sessionKey, msg)]
+        ]) {
+          try {
+            const pref = loadScopedPersonality(personalityScope).preferences?.replyMode;
+            if (!pref) continue;
+            setTelegramReplyModePreference(this.telegramSocialStateForSession(sessionKey), {
+              chatId: msg.chatId,
+              actor: this.telegramMessageSocialActorInput(msg),
+              scope: pref.scope,
+              mode: pref.mode,
+              confidence: pref.confidence,
+              note: pref.note,
+              source: pref.source || `persona:${scope}`,
+              ts: Number.isFinite(Date.parse(pref.updatedAt)) ? Date.parse(pref.updatedAt) : Date.now()
+            });
+          } catch {
+          }
+        }
+      }
+      resolvedTelegramReplyMode(sessionKey, msg) {
+        try {
+          this.hydrateTelegramReplyPreferencesFromPersona(sessionKey, msg);
+          return resolveTelegramReplyModePreference(this.telegramSocialStateForSession(sessionKey), {
+            chatId: msg.chatId,
+            actor: this.telegramMessageSocialActorInput(msg)
+          })?.mode ?? "notes_then_reply";
+        } catch {
+          return "notes_then_reply";
+        }
+      }
+      stripTelegramDecisionNotes(decision2) {
+        return {
+          ...decision2,
+          silentDisposition: void 0,
+          mentalNote: void 0,
+          memoryNote: void 0,
+          relationshipNote: void 0,
+          procedureNote: void 0,
+          voiceNote: void 0,
+          scenarioNote: void 0,
+          scenarioId: void 0,
+          scenarioLabel: void 0,
+          scenarioConfidence: void 0,
+          scenarioObjective: void 0,
+          scenarioStateLoop: void 0
+        };
+      }
+      telegramTextDeliveryCapability(sessionKey, chatId, messageThreadId) {
+        try {
+          return telegramTextDeliveryCapabilityFor(this.telegramSocialStateForSession(sessionKey), {
+            chatId,
+            messageThreadId
+          });
+        } catch {
+          return void 0;
+        }
+      }
+      updateTelegramTextDeliveryCapability(chatId, input) {
+        const sessionKey = `chat:${String(chatId)}`;
+        try {
+          const capability = setTelegramTextDeliveryCapability(this.telegramSocialStateForSession(sessionKey), {
+            chatId,
+            messageThreadId: input.messageThreadId,
+            status: input.status,
+            canSendText: input.canSendText,
+            reason: input.reason,
+            retryAfterSec: input.retryAfterSec,
+            source: input.source
+          });
+          this.saveTelegramConversationState(sessionKey);
+          return capability;
+        } catch {
+          return void 0;
+        }
+      }
+      formatTelegramDeliveryCapabilityContext(sessionKey, msg) {
+        const capability = this.telegramTextDeliveryCapability(sessionKey, msg.chatId, msg.messageThreadId);
+        if (!capability) return "Telegram text delivery raw warning stream for this chat: none recorded.";
+        return [
+          `Telegram text delivery raw warning stream for this chat: ${capability.status}.`,
+          capability.reason ? `Latest raw Telegram warning/error text: ${capability.reason}` : ""
+        ].filter(Boolean).join(" ");
+      }
       ensureTelegramConversationLoaded(sessionKey) {
         if (this.loadedConversationState.has(sessionKey)) return;
         this.loadedConversationState.add(sessionKey);
@@ -627024,7 +627397,7 @@ ${mediaContext}` : ""
             convertMarkdownToTelegramHTML(decision2.text),
             replyTo
           );
-          this.recordTelegramAssistantMessage({
+          if (sentMessageId !== null) this.recordTelegramAssistantMessage({
             chatId,
             chatType: artifact.chatType,
             chatTitle: artifact.chatTitle,
@@ -627037,6 +627410,7 @@ ${mediaContext}` : ""
             messageId: sentMessageId,
             replyToMessageId: replyTo
           });
+          if (sentMessageId === null) return { sent: false, reason: "Telegram returned no delivered message id" };
           state.lastFollowupAt = now;
           this.saveTelegramConversationState(sessionKey);
           this.tuiWrite(() => renderTelegramSubAgentEvent("reflection", `sent scoped Telegram follow-up (${decision2.confidence.toFixed(2)}): ${decision2.reason}`));
@@ -627127,6 +627501,7 @@ ${mediaContext}` : ""
       buildTelegramSocialStateContext(sessionKey, msg, salienceSignals = []) {
         try {
           this.registerLatestTelegramDaydreamOpportunities(sessionKey);
+          this.hydrateTelegramReplyPreferencesFromPersona(sessionKey, msg);
           return formatTelegramSocialStateContext(this.telegramSocialStateForSession(sessionKey), {
             sessionKey,
             chatId: msg.chatId,
@@ -627255,6 +627630,28 @@ ${mediaContext}` : ""
               msg.chatType !== "private" ? `Group participant ${telegramSpeakerLabel(msg)} in ${msg.chatTitle || "unknown group"}` : `Private Telegram chat with ${telegramSpeakerLabel(msg)}`
             ]
           });
+          updateScopedPersonality(this.telegramUserPersonalityScope(msg), {
+            speaker: telegramSpeakerLabel(msg),
+            text,
+            role: "user",
+            mode,
+            ts: entry.ts,
+            toneTags: inferTelegramToneTags(text),
+            relationshipHints: [
+              `Telegram user identity ${telegramSpeakerLabel(msg)} observed in ${msg.chatType}`
+            ]
+          });
+          updateScopedPersonality(this.telegramUserInChatPersonalityScope(sessionKey, msg), {
+            speaker: telegramSpeakerLabel(msg),
+            text,
+            role: "user",
+            mode,
+            ts: entry.ts,
+            toneTags: inferTelegramToneTags(text),
+            relationshipHints: [
+              msg.chatType !== "private" ? `Participant-specific preference/memory scope for ${telegramSpeakerLabel(msg)} in ${msg.chatTitle || "unknown group"}` : `Participant-specific preference/memory scope for private chat with ${telegramSpeakerLabel(msg)}`
+            ]
+          });
         } catch {
         }
         this.saveTelegramConversationState(sessionKey);
@@ -628986,7 +629383,7 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`,
           routeInstruction,
           ``,
           `Return JSON only with this schema:`,
-          `{"recoverable":true|false,"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","procedure_note":"short tree/procedure note","voice_note":"short final-voice note","scenario_note":"short scenario/transition note","scenario_id":"dynamic inferred scenario id","scenario_label":"human readable dynamic scenario label","scenario_confidence":0.0-1.0,"scenario_objective":"current scenario objective","scenario_state_loop":"state loop to maintain until transition"}`,
+          `{"recoverable":true|false,"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","procedure_note":"short tree/procedure note","voice_note":"short final-voice note","scenario_note":"short scenario/transition note","scenario_id":"dynamic inferred scenario id","scenario_label":"human readable dynamic scenario label","scenario_confidence":0.0-1.0,"scenario_objective":"current scenario objective","scenario_state_loop":"state loop to maintain until transition","reply_mode_preference":null|{"scope":"current_user_in_chat"|"current_user_global"|"current_group","reply_mode":"reply_then_notes"|"notes_then_reply"|"reply_only","confidence":0.0-1.0,"note":"why this durable preference was explicitly expressed"}}`,
           ``,
           `Original router output:`,
           rawPreview,
@@ -629050,7 +629447,7 @@ ${userPrompt.slice(-4e3)}` : userPrompt;
           `Return exactly one JSON object and no prose. No <think> tags. No commentary.`,
           routeInstruction,
           ``,
-          `Required 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","procedure_note":"short tree/procedure note","voice_note":"short final-voice note","scenario_note":"short scenario/transition note","scenario_id":"dynamic inferred scenario id","scenario_label":"human readable dynamic scenario label","scenario_confidence":0.0-1.0,"scenario_objective":"current scenario objective","scenario_state_loop":"state loop to maintain until transition"}`,
+          `Required 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","procedure_note":"short tree/procedure note","voice_note":"short final-voice note","scenario_note":"short scenario/transition note","scenario_id":"dynamic inferred scenario id","scenario_label":"human readable dynamic scenario label","scenario_confidence":0.0-1.0,"scenario_objective":"current scenario objective","scenario_state_loop":"state loop to maintain until transition","reply_mode_preference":null|{"scope":"current_user_in_chat"|"current_user_global"|"current_group","reply_mode":"reply_then_notes"|"notes_then_reply"|"reply_only","confidence":0.0-1.0,"note":"why this durable preference was explicitly expressed"}}`,
           ``,
           `Invalid previous output, for diagnostics only:`,
           invalidPreview,
@@ -629350,6 +629747,7 @@ ${retryText}`,
           `Platform salience signals (context only, not triggers): ${identitySalienceSignals.length ? identitySalienceSignals.join(", ") : "none"}`,
           `Current chat type: ${msg.chatType}`,
           `Current sender: ${telegramSpeakerLabel(msg)} [${telegramActorKindLabel(msg)}]`,
+          this.formatTelegramDeliveryCapabilityContext(sessionKey, msg),
           msg.replyToMessageId ? `Current message replies to message_id ${msg.replyToMessageId}` : "",
           msg.replyToUsername ? `Current message replies to @${msg.replyToUsername}${msg.replyToBot ? " [bot]" : " [human/unknown]"}` : "",
           currentReplyContext,
@@ -629414,7 +629812,7 @@ ${stimulationProbe.context}`,
           `Use the persona docs below as binding behavioral guidance for whether speaking is appropriate and how to avoid over-eager or adversarially bad interventions.`,
           `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,"silent_disposition":"short outcome-level disposition","mental_note":"short outcome-level observation","memory_note":"short memory/summary update","relationship_note":"short relationship/thread note","procedure_note":"short tree/procedure note","voice_note":"short final-voice note","scenario_note":"short scenario/transition note","scenario_id":"dynamic inferred scenario id","scenario_label":"human readable dynamic scenario label","scenario_confidence":0.0-1.0,"scenario_objective":"current scenario objective","scenario_state_loop":"state loop to maintain until transition"}`,
+          `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","procedure_note":"short tree/procedure note","voice_note":"short final-voice note","scenario_note":"short scenario/transition note","scenario_id":"dynamic inferred scenario id","scenario_label":"human readable dynamic scenario label","scenario_confidence":0.0-1.0,"scenario_objective":"current scenario objective","scenario_state_loop":"state loop to maintain until transition","reply_mode_preference":null|{"scope":"current_user_in_chat"|"current_user_global"|"current_group","reply_mode":"reply_then_notes"|"notes_then_reply"|"reply_only","confidence":0.0-1.0,"note":"why this durable preference was explicitly expressed"}}`,
           ``,
           `Route meanings:`,
           `- chat: a short conversational answer can be produced without tools.`,
@@ -629426,6 +629824,8 @@ ${stimulationProbe.context}`,
           `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, relationship_note, procedure_note, voice_note, scenario_note, scenario_id, scenario_label, scenario_confidence, scenario_objective, and scenario_state_loop with concise outcome-level notes for the TUI. Do not expose hidden chain-of-thought; summarize what the bot did with the heard message.`,
+          `Reply-mode preference capture: if and only if the current sender explicitly expresses a durable preference for reply cadence/order, populate reply_mode_preference as a typed update. Do not infer this from style, keywords, tone, or one-off task shape. Use null otherwise.`,
+          `Reply-mode meanings: reply_then_notes means visible reply first and internal notes afterward; notes_then_reply means internal notes before visible reply; reply_only means one user-facing reply with tools/context and no extra internal notes stage.`,
           `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.`,
@@ -630233,6 +630633,11 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`);
           if (replyParameters) body["reply_parameters"] = replyParameters;
           const result = await this.apiCall("sendMessage", body);
           this.state.messagesSent++;
+          this.updateTelegramTextDeliveryCapability(chatId, {
+            status: "allowed",
+            canSendText: true,
+            source: "sendLiveMessage"
+          });
           return result.result?.message_id ?? null;
         } catch {
           try {
@@ -630244,8 +630649,26 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`);
             if (replyParameters) body["reply_parameters"] = replyParameters;
             const result = await this.apiCall("sendMessage", body);
             this.state.messagesSent++;
+            this.updateTelegramTextDeliveryCapability(chatId, {
+              status: "allowed",
+              canSendText: true,
+              source: "sendLiveMessage.plain_fallback"
+            });
             return result.result?.message_id ?? null;
-          } catch {
+          } catch (err) {
+            const errStr = err instanceof Error ? err.message : String(err);
+            this.tuiWrite(() => renderWarning(`Failed to send Telegram live message: ${errStr}`));
+            this.updateTelegramTextDeliveryCapability(chatId, {
+              status: "failed",
+              reason: errStr,
+              source: "sendLiveMessage"
+            });
+            getSoulObservationStream().emit({
+              kind: "telegram.send.failed",
+              sessionKey: String(chatId),
+              reason: errStr,
+              ts: Date.now()
+            });
             return null;
           }
         }
@@ -630480,14 +630903,29 @@ Join: ${newUrl}`);
         } catch (err) {
           decision2 = this.fallbackTelegramRouterDecision(msg, toolContext, err);
         }
-        this.deliverTelegramAttentionDecision(
+        const storedPreference = this.applyTelegramReplyPreferenceUpdate(
           sessionKey,
           msg,
-          attentionViewId,
-          decision2,
-          this.telegramMessageIdentitySalienceSignals(msg),
-          this.markLatestTelegramDaydreamOpportunitiesConsidered(sessionKey, msg)
+          decision2.replyPreferenceUpdate,
+          "telegram-router"
         );
+        if (storedPreference) this.subAgentViewCallbacks?.onWrite(attentionViewId || this.viewIdForMessage(msg), `preference: ${storedPreference}`);
+        const replyMode = this.resolvedTelegramReplyMode(sessionKey, msg);
+        const deliveredDecision = replyMode === "reply_only" ? this.stripTelegramDecisionNotes(decision2) : decision2;
+        const daydreamOpportunities = this.markLatestTelegramDaydreamOpportunitiesConsidered(sessionKey, msg);
+        const shouldDeferNotes = replyMode === "reply_then_notes" && decision2.shouldReply;
+        if (!shouldDeferNotes) {
+          this.deliverTelegramAttentionDecision(
+            sessionKey,
+            msg,
+            attentionViewId,
+            deliveredDecision,
+            this.telegramMessageIdentitySalienceSignals(msg),
+            daydreamOpportunities
+          );
+        } else if (attentionViewId && this.subAgentViewCallbacks) {
+          this.subAgentViewCallbacks.onWrite(attentionViewId, `reply mode: reply_then_notes; internal notes will be committed after visible reply attempt`);
+        }
         this.markLastTelegramUserMessageMode(msg, decision2.shouldReply ? decision2.route : "ambient");
         this.subAgentViewCallbacks?.onWrite(
           this.viewIdForMessage(msg),
@@ -630497,7 +630935,7 @@ Join: ${newUrl}`);
           this.maybeLogTelegramGroupSkip(msg, `live inference: no reply — ${decision2.reason}`);
           return;
         }
-        const decisionContext = this.formatTelegramAttentionDecisionContext(decision2);
+        const decisionContext = this.formatTelegramAttentionDecisionContext(deliveredDecision);
         const existingAfterDecision = this.subAgents.get(sessionKey);
         if (existingAfterDecision && !existingAfterDecision.aborted) {
           this.subAgentViewCallbacks?.onWrite(
@@ -630506,11 +630944,31 @@ Join: ${newUrl}`);
           );
           this.enqueueTelegramSubAgentContext(sessionKey, existingAfterDecision, decisionContext, msg.username);
           await this.enqueueTelegramQueuedSessionWorkForExistingSubAgent(work, existingAfterDecision);
+          if (shouldDeferNotes) {
+            this.deliverTelegramAttentionDecision(
+              sessionKey,
+              msg,
+              attentionViewId,
+              deliveredDecision,
+              this.telegramMessageIdentitySalienceSignals(msg),
+              daydreamOpportunities
+            );
+          }
           return;
         }
         const subAgentProfile = decision2.route === "chat" ? "chat" : "action";
         if (decision2.route === "chat" && msg.chatType === "private") {
           await this.handleTelegramChatCompletion(msg, toolContext, [decisionContext, rapidContext].filter(Boolean).join("\n\n"));
+          if (shouldDeferNotes) {
+            this.deliverTelegramAttentionDecision(
+              sessionKey,
+              msg,
+              attentionViewId,
+              deliveredDecision,
+              this.telegramMessageIdentitySalienceSignals(msg),
+              daydreamOpportunities
+            );
+          }
           return;
         }
         const subAgent = {
@@ -630595,6 +631053,16 @@ Join: ${newUrl}`);
               await this.deleteLiveMessage(msg.chatId, subAgent.liveMessageId).catch(() => {
               });
             }
+            if (shouldDeferNotes) {
+              this.deliverTelegramAttentionDecision(
+                sessionKey,
+                msg,
+                attentionViewId,
+                deliveredDecision,
+                this.telegramMessageIdentitySalienceSignals(msg),
+                daydreamOpportunities
+              );
+            }
             return;
           }
           if (subAgent.liveMessagePromise) {
@@ -630603,16 +631071,30 @@ Join: ${newUrl}`);
           }
           const finalHtml = convertMarkdownToTelegramHTML(finalText);
           const sentMessageId = await this.sendOrEditFinalTelegramHTML(msg, finalHtml, subAgent.liveMessageId);
-          this.recordTelegramAssistantMessage(msg, finalText, subAgentProfile, {
-            messageId: sentMessageId,
-            replyToMessageId: msg.chatType !== "private" ? msg.messageId : void 0
-          });
+          if (sentMessageId !== null || msg.guestQueryId) {
+            this.recordTelegramAssistantMessage(msg, finalText, subAgentProfile, {
+              messageId: sentMessageId,
+              replyToMessageId: msg.chatType !== "private" ? msg.messageId : void 0
+            });
+          } else {
+            this.subAgentViewCallbacks?.onWrite(subAgent.viewId, "Telegram text send returned no delivered message id");
+          }
           await this.sendGeneratedArtifactsFromSubAgent(
             msg,
             subAgent,
             finalText,
             Boolean(subAgent.liveMessageId && !msg.guestQueryId)
           );
+          if (shouldDeferNotes) {
+            this.deliverTelegramAttentionDecision(
+              sessionKey,
+              msg,
+              attentionViewId,
+              deliveredDecision,
+              this.telegramMessageIdentitySalienceSignals(msg),
+              daydreamOpportunities
+            );
+          }
           this.tuiWrite(() => renderTelegramSubAgentComplete(msg.username, finalText));
           this.subAgentViewCallbacks?.onWrite(subAgent.viewId, `completed: ${finalText}`);
           this.subAgentViewCallbacks?.onStatus(subAgent.viewId, "completed");
@@ -630633,6 +631115,16 @@ Join: ${newUrl}`);
             await this.deleteLiveMessage(msg.chatId, subAgent.liveMessageId).catch(() => {
             });
           }
+          if (shouldDeferNotes) {
+            this.deliverTelegramAttentionDecision(
+              sessionKey,
+              msg,
+              attentionViewId,
+              deliveredDecision,
+              this.telegramMessageIdentitySalienceSignals(msg),
+              daydreamOpportunities
+            );
+          }
         } finally {
           this.clearTelegramSubAgentContextBuffer(sessionKey);
           this.subAgents.delete(sessionKey);
@@ -630716,10 +631208,14 @@ Join: ${newUrl}`);
           }
           const finalHtml = convertMarkdownToTelegramHTML(finalText);
           const sentMessageId = await this.sendOrEditFinalTelegramHTML(msg, finalHtml, subAgent.liveMessageId);
-          this.recordTelegramAssistantMessage(msg, finalText, "chat", {
-            messageId: sentMessageId,
-            replyToMessageId: msg.chatType !== "private" ? msg.messageId : void 0
-          });
+          if (sentMessageId !== null || msg.guestQueryId) {
+            this.recordTelegramAssistantMessage(msg, finalText, "chat", {
+              messageId: sentMessageId,
+              replyToMessageId: msg.chatType !== "private" ? msg.messageId : void 0
+            });
+          } else {
+            this.subAgentViewCallbacks?.onWrite(subAgent.viewId, "Telegram text send returned no delivered message id");
+          }
           await this.sendGeneratedArtifactsFromSubAgent(
             msg,
             subAgent,
@@ -630845,10 +631341,14 @@ Join: ${newUrl}`);
           }
           const finalHtml = convertMarkdownToTelegramHTML(cleaned);
           const sentMessageId = await this.sendOrEditFinalTelegramHTML(msg, finalHtml, liveMessageId);
-          this.recordTelegramAssistantMessage(msg, cleaned, "chat", {
-            messageId: sentMessageId,
-            replyToMessageId: msg.chatType !== "private" ? msg.messageId : void 0
-          });
+          if (sentMessageId !== null || msg.guestQueryId) {
+            this.recordTelegramAssistantMessage(msg, cleaned, "chat", {
+              messageId: sentMessageId,
+              replyToMessageId: msg.chatType !== "private" ? msg.messageId : void 0
+            });
+          } else {
+            this.subAgentViewCallbacks?.onWrite(viewId, "Telegram text send returned no delivered message id");
+          }
           this.subAgentViewCallbacks?.onWrite(viewId, `completed: ${cleaned}`);
           this.subAgentViewCallbacks?.onStatus(viewId, "completed");
         } catch (err) {
@@ -631244,6 +631744,7 @@ ${currentTelegramPrompt}`;
             "You have access to isolated per-chat memory (memory_write, memory_read, memory_search) scoped to this conversation.",
             "memory_search may use scope=group/current_chat for this group or scope=user with user_id/username for a participant in this same group. Other groups, admin chats, and private DMs are not accessible here.",
             "You can remember facts about users and retrieve them later. Durable associative memory in the prompt includes participant profiles, relationships, scoped facts, and prior actions retained across days, sessions, and Omnius updates. You also have web_search and web_fetch to look up information.",
+            "If a user explicitly states a durable preference for reply cadence/order, call telegram_preference_set. Do not infer or classify reply-mode preferences from keywords, style, tone, or task type.",
             "You have the full scoped Telegram media-analysis stack by default: telegram_media_recent, image_read, ocr, ocr_image_advanced, vision, pdf_to_text, ocr_pdf, transcribe_file, video_understand, audio_analyze, and identity_memory. For complex textual imagery, screenshots, forms, scans, or dense labels, prefer ocr_image_advanced after resolving media with path='reply' or path='latest'.",
             formatIdentityMemoryContext(chatLabel || "Telegram private chat"),
             reminderToolContract,
@@ -631996,6 +632497,7 @@ Scoped workspace: ${scopedRoot}`,
           new SkillListTool(repoRoot),
           sharedSkillExtractTool,
           this.buildTelegramMediaRecentTool(chatId, msg),
+          this.buildTelegramReplyPreferenceTool(context2, chatId, msg),
           this.buildTelegramTool(context2, repoRoot, chatId, msg),
           ...this.buildTelegramReminderTools(context2, repoRoot, chatId, msg)
         ];
@@ -632061,6 +632563,7 @@ Scoped workspace: ${scopedRoot}`,
           new SkillListTool(repoRoot),
           new SkillExecuteTool(repoRoot),
           adminSkillExtractTool,
+          this.buildTelegramReplyPreferenceTool(context2, chatId, msg),
           this.buildTelegramTool(context2, repoRoot, chatId, msg),
           ...this.buildTelegramReminderTools(context2, repoRoot, chatId, msg),
           fullSubAgentTool,
@@ -632318,8 +632821,9 @@ Scoped workspace: ${scopedRoot}`,
             const text = String(args["text"] || "").trim();
             if (!text) throw new Error("text is required for send_message.");
             if (dryRun) return this.telegramDryRun(action, targetChatId, { text });
-            const sent = await this.sendMessage(targetChatId, text);
-            return { action, telegram_method: "sendMessage", ok: true, chat_id: targetChatId, message_id: sent };
+            const sent = await this.sendMessageDetailed(targetChatId, text);
+            if (!sent.ok) throw new Error(sent.reason || `Telegram send_message ${sent.status}`);
+            return { action, telegram_method: "sendMessage", ok: true, chat_id: targetChatId, message_id: sent.messageId ?? null };
           }
           case "edit_message_text": {
             if (targetChatId === void 0 || messageId === void 0) throw new Error("target/chat_id and message_id are required for edit_message_text.");
@@ -633233,6 +633737,64 @@ Scoped workspace: ${scopedRoot}`,
           resolveMedia: (ref, args) => this.resolveTelegramIdentityMedia(chatId, currentMsg, ref, args)
         });
       }
+      buildTelegramReplyPreferenceTool(_context, _chatId, currentMsg) {
+        const bridge = this;
+        return {
+          name: "telegram_preference_set",
+          description: [
+            "Store an explicitly stated Telegram reply-mode preference for the current user or group.",
+            "Use only when the user directly expresses a durable preference; do not infer from style, tone, keywords, or task type.",
+            "This stores internal behavior preferences only and does not send a Telegram message."
+          ].join(" "),
+          parameters: {
+            type: "object",
+            properties: {
+              scope: {
+                type: "string",
+                enum: ["current_user_in_chat", "current_user_global", "current_group"],
+                description: "Where to store the preference. Default current_user_in_chat for public/group contexts."
+              },
+              reply_mode: {
+                type: "string",
+                enum: ["reply_then_notes", "notes_then_reply", "reply_only"],
+                description: "reply_then_notes = visible reply first, then internal notes; notes_then_reply = internal notes first; reply_only = one reply with tools/context and no extra internal notes stage."
+              },
+              confidence: { type: "number", description: "Confidence that the user explicitly expressed this durable preference, 0.0-1.0." },
+              note: { type: "string", description: "Short evidence/rationale from the user's message." }
+            },
+            required: ["reply_mode"]
+          },
+          async execute(args) {
+            const start2 = performance.now();
+            if (!currentMsg) {
+              return { success: false, output: "", error: "No current Telegram message is available for preference scope.", durationMs: performance.now() - start2 };
+            }
+            const replyMode = parseTelegramReplyMode(args["reply_mode"] ?? args["replyMode"] ?? args["mode"]);
+            if (!replyMode) {
+              return { success: false, output: "", error: "reply_mode must be reply_then_notes, notes_then_reply, or reply_only.", durationMs: performance.now() - start2 };
+            }
+            const scope = parseTelegramReplyPreferenceToolScope(args["scope"]) ?? "current_user_in_chat";
+            const confidenceRaw = Number(args["confidence"]);
+            const update2 = {
+              scope,
+              replyMode,
+              confidence: Number.isFinite(confidenceRaw) ? Math.max(0, Math.min(1, confidenceRaw)) : void 0,
+              note: typeof args["note"] === "string" ? args["note"].trim().slice(0, 220) : void 0,
+              source: "telegram_preference_set"
+            };
+            const sessionKey = bridge.sessionKeyForMessage(currentMsg);
+            const stored = bridge.applyTelegramReplyPreferenceUpdate(sessionKey, currentMsg, update2, "telegram_preference_set");
+            return {
+              success: true,
+              output: stored || `stored reply_mode=${replyMode}`,
+              llmContent: stored || `Stored Telegram reply preference ${replyMode}.`,
+              durationMs: performance.now() - start2,
+              mutated: true,
+              mutatedFiles: []
+            };
+          }
+        };
+      }
       buildTelegramMediaRecentTool(chatId, currentMsg) {
         const bridge = this;
         return {
@@ -633743,17 +634305,25 @@ ${text}`.trim());
       // ── Message sending ───────────────────────────────────────────────────
       /** Send a response back to a Telegram chat (Markdown → HTML conversion) */
       async sendMessage(chatId, text, replyToMessageId, options2 = {}) {
+        const result = await this.sendMessageDetailed(chatId, text, replyToMessageId, options2);
+        return result.messageId ?? null;
+      }
+      async sendMessageDetailed(chatId, text, replyToMessageId, options2 = {}) {
         const extracted = extractMediaReferences(text);
         const mediaRefs = this.filterTelegramMediaReferences(extracted.media, options2);
         const html = convertMarkdownToTelegramHTML(extracted.text);
-        const msgId = extracted.text.trim() ? await this.sendMessageHTML(chatId, html, replyToMessageId, options2) : null;
+        const textResult = extracted.text.trim() ? await this.sendMessageHTMLDetailed(chatId, html, replyToMessageId, options2) : { ok: true, status: "sent", chatId, messageId: null };
         for (const media of mediaRefs) {
           await this.sendMediaReference(chatId, media, { replyToMessageId }).catch(() => null);
         }
-        return msgId;
+        return textResult;
       }
       /** Send an HTML-formatted message to a Telegram chat */
       async sendMessageHTML(chatId, html, replyToMessageId, options2 = {}) {
+        const result = await this.sendMessageHTMLDetailed(chatId, html, replyToMessageId, options2);
+        return result.messageId ?? null;
+      }
+      async sendMessageHTMLDetailed(chatId, html, replyToMessageId, options2 = {}) {
         const extracted = extractMediaReferences(html);
         const mediaRefs = this.filterTelegramMediaReferences(extracted.media, options2);
         const sendHtml = extracted.text || (extracted.media.length > 0 ? "" : html);
@@ -633768,7 +634338,7 @@ ${text}`.trim());
             ).catch(() => null);
             if (sentId === null) sentId = mediaId;
           }
-          return sentId;
+          return { ok: sentId !== null || mediaRefs.length === 0, status: "sent", chatId, messageId: sentId };
         }
         const chunks = splitTelegramMessageText(sendHtml, 3900);
         for (let idx = 0; idx < chunks.length; idx++) {
@@ -633786,6 +634356,11 @@ ${text}`.trim());
             if (result.ok === false) throw new Error(String(result.description || "Telegram sendMessage failed"));
             this.state.messagesSent++;
             if (sentId === null) sentId = result.result?.message_id ?? null;
+            this.updateTelegramTextDeliveryCapability(chatId, {
+              status: "allowed",
+              canSendText: true,
+              source: "sendMessage"
+            });
             getSoulObservationStream().emit({
               kind: "telegram.send.success",
               sessionKey: sessionKeyForObs,
@@ -633801,6 +634376,11 @@ ${text}`.trim());
               if (result.ok === false) throw new Error(String(result.description || "Telegram sendMessage failed"));
               this.state.messagesSent++;
               if (sentId === null) sentId = result.result?.message_id ?? null;
+              this.updateTelegramTextDeliveryCapability(chatId, {
+                status: "allowed",
+                canSendText: true,
+                source: "sendMessage.plain_fallback"
+              });
               getSoulObservationStream().emit({
                 kind: "telegram.send.success",
                 sessionKey: sessionKeyForObs,
@@ -633810,30 +634390,25 @@ ${text}`.trim());
             } catch (err) {
               this.tuiWrite(() => renderWarning(`Failed to send Telegram message: ${err instanceof Error ? err.message : String(err)}`));
               const errStr = err instanceof Error ? err.message : String(err);
-              const lc = errStr.toLowerCase();
-              if (/(not enough rights|forbidden|chat_write_forbidden|user_banned|kicked|chat_admin_required)/.test(lc)) {
-                getSoulObservationStream().emit({
-                  kind: "telegram.send.forbidden",
-                  sessionKey: sessionKeyForObs,
-                  reason: errStr,
-                  ts: Date.now()
-                });
-              } else if (/too many requests|retry after/.test(lc)) {
-                const m2 = lc.match(/retry after (\d+)/);
-                getSoulObservationStream().emit({
-                  kind: "telegram.send.rate_limited",
-                  sessionKey: sessionKeyForObs,
-                  retryAfterSec: m2 ? parseInt(m2[1], 10) : void 0,
-                  ts: Date.now()
-                });
-              }
+              this.updateTelegramTextDeliveryCapability(chatId, {
+                status: "failed",
+                reason: errStr,
+                source: "sendMessage"
+              });
+              getSoulObservationStream().emit({
+                kind: "telegram.send.failed",
+                sessionKey: sessionKeyForObs,
+                reason: errStr,
+                ts: Date.now()
+              });
+              return { ok: false, status: "failed", chatId, messageId: sentId, reason: errStr };
             }
           }
         }
         for (const media of mediaRefs) {
           await this.sendMediaReference(chatId, media).catch(() => null);
         }
-        return sentId;
+        return { ok: sentId !== null, status: "sent", chatId, messageId: sentId };
       }
       filterTelegramMediaReferences(media, options2) {
         const suppress = options2.suppressMedia;

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "omnius",
-  "version": "1.0.157",
+  "version": "1.0.158",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.157",
+      "version": "1.0.158",
       "bundleDependencies": [
         "image-to-ascii"
       ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnius",
-  "version": "1.0.157",
+  "version": "1.0.158",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",