omnius 1.0.80 → 1.0.81

package/dist/index.js

@@ -608034,7 +608034,7 @@ function phaseFromAttention(attention) {
 function parseStimulationPhase(value2) {
   return normalizePhase(value2);
 }
-var DEFAULT_STATE, PHASE_DEFAULTS, PHASE_FLOORS, StimulationController;
+var DEFAULT_STATE, PHASE_MESSAGE_BUDGETS, PHASE_FLOORS, StimulationController;
 var init_stimulation = __esm({
   "packages/cli/src/tui/stimulation.ts"() {
     "use strict";
@@ -608047,11 +608047,11 @@ var init_stimulation = __esm({
       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_MESSAGE_BUDGETS = {
+      idle: 6,
+      cooldown: 4,
+      observing: 2,
+      engaged: 1
     };
     PHASE_FLOORS = {
       idle: 0,
@@ -608082,7 +608082,6 @@ var init_stimulation = __esm({
       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;
@@ -608093,22 +608092,15 @@ var init_stimulation = __esm({
         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;
+        const messageBudget = state.nextAnalysisAfterMessages ?? PHASE_MESSAGE_BUDGETS[state.phase];
+        const shouldAnalyze = !state.lastAnalysisAtMs || metadataStimulus || state.messagesSinceAnalysis >= messageBudget;
         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;
-        }
+        else if (state.messagesSinceAnalysis >= messageBudget) reason = "message-sample";
         this.states.set(input.channelId, cloneState(state));
         return {
           shouldAnalyze,
@@ -608119,7 +608111,6 @@ var init_stimulation = __esm({
       }
       applyAgentDecision(channelId, decision, nowMs = Date.now()) {
         const state = this.stateFor(channelId, nowMs);
-        this.applyTimeDecay(state, nowMs);
         if (Number.isFinite(decision.attentionScore)) {
           state.attention = clamp017(Number(decision.attentionScore));
         } else if (Number.isFinite(decision.attentionDelta)) {
@@ -608135,14 +608126,14 @@ var init_stimulation = __esm({
         }
         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.lastAnalysisAtMs = nowMs;
+        state.messagesSinceAnalysis = 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;
@@ -608164,8 +608155,7 @@ var init_stimulation = __esm({
           `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()}` : ""
+          state.nextAnalysisAfterMessages ? `Agent-requested next check after messages: ${state.nextAnalysisAfterMessages}` : ""
         ].filter(Boolean).join("\n");
       }
       stateFor(channelId, nowMs) {
@@ -608177,15 +608167,6 @@ var init_stimulation = __esm({
           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 = clamp017(state.attention * Math.pow(0.5, halfLives));
-        if (state.phase !== "engaged" || elapsedMs2 > 4 * 6e4) {
-          state.phase = phaseFromAttention(state.attention);
-        }
-      }
     };
   }
 });
@@ -610420,6 +610401,9 @@ function telegramDecisionRecoverableFlag(text) {
   }
   return void 0;
 }
+function telegramRouterTimeoutMs(configTimeoutMs, minMs = 15e3, maxMs = 6e4) {
+  return Math.min(Math.max(configTimeoutMs ?? 3e4, minMs), maxMs);
+}
 function parseTelegramInteractionDecision(text, forcedRoute, options2 = {}) {
   for (const jsonText of telegramDecisionJsonCandidates(text)) {
     try {
@@ -610436,7 +610420,6 @@ function parseTelegramInteractionDecision(text, forcedRoute, options2 = {}) {
       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,
@@ -610448,7 +610431,6 @@ function parseTelegramInteractionDecision(text, forcedRoute, options2 = {}) {
         attentionDelta: Number.isFinite(attentionDeltaRaw) ? Math.max(-1, Math.min(1, attentionDeltaRaw)) : void 0,
         attentionScore: Number.isFinite(attentionScoreRaw) ? Math.max(0, Math.min(1, attentionScoreRaw)) : void 0,
         nextCheckAfterMessages: Number.isFinite(nextMessagesRaw) ? Math.max(1, Math.floor(nextMessagesRaw)) : void 0,
-        nextCheckAfterMs: Number.isFinite(nextMsRaw) ? Math.max(0, Math.floor(nextMsRaw)) : void 0,
         silentDisposition: telegramDecisionNote(parsed, ["silent_disposition", "silentDisposition", "disposition"]),
         mentalNote: telegramDecisionNote(parsed, ["mental_note", "mentalNote", "observation", "insight"]),
         memoryNote: telegramDecisionNote(parsed, ["memory_note", "memoryNote", "memory"]),
@@ -612267,7 +612249,7 @@ External acquisition contract:
       chatAssociativeMemory = /* @__PURE__ */ new Map();
       /** Durable social cognition state by scoped Telegram chat key. */
       chatSocialState = /* @__PURE__ */ new Map();
-      /** Generic chronological attention cadence shared by live surfaces. */
+      /** Generic deliverable/message attention cadence shared by live surfaces. */
       stimulation = new StimulationController();
       /** Throttles noisy "skipped group chatter" waterfall logs */
       groupSkipLogAt = /* @__PURE__ */ new Map();
@@ -612505,13 +612487,13 @@ External acquisition contract:
           decision.attentionScore !== void 0 ? `score=${decision.attentionScore.toFixed(2)}` : ""
         ].filter(Boolean).join(", ");
         const cadence = [
-          decision.nextCheckAfterMessages !== void 0 ? `after ${decision.nextCheckAfterMessages} message(s)` : "",
-          decision.nextCheckAfterMs !== void 0 ? `after ${Math.round(decision.nextCheckAfterMs / 1e3)}s` : ""
+          decision.nextCheckAfterMessages !== void 0 ? `after ${decision.nextCheckAfterMessages} message(s)` : ""
         ].filter(Boolean).join(" or ");
         const lines = [
           `decision: ${route} (${decision.source}, confidence ${decision.confidence.toFixed(2)})`,
           attention ? `attention: ${attention}` : "",
           `reason: ${decision.reason}`,
+          decision.diagnosticNote ? `router diagnostic: ${decision.diagnosticNote}` : "",
           decision.silentDisposition ? `silent disposition: ${decision.silentDisposition}` : "",
           decision.mentalNote ? `mental note: ${decision.mentalNote}` : "",
           decision.memoryNote ? `memory note: ${decision.memoryNote}` : "",
@@ -612528,6 +612510,7 @@ External acquisition contract:
         const route = decision.shouldReply ? `reply via ${decision.route}` : "silent";
         const primary = `attention decision: ${route} (${decision.source}, confidence ${decision.confidence.toFixed(2)}) - ${decision.reason}`;
         const notes2 = [
+          decision.diagnosticNote ? `router diagnostic: ${decision.diagnosticNote}` : "",
           decision.silentDisposition ? `silent reflection: ${decision.silentDisposition}` : "",
           decision.mentalNote ? `mental note: ${decision.mentalNote}` : "",
           decision.memoryNote ? `memory note: ${decision.memoryNote}` : "",
@@ -612535,11 +612518,23 @@ External acquisition contract:
         ].filter(Boolean);
         this.tuiWrite(() => {
           renderTelegramSubAgentEvent(msg.username, primary);
-          for (const note of notes2.slice(0, 4)) {
+          for (const note of notes2.slice(0, 5)) {
             renderTelegramSubAgentEvent(msg.username, note);
           }
         });
       }
+      deliverTelegramAttentionDecision(sessionKey, msg, viewId, decision, salienceSignals, daydreamOpportunities = this.latestTelegramDaydreamOpportunityInputs(sessionKey)) {
+        this.writeTelegramAttentionDecision(viewId, decision);
+        this.mirrorTelegramAttentionDecision(msg, decision);
+        this.commitTelegramSocialDecision(
+          sessionKey,
+          msg,
+          decision,
+          salienceSignals,
+          daydreamOpportunities
+        );
+        this.applyTelegramStimulationDecision(sessionKey, decision);
+      }
       normalizeTelegramCommandText(input) {
         const trimmed = input.trim();
         if (!trimmed.startsWith("/")) return input;
@@ -615408,8 +615403,7 @@ ${lines.join("\n")}`);
           phase: decision.attentionState,
           attentionDelta: decision.attentionDelta,
           attentionScore: decision.attentionScore,
-          nextAnalysisAfterMessages: decision.nextCheckAfterMessages,
-          nextAnalysisAfterMs: decision.nextCheckAfterMs
+          nextAnalysisAfterMessages: decision.nextCheckAfterMessages
         });
       }
       async telegramRouterJsonCompletion(backend, request, diagnostics) {
@@ -615489,7 +615483,7 @@ ${lines.join("\n")}`);
             tools: [],
             temperature: 0,
             maxTokens: 500,
-            timeoutMs: Math.min(Math.max(timeoutMs, 3e3), 8e3),
+            timeoutMs: telegramRouterTimeoutMs(timeoutMs, 8e3, 2e4),
             think: false
           });
           const repairedText = result.choices[0]?.message?.content ?? "";
@@ -615512,8 +615506,8 @@ ${lines.join("\n")}`);
 
 [repaired router decision]
 ${repairedText}`,
-            mentalNote: parsed.mentalNote ?? "router decision recovered from non-JSON model output",
-            memoryNote: parsed.memoryNote ?? "router repair preserved the model-derived attention decision"
+            mentalNote: parsed.mentalNote,
+            memoryNote: parsed.memoryNote
           };
         } catch (err) {
           if (diagnostics) {
@@ -615556,7 +615550,7 @@ ${userPrompt.slice(-4e3)}` : userPrompt;
             tools: [],
             temperature: 0,
             maxTokens: 1200,
-            timeoutMs: Math.min(Math.max(timeoutMs, 5e3), 15e3),
+            timeoutMs: telegramRouterTimeoutMs(timeoutMs, 1e4, 3e4),
             think: false
           });
           const retryText = result.choices[0]?.message?.content ?? "";
@@ -615579,7 +615573,7 @@ ${userPrompt.slice(-4e3)}` : userPrompt;
 
 [strict router retry]
 ${retryText}`,
-            mentalNote: parsed.mentalNote ?? "strict router retry produced a valid attention decision"
+            mentalNote: parsed.mentalNote
           };
         } catch (err) {
           if (diagnostics) {
@@ -615613,9 +615607,8 @@ ${retryText}`,
             reason: "router inference unavailable; no model-derived reply decision",
             source: "inference-unavailable",
             silentDisposition: "retained as context without replying",
-            mentalNote: "router unavailable, so no model-derived attention note was produced"
+            diagnosticNote: "router unavailable; live mental, memory, and relationship notes were not generated"
           };
-          this.applyTelegramStimulationDecision(sessionKey, fallback);
           return fallback;
         }
         const backend = new OllamaAgenticBackend(
@@ -615647,7 +615640,7 @@ ${retryText}`,
           `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.`,
-          `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.`,
+          `Stimulation discipline: also set attention_state, attention_delta, and optional next_check_after_messages. This is a message-deliverable cadence only; do not use elapsed time as an analysis trigger. 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}`,
@@ -615683,8 +615676,8 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
             ],
             tools: [],
             temperature: 0,
-            maxTokens: 700,
-            timeoutMs: Math.min(Math.max(config.timeoutMs ?? 3e4, 5e3), 15e3),
+            maxTokens: 1e3,
+            timeoutMs: telegramRouterTimeoutMs(config.timeoutMs),
             think: false
           }, diagnostics);
           const text = result.choices[0]?.message?.content ?? "";
@@ -615692,7 +615685,6 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
             defaultShouldReply: false
           });
           if (parsed) {
-            this.applyTelegramStimulationDecision(sessionKey, parsed);
             return parsed;
           }
           const repaired = await this.repairTelegramInteractionDecision(
@@ -615703,7 +615695,6 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
             diagnostics
           );
           if (repaired) {
-            this.applyTelegramStimulationDecision(sessionKey, repaired);
             return repaired;
           }
           const strictRetry = await this.retryTelegramInteractionDecisionStrict(
@@ -615715,7 +615706,6 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
             diagnostics
           );
           if (strictRetry) {
-            this.applyTelegramStimulationDecision(sessionKey, strictRetry);
             return strictRetry;
           }
           const invalidRouterPreview = telegramRouterRawPreview(text);
@@ -615727,15 +615717,13 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
             reason: "router output was not valid decision JSON after repair/retry; no model-derived reply decision",
             source: "inference-unavailable",
             silentDisposition: "retained as context without replying because the router decision could not be parsed",
-            // Preserve the well-known mental-note strings (existing tests rely
-            // on them) but append the per-step diagnostic so operators get a
-            // real explanation of what actually failed.
-            mentalNote: (invalidRouterPreview ? "router produced an invalid attention decision payload; repair and strict retry did not recover it" : "router produced an empty attention decision payload; strict retry did not recover it") + (failureNarrative.summary ? ` — ${failureNarrative.summary}` : ""),
-            memoryNote: this.composeTelegramRouterMemoryNote(invalidRouterPreview, failureNarrative.detail),
-            relationshipNote: failureNarrative.relationshipHint,
+            diagnosticNote: this.composeTelegramRouterDiagnosticNote(
+              invalidRouterPreview,
+              failureNarrative,
+              invalidRouterPreview ? "router produced an invalid attention decision payload; repair and strict retry did not recover it" : "router produced an empty attention decision payload; strict retry did not recover it"
+            ),
             raw: text
           };
-          this.applyTelegramStimulationDecision(sessionKey, fallback);
           return fallback;
         } catch (err) {
           const failureNarrative = this.summarizeTelegramRouterFailure(diagnostics);
@@ -615747,19 +615735,20 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
             reason: `router inference failed; no model-derived reply decision (${errMsg.slice(0, 160)})`,
             source: "inference-unavailable",
             silentDisposition: "retained as context without replying",
-            mentalNote: `router failed, so no model-derived attention note was produced` + (failureNarrative.summary ? ` — ${failureNarrative.summary}` : ` — ${errMsg.slice(0, 160)}`),
-            memoryNote: failureNarrative.detail ? `router-failure trace: ${failureNarrative.detail}` : `router-failure trace: ${errMsg.slice(0, 240)}`,
-            relationshipNote: failureNarrative.relationshipHint
+            diagnosticNote: this.composeTelegramRouterDiagnosticNote(
+              void 0,
+              failureNarrative,
+              `router failed before live notes were generated: ${errMsg.slice(0, 160)}`
+            )
           };
-          this.applyTelegramStimulationDecision(sessionKey, fallback);
           return fallback;
         }
       }
       /**
        * Reduce captured per-step diagnostics into:
-       *   - `summary`: a short outcome-level line for the mental note
-       *   - `detail`: a longer ordered trace for the memory note
-       *   - `relationshipHint`: an operational hint (e.g. "ollama backend appears to be injecting <think> tags despite think:false")
+       *   - `summary`: a short outcome-level diagnostic
+       *   - `detail`: a longer ordered trace for operator debugging
+       *   - `operatorHint`: an operational hint (e.g. "ollama backend appears to be injecting <think> tags despite think:false")
        */
       summarizeTelegramRouterFailure(diag) {
         const parts = [];
@@ -615809,24 +615798,26 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
         } else if (diag.strictRetryStatus === "recovered") {
           detailParts.push(`strict-retry: recovered`);
         }
-        let relationshipHint;
+        let operatorHint;
         if (networkErrorSeen) {
-          relationshipHint = "router backend appears unreachable or rate-limited; continued conversation depends on recovery";
+          operatorHint = "router backend appears unreachable or rate-limited; continued conversation depends on recovery";
         } else if (thinkInjectionSuspected) {
-          relationshipHint = "router model emitted <think>-only or unclosed-think output; conversation continuity preserved but inference is degraded";
+          operatorHint = "router model emitted <think>-only or unclosed-think output; conversation continuity preserved but inference is degraded";
         }
         return {
           summary: parts.join("; "),
           detail: detailParts.join("; "),
-          relationshipHint
+          operatorHint
         };
       }
-      composeTelegramRouterMemoryNote(invalidRouterPreview, detail) {
+      composeTelegramRouterDiagnosticNote(invalidRouterPreview, failureNarrative, headline) {
         const segments = [];
+        segments.push(headline);
+        if (failureNarrative.summary) segments.push(failureNarrative.summary);
         if (invalidRouterPreview) segments.push(`invalid router output preview: ${invalidRouterPreview}`);
-        if (detail) segments.push(`router-failure trace: ${detail}`);
-        if (segments.length === 0) return void 0;
-        return segments.join(" | ");
+        if (failureNarrative.detail) segments.push(`router-failure trace: ${failureNarrative.detail}`);
+        if (failureNarrative.operatorHint) segments.push(failureNarrative.operatorHint);
+        return segments.join(" | ").slice(0, 900);
       }
       buildTelegramWorkspaceContext(modelTier, budget = 14e3) {
         if (!this.repoRoot) return "";
@@ -616592,11 +616583,10 @@ Join: ${newUrl}`);
           if (isGroup) {
             const attentionViewId2 = this.registerTelegramAttentionView(msg, existing.toolContext || toolContext, "active Telegram thread");
             const decision2 = await this.inferTelegramInteractionDecision(msg, existing.toolContext || toolContext);
-            this.writeTelegramAttentionDecision(attentionViewId2, decision2);
-            this.mirrorTelegramAttentionDecision(msg, decision2);
-            this.commitTelegramSocialDecision(
+            this.deliverTelegramAttentionDecision(
               sessionKey,
               msg,
+              attentionViewId2,
               decision2,
               this.telegramMessageIdentitySalienceSignals(msg),
               this.markLatestTelegramDaydreamOpportunitiesConsidered(sessionKey, msg)
@@ -616637,11 +616627,10 @@ Join: ${newUrl}`);
         }
         const attentionViewId = this.registerTelegramAttentionView(msg, toolContext);
         const decision = await this.inferTelegramInteractionDecision(msg, toolContext);
-        this.writeTelegramAttentionDecision(attentionViewId, decision);
-        this.mirrorTelegramAttentionDecision(msg, decision);
-        this.commitTelegramSocialDecision(
+        this.deliverTelegramAttentionDecision(
           sessionKey,
           msg,
+          attentionViewId,
           decision,
           this.telegramMessageIdentitySalienceSignals(msg),
           this.markLatestTelegramDaydreamOpportunitiesConsidered(sessionKey, msg)

package/npm-shrinkwrap.json

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

package/package.json

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