omnius 1.0.70 → 1.0.71

package/dist/index.js

@@ -609996,6 +609996,10 @@ function telegramHistoryTime(entry) {
     minute: "2-digit"
   });
 }
+function formatTelegramIdentitySignals(signals) {
+  const unique = [...new Set(signals.map((signal) => signal.trim()).filter(Boolean))];
+  return unique.length > 0 ? unique.join(", ") : "none";
+}
 function summarizeTelegramMessageAttachments(msg) {
   const parts = [];
   if (msg.media) {
@@ -611157,12 +611161,12 @@ Public Telegram runs have the full scoped media-analysis stack for media posted
 - These tools are current-chat scoped. Never inspect arbitrary local files, reveal local paths, or claim access to media outside this Telegram chat scope.
 `.trim();
     GROUP_REPLY_DISCRETION_PROMPT = `
-REPLY DISCRETION: You are in a group chat. The live router has already filtered
-most ambient chatter. Continue to be selective:
-1. Respond when someone directly addresses the bot, replies to the bot, or keeps
-   an active bot-involved task moving.
-2. Stay silent for conversation between other people, third-person commentary
-   about the bot, status chatter, or questions clearly meant for someone else.
+REPLY DISCRETION: You are in a group chat. The live router selected this turn
+using context, attention, and relationship signals. Continue that same approach:
+1. Use the supplied conversation context to decide whether a visible reply is
+   socially appropriate for this specific turn.
+2. Treat direct address, replies, ongoing task continuity, and speaker intent as
+   contextual evidence, not automatic triggers.
 3. Do not reply just because you know an answer or could add color.
 4. Peer bots are labeled as bots in context. Do not reflexively answer bot
    chatter; only continue bot-to-bot exchanges when the message is clearly
@@ -611376,6 +611380,7 @@ External acquisition contract:
       state = {
         active: false,
         botUsername: "",
+        botFirstName: void 0,
         supportsGuestQueries: false,
         canReadAllGroupMessages: false,
         interactionMode: "auto",
@@ -614258,21 +614263,12 @@ ${lines.join("\n")}`);
           activeAgent: this.subAgents.has(sessionKey),
           forceAnalyze: daydreamForceCheck
         });
-        if (isGroup && !stimulationProbe.shouldAnalyze) {
-          return {
-            route: forcedRoute ?? "chat",
-            shouldReply: false,
-            confidence: 0.35,
-            reason: `stimulation cadence held analysis (${stimulationProbe.reason}); context retained`,
-            source: "attention-gated"
-          };
-        }
         if (!config) {
           const fallback2 = {
             route: forcedRoute ?? (isGroup ? "action" : "chat"),
-            shouldReply: !isGroup || addressesBot,
+            shouldReply: false,
             confidence: 0,
-            reason: isGroup ? addressesBot ? "router inference unavailable; Telegram message directly addresses the bot" : "router inference unavailable; public group fails closed without keyword heuristics" : "router inference unavailable; private chat defaults to quick reply",
+            reason: "router inference unavailable; no model-derived reply decision",
             source: "inference-unavailable"
           };
           this.applyTelegramStimulationDecision(sessionKey, fallback2);
@@ -614286,6 +614282,12 @@ ${lines.join("\n")}`);
         const forcedLine = forcedRoute ? `The operator selected Telegram mode "${forcedRoute}". The route field MUST be "${forcedRoute}", but should_reply must still be inferred live from context.` : `The operator selected Telegram mode "auto". Infer route live from context.`;
         const context2 = this.buildTelegramConversationContextStream(sessionKey, msg, isGroup ? 36 : 20);
         const currentReplyContext = this.buildTelegramCurrentReplyContext(sessionKey, msg);
+        const botUsername = this.state.botUsername || "unknown";
+        const botIdentitySignals = [
+          botUsername && botUsername !== "unknown" ? `@${botUsername}` : "",
+          botUsername && botUsername !== "unknown" ? botUsername.replace(/^@/, "") : "",
+          this.state.botFirstName || ""
+        ];
         const userPrompt = [
           `You are the Telegram live routing and reply-discretion model.`,
           `Return JSON only, with no markdown and no explanation outside JSON.`,
@@ -614297,10 +614299,10 @@ ${lines.join("\n")}`);
           `- action: tools, workspace context, media processing, web lookup, delegation, or a multi-step agent loop may be needed.`,
           `Route discipline: greetings, acknowledgements, casual tone/style discussion, and simple conversational questions are chat. Use action only when the message asks you to inspect, create, change, send, remember, search, analyze media, extract text from images/screenshots/forms/scans, name/enroll/identify a person/face/voice from media, or otherwise do tool-backed work.`,
           ``,
-          `Reply discretion: infer from the live thread, speaker relationships, direct platform signals, replies, tone, current message, and any private channel daydream artifact supplied in context. Do not use static keyword rules.`,
-          `Private chats: should_reply is normally true.`,
-          `Group/public chats: default should_reply to false unless the current message clearly addresses the bot, replies to the bot, continues an active bot-involved exchange, assigns the bot work, asks for the bot's view, or is semantically connected to durable memory/current discussion in a way where a concise bot reply is socially useful. Ambient chatter, third-person discussion about the bot, commands meant for a human, or questions among other people are false. Do not set true just because the bot could help.`,
-          `Bot-to-bot discipline: sender labels include [bot] or [human]. Treat peer bots as autonomous actors, not human users. Be more conservative with peer-bot messages unless explicitly addressed, and avoid bot loops by preferring no_reply for repetitive bot chatter.`,
+          `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.`,
+          `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.`,
+          `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.`,
           `Channel daydream discipline: a daydream artifact may highlight relationship signals, unresolved questions, or possible reply opportunities from idle reflection. It can justify analyzing this turn, but it does not force a reply. Reply only if the current user entry makes the intervention timely and socially appropriate.`,
@@ -614308,8 +614310,8 @@ ${lines.join("\n")}`);
           forcedLine,
           ``,
           `Tool context: ${toolContext}`,
-          `Bot username: ${this.state.botUsername || "unknown"}`,
-          `Current message directly addresses this bot: ${addressesBot ? "yes" : "no"}`,
+          `Known self identity signals (context only, not triggers): ${formatTelegramIdentitySignals(botIdentitySignals)}`,
+          `Platform notification/direct-address signal (salience evidence only, not a decision): ${addressesBot ? "yes" : "no"}`,
           `Current chat type: ${msg.chatType}`,
           `Current sender: ${telegramSpeakerLabel(msg)} [${telegramActorKindLabel(msg)}]`,
           msg.replyToMessageId ? `Current message replies to message_id ${msg.replyToMessageId}` : "",
@@ -614318,8 +614320,9 @@ ${lines.join("\n")}`);
           (msg.mentionedUsernames ?? []).length > 0 ? `Current message mentions: ${(msg.mentionedUsernames ?? []).map((name10) => `@${name10}`).join(", ")}` : "",
           msg.media ? `Current message has media: ${summarizeTelegramMessageAttachments(msg)}` : "",
           ``,
-          `Current stimulation state before semantic decision:
+          `Current stimulation state before semantic decision (context only; do not treat cadence as a hard reply filter):
 ${stimulationProbe.context}`,
+          `Stimulation analysis cadence says: ${stimulationProbe.shouldAnalyze ? "analyze-now" : `low-priority sample (${stimulationProbe.reason})`}. You must still make the should_reply decision semantically.`,
           ``,
           context2,
           ``,
@@ -614343,7 +614346,7 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
           });
           const text = result.choices[0]?.message?.content ?? "";
           const parsed = parseTelegramInteractionDecision(text, forcedRoute, {
-            defaultShouldReply: !isGroup
+            defaultShouldReply: false
           });
           if (parsed) {
             this.applyTelegramStimulationDecision(sessionKey, parsed);
@@ -614353,9 +614356,9 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
         }
         const fallback = {
           route: forcedRoute ?? (isGroup ? "action" : "chat"),
-          shouldReply: !isGroup || addressesBot,
+          shouldReply: false,
           confidence: 0,
-          reason: isGroup ? addressesBot ? "router inference failed; Telegram message directly addresses the bot" : "router inference failed; public group fails closed without keyword heuristics" : "router inference failed; private chat defaults to quick reply",
+          reason: "router inference failed; no model-derived reply decision",
           source: "inference-unavailable"
         };
         this.applyTelegramStimulationDecision(sessionKey, fallback);
@@ -614707,6 +614710,7 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`);
         this.state = {
           active: true,
           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),
           canReadAllGroupMessages: me.result?.can_read_all_group_messages === true,
           interactionMode: this.interactionMode,

package/npm-shrinkwrap.json

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

package/package.json

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