omnius 1.0.29 → 1.0.30

package/dist/index.js

@@ -598971,6 +598971,182 @@ ${result.output}`,
   }
 });
 
+// packages/cli/src/tui/stimulation.ts
+function clamp016(value2) {
+  return Math.max(0, Math.min(1, value2));
+}
+function cloneState(state) {
+  return { ...state };
+}
+function normalizePhase(value2) {
+  const raw = String(value2 ?? "").trim().toLowerCase();
+  return raw === "idle" || raw === "observing" || raw === "engaged" || raw === "cooldown" ? raw : void 0;
+}
+function phaseFromAttention(attention) {
+  if (attention >= 0.72) return "engaged";
+  if (attention >= 0.38) return "observing";
+  if (attention >= 0.14) return "cooldown";
+  return "idle";
+}
+function parseStimulationPhase(value2) {
+  return normalizePhase(value2);
+}
+var DEFAULT_STATE, PHASE_DEFAULTS, PHASE_FLOORS, StimulationController;
+var init_stimulation = __esm({
+  "packages/cli/src/tui/stimulation.ts"() {
+    "use strict";
+    DEFAULT_STATE = {
+      phase: "idle",
+      attention: 0,
+      lastStimulusAtMs: 0,
+      messagesSinceAnalysis: 0,
+      messagesSinceAgentOutput: 0,
+      consecutiveNoReply: 0,
+      updatedAtMs: 0
+    };
+    PHASE_DEFAULTS = {
+      idle: { messages: 6, ms: 10 * 6e4 },
+      cooldown: { messages: 4, ms: 5 * 6e4 },
+      observing: { messages: 2, ms: 2 * 6e4 },
+      engaged: { messages: 1, ms: 45e3 }
+    };
+    PHASE_FLOORS = {
+      idle: 0,
+      cooldown: 0.18,
+      observing: 0.45,
+      engaged: 0.78
+    };
+    StimulationController = class {
+      states = /* @__PURE__ */ new Map();
+      getState(channelId) {
+        return cloneState(this.stateFor(channelId, Date.now()));
+      }
+      setState(channelId, state) {
+        if (!state) return;
+        const now = Date.now();
+        this.states.set(channelId, {
+          ...DEFAULT_STATE,
+          ...state,
+          phase: normalizePhase(state.phase) ?? DEFAULT_STATE.phase,
+          attention: clamp016(Number.isFinite(state.attention) ? Number(state.attention) : DEFAULT_STATE.attention),
+          updatedAtMs: Number.isFinite(state.updatedAtMs) ? Number(state.updatedAtMs) : now,
+          lastStimulusAtMs: Number.isFinite(state.lastStimulusAtMs) ? Number(state.lastStimulusAtMs) : now,
+          messagesSinceAnalysis: Math.max(0, Math.floor(Number(state.messagesSinceAnalysis ?? 0))),
+          messagesSinceAgentOutput: Math.max(0, Math.floor(Number(state.messagesSinceAgentOutput ?? 0))),
+          consecutiveNoReply: Math.max(0, Math.floor(Number(state.consecutiveNoReply ?? 0)))
+        });
+      }
+      observe(input) {
+        const now = input.nowMs ?? Date.now();
+        const state = this.stateFor(input.channelId, now);
+        this.applyTimeDecay(state, now);
+        state.lastStimulusAtMs = now;
+        state.updatedAtMs = now;
+        state.messagesSinceAnalysis += 1;
+        state.messagesSinceAgentOutput += 1;
+        const metadataStimulus = input.privateChannel || input.directSignal || input.replyToAgent || input.activeAgent || input.forceAnalyze;
+        if (input.privateChannel) state.attention = Math.max(state.attention, 0.82);
+        if (input.directSignal) state.attention = Math.max(state.attention, 0.76);
+        if (input.replyToAgent) state.attention = Math.max(state.attention, 0.84);
+        if (input.activeAgent) state.attention = Math.max(state.attention, 0.68);
+        state.phase = phaseFromAttention(state.attention);
+        const cadence = PHASE_DEFAULTS[state.phase];
+        const messageBudget = state.nextAnalysisAfterMessages ?? cadence.messages;
+        const timeDue = state.nextAnalysisAtMs !== void 0 ? now >= state.nextAnalysisAtMs : state.lastAnalysisAtMs !== void 0 && now - state.lastAnalysisAtMs >= cadence.ms;
+        const shouldAnalyze = !state.lastAnalysisAtMs || metadataStimulus || state.messagesSinceAnalysis >= messageBudget || timeDue;
+        let reason = "cadence-hold";
+        if (!state.lastAnalysisAtMs) reason = "initial-analysis";
+        else if (input.privateChannel) reason = "private-channel";
+        else if (input.replyToAgent) reason = "reply-to-agent";
+        else if (input.directSignal) reason = "direct-platform-signal";
+        else if (input.activeAgent) reason = "active-agent-thread";
+        else if (state.messagesSinceAnalysis >= messageBudget) reason = "chronological-sample";
+        else if (timeDue) reason = "time-sample";
+        if (shouldAnalyze) {
+          state.lastAnalysisAtMs = now;
+          state.messagesSinceAnalysis = 0;
+        }
+        this.states.set(input.channelId, cloneState(state));
+        return {
+          shouldAnalyze,
+          reason,
+          state: cloneState(state),
+          context: this.formatContext(input.channelId)
+        };
+      }
+      applyAgentDecision(channelId, decision, nowMs = Date.now()) {
+        const state = this.stateFor(channelId, nowMs);
+        this.applyTimeDecay(state, nowMs);
+        if (Number.isFinite(decision.attentionScore)) {
+          state.attention = clamp016(Number(decision.attentionScore));
+        } else if (Number.isFinite(decision.attentionDelta)) {
+          state.attention = clamp016(state.attention + Number(decision.attentionDelta));
+        } else {
+          state.attention = clamp016(state.attention + (decision.shouldReply ? 0.22 : -0.1));
+        }
+        if (decision.phase) {
+          state.attention = Math.max(state.attention, PHASE_FLOORS[decision.phase]);
+          state.phase = decision.phase;
+        } else {
+          state.phase = phaseFromAttention(state.attention);
+        }
+        state.consecutiveNoReply = decision.shouldReply ? 0 : state.consecutiveNoReply + 1;
+        state.nextAnalysisAfterMessages = Number.isFinite(decision.nextAnalysisAfterMessages) ? Math.max(1, Math.floor(Number(decision.nextAnalysisAfterMessages))) : void 0;
+        state.nextAnalysisAtMs = Number.isFinite(decision.nextAnalysisAfterMs) ? nowMs + Math.max(0, Number(decision.nextAnalysisAfterMs)) : void 0;
+        state.updatedAtMs = nowMs;
+        this.states.set(channelId, cloneState(state));
+        return cloneState(state);
+      }
+      recordAgentOutput(channelId, nowMs = Date.now()) {
+        const state = this.stateFor(channelId, nowMs);
+        this.applyTimeDecay(state, nowMs);
+        state.phase = "engaged";
+        state.attention = Math.max(state.attention, 0.78);
+        state.lastAgentOutputAtMs = nowMs;
+        state.messagesSinceAgentOutput = 0;
+        state.consecutiveNoReply = 0;
+        state.updatedAtMs = nowMs;
+        this.states.set(channelId, cloneState(state));
+        return cloneState(state);
+      }
+      formatContext(channelId) {
+        const state = this.stateFor(channelId, Date.now());
+        const sinceAnalysis = state.lastAnalysisAtMs ? `${Math.max(0, Math.round((Date.now() - state.lastAnalysisAtMs) / 1e3))}s` : "never";
+        const sinceAgent = state.lastAgentOutputAtMs ? `${Math.max(0, Math.round((Date.now() - state.lastAgentOutputAtMs) / 1e3))}s` : "never";
+        return [
+          `Stimulation phase: ${state.phase}`,
+          `Attention score: ${state.attention.toFixed(2)}`,
+          `Messages since analysis: ${state.messagesSinceAnalysis}`,
+          `Messages since agent output: ${state.messagesSinceAgentOutput}`,
+          `Consecutive no-reply decisions: ${state.consecutiveNoReply}`,
+          `Last analysis: ${sinceAnalysis}`,
+          `Last agent output: ${sinceAgent}`,
+          state.nextAnalysisAfterMessages ? `Agent-requested next check after messages: ${state.nextAnalysisAfterMessages}` : "",
+          state.nextAnalysisAtMs ? `Agent-requested next check at: ${new Date(state.nextAnalysisAtMs).toISOString()}` : ""
+        ].filter(Boolean).join("\n");
+      }
+      stateFor(channelId, nowMs) {
+        const existing = this.states.get(channelId);
+        if (existing) return cloneState(existing);
+        return {
+          ...DEFAULT_STATE,
+          lastStimulusAtMs: nowMs,
+          updatedAtMs: nowMs
+        };
+      }
+      applyTimeDecay(state, nowMs) {
+        const elapsedMs2 = Math.max(0, nowMs - (state.updatedAtMs || nowMs));
+        if (elapsedMs2 <= 0) return;
+        const halfLives = elapsedMs2 / (12 * 6e4);
+        state.attention = clamp016(state.attention * Math.pow(0.5, halfLives));
+        if (state.phase !== "engaged" || elapsedMs2 > 4 * 6e4) {
+          state.phase = phaseFromAttention(state.attention);
+        }
+      }
+    };
+  }
+});
+
 // packages/cli/src/tui/vision-ingress.ts
 var vision_ingress_exports = {};
 __export(vision_ingress_exports, {
@@ -599143,13 +599319,22 @@ function parseTelegramInteractionDecision(text, forcedRoute, options2 = {}) {
     const confidenceRaw = Number(parsed["confidence"]);
     const confidence = Number.isFinite(confidenceRaw) ? Math.max(0, Math.min(1, confidenceRaw)) : 0;
     const reason = String(parsed["reason"] ?? "live inference decision").slice(0, 240);
+    const attentionDeltaRaw = Number(parsed["attention_delta"] ?? parsed["attentionDelta"]);
+    const attentionScoreRaw = Number(parsed["attention_score"] ?? parsed["attentionScore"]);
+    const nextMessagesRaw = Number(parsed["next_check_after_messages"] ?? parsed["nextCheckAfterMessages"]);
+    const nextMsRaw = Number(parsed["next_check_after_ms"] ?? parsed["nextCheckAfterMs"]);
     return {
       route,
       shouldReply,
       confidence,
       reason,
       source: forcedRoute ? "forced-mode" : "live-inference",
-      raw: text
+      raw: text,
+      attentionState: parseStimulationPhase(parsed["attention_state"] ?? parsed["attentionState"]),
+      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
     };
   } catch {
     return null;
@@ -599982,6 +600167,7 @@ var init_telegram_bridge = __esm({
     init_scoped_personality();
     init_telegram_creative_tools();
     init_omnius_directory();
+    init_stimulation();
     TELEGRAM_SAFETY_PROMPT = `
 CRITICAL SAFETY NOTICE — PUBLIC TELEGRAM CHANNEL
 
@@ -600206,6 +600392,8 @@ Telegram response contract:
       chatParticipants = /* @__PURE__ */ new Map();
       /** Lightweight Zettelkasten-style memory cards by chat/guest session key */
       chatMemoryCards = /* @__PURE__ */ new Map();
+      /** Generic chronological attention cadence shared by live surfaces. */
+      stimulation = new StimulationController();
       /** Throttles noisy "skipped group chatter" waterfall logs */
       groupSkipLogAt = /* @__PURE__ */ new Map();
       /** Telegram interaction routing profile */
@@ -600495,6 +600683,9 @@ Telegram response contract:
           if (Array.isArray(parsed.memoryCards)) {
             this.chatMemoryCards.set(sessionKey, parsed.memoryCards.slice(0, TELEGRAM_MEMORY_CARD_LIMIT));
           }
+          if (parsed.stimulation) {
+            this.stimulation.setState(sessionKey, parsed.stimulation);
+          }
         } catch {
         }
       }
@@ -600528,7 +600719,8 @@ Telegram response contract:
             savedAt: (/* @__PURE__ */ new Date()).toISOString(),
             history: this.chatHistory.get(sessionKey) ?? [],
             participants,
-            memoryCards: this.chatMemoryCards.get(sessionKey) ?? []
+            memoryCards: this.chatMemoryCards.get(sessionKey) ?? [],
+            stimulation: this.stimulation.getState(sessionKey)
           };
           writeFileSync57(this.telegramConversationPath(sessionKey), JSON.stringify(payload, null, 2) + "\n", "utf8");
         } catch {
@@ -600593,6 +600785,7 @@ Telegram response contract:
           chatTitle: msg.chatTitle
         };
         this.recordChatHistory(sessionKey, entry);
+        this.stimulation.recordAgentOutput(sessionKey);
         this.updateTelegramMemoryCards(sessionKey, entry);
         try {
           updateScopedPersonality(this.telegramPersonalityScope(sessionKey, msg), {
@@ -600952,21 +601145,53 @@ ${lines.join("\n")}`);
         if (msg.replyToUsername && msg.replyToUsername.trim().replace(/^@/, "").toLowerCase() === bot) return true;
         return false;
       }
+      telegramMessageRepliesToBot(msg) {
+        const bot = this.state.botUsername.trim().replace(/^@/, "").toLowerCase();
+        return !!bot && !!msg.replyToUsername && msg.replyToUsername.trim().replace(/^@/, "").toLowerCase() === bot;
+      }
+      applyTelegramStimulationDecision(sessionKey, decision) {
+        this.stimulation.applyAgentDecision(sessionKey, {
+          shouldReply: decision.shouldReply,
+          phase: decision.attentionState,
+          attentionDelta: decision.attentionDelta,
+          attentionScore: decision.attentionScore,
+          nextAnalysisAfterMessages: decision.nextCheckAfterMessages,
+          nextAnalysisAfterMs: decision.nextCheckAfterMs
+        });
+      }
       async inferTelegramInteractionDecision(msg, toolContext) {
         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);
-        if (!config) {
+        const sessionKey = this.sessionKeyForMessage(msg);
+        const stimulationProbe = this.stimulation.observe({
+          channelId: sessionKey,
+          privateChannel: !isGroup,
+          directSignal: addressesBot,
+          replyToAgent: this.telegramMessageRepliesToBot(msg),
+          activeAgent: this.subAgents.has(sessionKey)
+        });
+        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,
             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",
             source: "inference-unavailable"
           };
+          this.applyTelegramStimulationDecision(sessionKey, fallback2);
+          return fallback2;
         }
-        const sessionKey = this.sessionKeyForMessage(msg);
         const backend = new OllamaAgenticBackend(
           config.backendUrl,
           config.model,
@@ -600978,16 +601203,17 @@ ${lines.join("\n")}`);
           `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"}`,
+          `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}`,
           ``,
           `Route meanings:`,
           `- chat: a short conversational answer can be produced without tools.`,
           `- 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, or otherwise do tool-backed work.`,
           ``,
-          `Reply discretion: infer from the live thread, speaker relationships, direct mentions, replies, tone, and current message. Do not use static keyword rules.`,
+          `Reply discretion: infer from the live thread, speaker relationships, direct platform signals, replies, tone, and current message. Do not use static keyword rules.`,
           `Private chats: should_reply is normally true.`,
           `Group/public chats: default should_reply to false unless the current message clearly addresses the bot, replies to the bot, continues an active bot-involved exchange, assigns the bot work, or asks for the bot's view. Ambient chatter, third-person discussion about the bot, commands meant for a human, or questions among other people are false. Do not set true just because the bot could help.`,
+          `Stimulation discipline: also set attention_state, attention_delta, and optional next_check_after_messages/next_check_after_ms. These control future analysis cadence only; they do not force a reply. Use engaged for active back-and-forth, observing for likely relevant context, cooldown for recently irrelevant context, and idle for ambient chatter.`,
           forcedLine,
           ``,
           `Tool context: ${toolContext}`,
@@ -600999,6 +601225,9 @@ ${lines.join("\n")}`);
           msg.replyToUsername ? `Current message replies to @${msg.replyToUsername}` : "",
           (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:
+${stimulationProbe.context}`,
           ``,
           context2,
           ``,
@@ -601010,7 +601239,7 @@ ${msg.text}`
             messages: [
               {
                 role: "system",
-                content: "You perform live Telegram route inference. Output strict JSON only."
+                content: "You perform live Telegram route and stimulation inference. Output strict JSON only."
               },
               { role: "user", content: userPrompt }
             ],
@@ -601024,16 +601253,21 @@ ${msg.text}`
           const parsed = parseTelegramInteractionDecision(text, forcedRoute, {
             defaultShouldReply: !isGroup
           });
-          if (parsed) return parsed;
+          if (parsed) {
+            this.applyTelegramStimulationDecision(sessionKey, parsed);
+            return parsed;
+          }
         } catch {
         }
-        return {
+        const fallback = {
           route: forcedRoute ?? (isGroup ? "action" : "chat"),
           shouldReply: !isGroup || addressesBot,
           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",
           source: "inference-unavailable"
         };
+        this.applyTelegramStimulationDecision(sessionKey, fallback);
+        return fallback;
       }
       buildTelegramWorkspaceContext(modelTier, budget = 14e3) {
         if (!this.repoRoot) return "";
@@ -605361,7 +605595,7 @@ __export(voicechat_exports, {
   VoiceChatSession: () => VoiceChatSession
 });
 import { EventEmitter as EventEmitter11 } from "node:events";
-function clamp016(x) {
+function clamp017(x) {
   return x < 0 ? 0 : x > 1 ? 1 : x;
 }
 function alnumRatio(s2) {
@@ -605400,9 +605634,9 @@ function computeSignalFromText(text, confidence) {
   else score = 0.15;
   score -= repeatingCharPenalty(t2) * 0.4;
   if (typeof confidence === "number" && !Number.isNaN(confidence)) {
-    score = 0.7 * score + 0.3 * clamp016(confidence);
+    score = 0.7 * score + 0.3 * clamp017(confidence);
   }
-  return clamp016(score);
+  return clamp017(score);
 }
 function truncateForLog(s2, n2) {
   return s2.length <= n2 ? s2 : s2.slice(0, n2 - 1) + "…";
@@ -605672,7 +605906,7 @@ Rules:
           }, MAX_SEGMENT_MS);
         }
         this.captureBuffer = text;
-        this.lastSignalScore = typeof snr === "number" && !Number.isNaN(snr) ? clamp016(snr) : computeSignalFromText(text, confidence);
+        this.lastSignalScore = typeof snr === "number" && !Number.isNaN(snr) ? clamp017(snr) : computeSignalFromText(text, confidence);
         this.emit("snr", { score: this.lastSignalScore });
         this.onPartialTranscript(text);
         if (this.silenceTimer) clearTimeout(this.silenceTimer);
@@ -612629,7 +612863,7 @@ const $config = writable(null);                     // {endpoint, model, ...}
 const $activeTab = writable('chat');
 
 function parseInitialGuiRoute() {
-  const path = (location.pathname || '/').replace(//+$/, '') || '/';
+  const path = (location.pathname || '/').replace(/\\/+$/, '') || '/';
   const pathToTab = {
     '/chat': 'chat',
     '/agent': 'agent',
@@ -612644,7 +612878,7 @@ function parseInitialGuiRoute() {
   const tab = pathToTab[path] || null;
   let chatSession = null;
   if (tab === 'chat') {
-    const qs = location.search.replace(/^?/, '').trim();
+    const qs = location.search.replace(/^\\?/, '').trim();
     if (qs) {
       try {
         const params = new URLSearchParams(location.search);
@@ -614786,7 +615020,7 @@ function routePathForTab(tab) {
   return map[tab] || '/chat';
 }
 function tabForRoutePath(pathname) {
-  const path = (pathname || '/').replace(//+$/, '') || '/';
+  const path = (pathname || '/').replace(/\\/+$/, '') || '/';
   const map = {
     '/': 'chat',
     '/chat': 'chat',
@@ -614802,7 +615036,7 @@ function tabForRoutePath(pathname) {
   return map[path] || 'chat';
 }
 function chatSessionFromRouteSearch(search) {
-  const qs = String(search || '').replace(/^?/, '').trim();
+  const qs = String(search || '').replace(/^\\?/, '').trim();
   if (!qs) return null;
   try {
     const params = new URLSearchParams(search);
@@ -614854,6 +615088,7 @@ function switchTab(tab, opts) {
     try { loadVoiceTab(); } catch {}
   }
 }
+window.switchTab = switchTab;
 window.addEventListener('popstate', () => {
   const tab = tabForRoutePath(location.pathname);
   if (tab === 'chat') {

package/npm-shrinkwrap.json

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

package/package.json

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