omnius 1.0.60 → 1.0.61

package/dist/index.js

@@ -12159,17 +12159,26 @@ process.on('unhandledRejection', (reason) => {
 
               dlog('COHERE response: ' + _cData.queryId + ' model=' + _cModel + ' tier=' + ['trivial','moderate','complex','expert'][_cTier] + ' ' + _cLatency + 'ms' + (_cReviewed ? ' (reviewed)' : ''));
               // IK-01: Update identity on query success
+              // Store full query + response content; downstream renderers (narrative summary, prompts)
+              // are responsible for compaction. Truncating at write time destroys identity history.
+              // NOTE: '\\n' is double-escaped because this whole block runs inside the
+              // outer DAEMON_SCRIPT template literal — see comment near line 440.
               _updateIdentity({ type: 'query_served', outcome: 1.0, details: {
                 latencyMs: _cLatency, toolsUsed: _cToolsUsed, model: _cModel,
-                summary: (_cData.query || '').slice(0, 60)
+                query: _cData.query || '',
+                response: _cFinalContent || '',
+                summary: (_cData.query || '') + (_cFinalContent ? '\\n→ ' + _cFinalContent : '')
               }});
             } catch (_cErr) {
               dlog('COHERE inference error: ' + (_cErr.message || _cErr));
               _cohereStats.queriesErrors++;
               _saveStats();
               // IK-01: Update identity on query failure
+              // Preserve the full error so post-hoc diagnosis is possible.
               _updateIdentity({ type: 'query_failed', outcome: 0, details: {
-                error: (_cErr.message || String(_cErr)).slice(0, 100), summary: 'inference error'
+                error: (_cErr && _cErr.message) || String(_cErr),
+                query: _cData.query || '',
+                summary: 'inference error: ' + ((_cErr && _cErr.message) || String(_cErr))
               }});
             }
           } catch (_cParseErr) {
@@ -593168,12 +593177,16 @@ sleep 1
           return "handled";
         }
         if (requested !== "auto" && requested !== "chat" && requested !== "action") {
-          renderWarning("Usage: /telegram mode auto|chat|action [--local]");
+          renderWarning("Usage: /telegram mode auto|chat|action [--global]");
           return "handled";
         }
-        ctx3.saveTelegramSettings?.({ mode: requested, local: isLocal });
+        const hasGlobalFlagMode = parts.includes("--global");
+        const projectRootMode = ctx3.repoRoot || process.cwd();
+        const projectHasOmniusMode = existsSync100(join114(projectRootMode, ".omnius"));
+        const wantsLocalMode = hasGlobalFlagMode ? false : isLocal || projectHasOmniusMode;
+        ctx3.saveTelegramSettings?.({ mode: requested, local: wantsLocalMode });
         ctx3.telegramSetInteractionMode?.(requested);
-        renderInfo(`Telegram interaction mode set to ${c3.bold(requested)}${isLocal ? " (project)" : " (global)"}.`);
+        renderInfo(`Telegram interaction mode set to ${c3.bold(requested)}${wantsLocalMode ? " (project)" : " (global)"}.`);
         return "handled";
       }
       if (parts[0] === "auth" || parts[0] === "authenticate") {
@@ -593420,18 +593433,23 @@ sleep 1
       }
       const keyIdx = parts.indexOf("--key");
       const adminIdx = parts.indexOf("--admin");
+      const hasGlobalFlag = parts.includes("--global");
+      const projectRoot = ctx3.repoRoot || process.cwd();
+      const projectHasOmnius = existsSync100(join114(projectRoot, ".omnius"));
+      const wantsLocal = hasGlobalFlag ? false : isLocal || projectHasOmnius;
       if (keyIdx !== -1 || adminIdx !== -1) {
         const settings = {
-          local: isLocal
+          local: wantsLocal
         };
-        const scope = isLocal ? "project" : "global";
+        const scope = wantsLocal ? "project" : "global";
         if (keyIdx !== -1) {
           const token = parts[keyIdx + 1];
           if (!token || token.startsWith("--")) {
             renderWarning(
-              "Usage: /telegram --key <bot-token> [--admin <id>] [--local]"
+              "Usage: /telegram --key <bot-token> [--admin <id>] [--global]"
             );
             renderInfo("Get a bot token from @BotFather on Telegram.");
+            renderInfo("Default scope: project-local when .omnius/ exists; use --global to override.");
             return "handled";
           }
           settings.key = token;
@@ -593440,7 +593458,7 @@ sleep 1
           const userId = parts[adminIdx + 1];
           if (!userId || userId.startsWith("--")) {
             renderWarning(
-              "Usage: /telegram --admin <user-id-or-username> [--key <token>] [--local]"
+              "Usage: /telegram --admin <user-id-or-username> [--key <token>] [--global]"
             );
             return "handled";
           }
@@ -593455,6 +593473,11 @@ sleep 1
           renderInfo(
             `Telegram admin set to ${c3.bold(settings.admin)} (${scope}).`
           );
+        if (wantsLocal && !projectHasOmnius) {
+          renderWarning(
+            "No .omnius/ in the current directory; this 'local' setting was written to ./.omnius/settings.json and only applies when omnius is invoked from this folder."
+          );
+        }
         if (!ctx3.isTelegramActive?.() && settings.key)
           renderInfo("Use /telegram to start.");
         return "handled";
@@ -593468,9 +593491,30 @@ sleep 1
         if (!settings.key) {
           renderWarning("No Telegram bot token configured.");
           renderInfo("Set one first: /telegram --key <bot-token>");
-          renderInfo("Get a token from @BotFather on Telegram.");
+          renderInfo("Get a token from @BotFather on Telegram. The token saves project-locally by default when .omnius/ exists.");
           return "handled";
         }
+        try {
+          const startProjectRoot = ctx3.repoRoot || process.cwd();
+          if (existsSync100(join114(startProjectRoot, ".omnius"))) {
+            const projectSettingsPath = join114(startProjectRoot, ".omnius", "settings.json");
+            let projectHasKey = false;
+            if (existsSync100(projectSettingsPath)) {
+              try {
+                const projectJson = JSON.parse(readFileSync81(projectSettingsPath, "utf8"));
+                projectHasKey = typeof projectJson?.telegramKey === "string" && projectJson.telegramKey.length > 0;
+              } catch {
+              }
+            }
+            if (!projectHasKey) {
+              renderWarning(
+                "Using GLOBAL Telegram token in a project that has no local key. Another omnius instance running with the same token will steal getUpdates and you'll see 409 conflicts."
+              );
+              renderInfo("Scope it locally: /telegram --key <token> (writes to ./.omnius/settings.json)");
+            }
+          }
+        } catch {
+        }
         try {
           await ctx3.telegramStart?.(settings.key, settings.admin);
         } catch (err) {
@@ -593482,8 +593526,8 @@ sleep 1
       }
       renderWarning(`Unknown argument: "${arg}"`);
       renderInfo("Usage:");
-      renderInfo("  /telegram --key <token>   Save bot token (global)");
-      renderInfo("  /telegram --admin <id>    Set admin filter (global)");
+      renderInfo("  /telegram --key <token>   Save bot token (project-local when .omnius/ exists)");
+      renderInfo("  /telegram --admin <id>    Set admin filter (project-local by default)");
       renderInfo("  /telegram                 Toggle on/off");
       renderInfo("  /telegram stop            Stop bridge");
       renderInfo("  /telegram status          Show status");
@@ -593502,7 +593546,7 @@ sleep 1
       renderInfo("  /telegram delete-messages <chat> <msg,msg> [reason]  Delete multiple messages");
       renderInfo("  /telegram delete-reaction <chat> <msg> --user <id>  Delete a reaction");
       renderInfo("  /telegram delete-reactions <chat> --user <id>  Delete recent reactions");
-      renderInfo("  Add --local to scope settings to this project only");
+      renderInfo("  Add --global to write to ~/.omnius/ (shared across all omnius instances)");
       return "handled";
     }
     case "platforms":
@@ -610944,6 +610988,12 @@ External acquisition contract:
       /** Durable SQLite mirror for raw Telegram messages and metadata. */
       telegramSqlitePath;
       telegramSqliteDb = null;
+      /**
+       * Per-bot ownership lockfile under .omnius/telegram-runner-state/.
+       * Prevents two omnius instances from polling the same bot token concurrently
+       * (which would cause silent 409 conflicts on getUpdates). Released in stop().
+       */
+      telegramOwnerLockFile = null;
       /** Session keys loaded from persistent conversation memory */
       loadedConversationState = /* @__PURE__ */ new Set();
       /** True once persisted Telegram conversation scopes have been bulk-loaded. */
@@ -611775,10 +611825,19 @@ ${mediaContext}` : ""
             }
             this.chatParticipants.set(sessionKey, participants);
           }
-          if (Array.isArray(parsed.memoryCards)) {
+          const cardsLookTruncated = Array.isArray(parsed.memoryCards) && parsed.memoryCards.some((card) => Array.isArray(card.notes) && card.notes.some((note) => typeof note === "string" && note.endsWith("...")));
+          if (Array.isArray(parsed.memoryCards) && !cardsLookTruncated) {
             this.chatMemoryCards.set(sessionKey, parsed.memoryCards.slice(0, TELEGRAM_MEMORY_CARD_LIMIT));
+          } else if (loadedHistory.length > 0) {
+            this.chatMemoryCards.set(sessionKey, []);
+            for (const entry of loadedHistory) {
+              this.updateTelegramMemoryCards(sessionKey, entry);
+            }
           }
-          if (parsed.associativeMemory) {
+          const associativeLooksTruncated = parsed.associativeMemory && Array.isArray(parsed.associativeMemory.facts) && parsed.associativeMemory.facts.some(
+            (fact) => typeof fact?.text === "string" && fact.text.endsWith("...")
+          );
+          if (parsed.associativeMemory && !associativeLooksTruncated) {
             this.chatAssociativeMemory.set(
               sessionKey,
               this.normalizeTelegramAssociativeMemory(parsed.associativeMemory)
@@ -612488,14 +612547,14 @@ ${mediaContext}` : ""
         profile.fromUserId = msg.fromUserId || profile.fromUserId;
         profile.messageCount += 1;
         profile.lastSeenTs = Date.now();
-        profile.lastMessage = truncateTelegramContextLine(text, 220);
+        profile.lastMessage = stripTelegramHiddenThinking(text).replace(/\s+/g, " ").trim();
         if (msg.replyToMessageId) profile.replyCount += 1;
         if (this.state.botUsername && text.toLowerCase().includes(`@${this.state.botUsername.toLowerCase()}`)) {
           profile.directAddressCount += 1;
         }
         for (const tag of inferTelegramToneTags(text)) profile.toneTags.add(tag);
         if (text.trim()) {
-          profile.samples.push(truncateTelegramContextLine(text, 160));
+          profile.samples.push(stripTelegramHiddenThinking(text).replace(/\s+/g, " ").trim());
           if (profile.samples.length > TELEGRAM_CONTEXT_SAMPLE_LIMIT) {
             profile.samples.splice(0, profile.samples.length - TELEGRAM_CONTEXT_SAMPLE_LIMIT);
           }
@@ -612516,7 +612575,7 @@ ${mediaContext}` : ""
             role: entry.role,
             speaker,
             mode: entry.mode,
-            text: truncateTelegramContextLine(entry.text, 900),
+            text: stripTelegramHiddenThinking(entry.text || "").replace(/\s+/g, " ").trim(),
             messageId: entry.messageId,
             replyToMessageId: entry.replyToMessageId,
             userId: entry.fromUserId,
@@ -612566,7 +612625,7 @@ ${mediaContext}` : ""
             if (!userMemory.toneTags.includes(tag)) userMemory.toneTags.push(tag);
           }
           userMemory.toneTags = userMemory.toneTags.slice(0, 20);
-          const compact2 = truncateTelegramContextLine(entry.text, 240);
+          const compact2 = stripTelegramHiddenThinking(entry.text || "").replace(/\s+/g, " ").trim();
           if (compact2) {
             userMemory.lastMessages.push(compact2);
             userMemory.lastMessages = userMemory.lastMessages.slice(-40);
@@ -612582,7 +612641,7 @@ ${mediaContext}` : ""
           }
           if (entry.replyContext?.sender || entry.replyToMessageId) {
             const target = entry.replyContext?.sender ? telegramReplySenderLabel(entry.replyContext.sender) : `message ${entry.replyToMessageId}`;
-            const hint = `${speaker} replied to ${target}: ${truncateTelegramContextLine(entry.text, 180)}`;
+            const hint = `${speaker} replied to ${target}: ${stripTelegramHiddenThinking(entry.text || "").replace(/\s+/g, " ").trim()}`;
             if (!userMemory.relationshipHints.includes(hint)) {
               userMemory.relationshipHints.push(hint);
               userMemory.relationshipHints = userMemory.relationshipHints.slice(-80);
@@ -612600,7 +612659,7 @@ ${mediaContext}` : ""
       }
       extractTelegramAssociativeFacts(entry, speaker) {
         if (entry.role !== "user") return [];
-        const text = truncateTelegramContextLine(entry.text, 500);
+        const text = stripTelegramHiddenThinking(entry.text || "").replace(/\s+/g, " ").trim();
         const facts = /* @__PURE__ */ new Set();
         const patterns = [
           /\b(?:remember|note|keep in mind|for future reference)\s+(?:that\s+)?(.{4,260})/i,
@@ -612621,7 +612680,7 @@ ${mediaContext}` : ""
         return [...facts].slice(0, 8);
       }
       upsertTelegramAssociativeFact(facts, text, entry, speaker, weight = 1) {
-        const clean5 = truncateTelegramContextLine(text, 500);
+        const clean5 = stripTelegramHiddenThinking(text || "").replace(/\s+/g, " ").trim();
         const key = clean5.toLowerCase();
         const now = entry.ts ?? Date.now();
         let fact = facts.find((item) => item.text.toLowerCase() === key);
@@ -612658,7 +612717,7 @@ ${mediaContext}` : ""
         return fact;
       }
       updateTelegramMemoryCards(sessionKey, entry) {
-        const text = truncateTelegramContextLine(entry.text, 500);
+        const text = stripTelegramHiddenThinking(entry.text || "").replace(/\s+/g, " ").trim();
         if (!text || text.length < 3) return;
         const speaker = telegramHistorySpeaker(entry);
         const tags = telegramMemoryTags(text, entry.mediaSummary);
@@ -612867,6 +612926,61 @@ ${lines.join("\n")}`);
           lines.join("\n")
         ].join("\n");
       }
+      /**
+       * Always-on episodic memory recall for the active Telegram session.
+       * Pulls scored episodes from .omnius/episodes.db where session_id = sessionKey,
+       * including social / tool_result / reflection modalities. This surfaces day-old
+       * context the rolling 36-turn window has already shed.
+       */
+      relevantTelegramEpisodicMemoryContext(sessionKey, msg, limit = 8) {
+        if (!this.repoRoot) return "";
+        const paths = omniusMemoryDbPaths(this.repoRoot);
+        if (!existsSync112(paths.episodes)) return "";
+        let episodes = [];
+        const graph = new TemporalGraph(paths.knowledge);
+        const store2 = new EpisodeStore(paths.episodes, graph);
+        try {
+          const recent = store2.search({ sessionId: sessionKey, limit: Math.max(limit * 3, 24) }) ?? [];
+          const queryText = (msg.text || "").toLowerCase().trim();
+          if (queryText.length > 3) {
+            const qTokens = queryText.split(/\s+/).filter((t2) => t2.length >= 4);
+            const scored = recent.map((ep) => {
+              const content = String(ep.content || "").toLowerCase();
+              const hits = qTokens.filter((t2) => content.includes(t2)).length;
+              return { ep, score: hits };
+            }).sort((a2, b) => b.score - a2.score || b.ep.timestamp - a2.ep.timestamp);
+            episodes = scored.slice(0, limit).map((s2) => s2.ep);
+          } else {
+            episodes = recent.slice(0, limit);
+          }
+        } catch {
+          return "";
+        } finally {
+          try {
+            store2.close();
+          } catch {
+          }
+          try {
+            graph.close();
+          } catch {
+          }
+        }
+        if (episodes.length === 0) return "";
+        const lines = episodes.map((ep) => {
+          const when = ep.timestamp ? new Date(ep.timestamp).toISOString() : "";
+          const meta = ep.metadata || {};
+          const tg = meta.telegram && typeof meta.telegram === "object" ? meta.telegram : {};
+          const speaker = tg.speaker || tg.username || (ep.modality === "tool_result" ? `tool:${ep.toolName || "?"}` : "agent");
+          const mode = tg.mode ? `/${tg.mode}` : "";
+          const text = ep.gist || ep.content;
+          return `- ${when} ${speaker}${mode} [${ep.modality}]: ${telegramContextJsonString(String(text || ""), 260)}`;
+        });
+        return [
+          "### Episodic Memory Recall (durable, day+ scope)",
+          "Scored episodes for this Telegram session from episodes.db. These are PERSISTENT across restarts and survive the rolling-context window. Treat as canonical for older facts.",
+          lines.join("\n")
+        ].join("\n");
+      }
       telegramSqliteHistoryForSession(sessionKey, limit = 1e3) {
         const db = this.telegramDb();
         if (!db) return [];
@@ -613047,6 +613161,17 @@ ${participantLines.join("\n")}`);
         if (sqliteMirrorContext) {
           sections.push(sqliteMirrorContext);
         }
+        try {
+          const episodicContext = this.relevantTelegramEpisodicMemoryContext(
+            sessionKey,
+            msg,
+            isGroup ? 10 : 6
+          );
+          if (episodicContext) {
+            sections.push(episodicContext);
+          }
+        } catch {
+        }
         const memoryCards = this.relevantTelegramMemoryCards(sessionKey, msg, isGroup ? 10 : 6);
         if (memoryCards.length > 0) {
           const cardLines = memoryCards.map(({ card, score }) => {
@@ -613613,6 +613738,40 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`);
         if (!me?.ok) {
           throw new Error(`Invalid Telegram bot token: ${me?.description || "unknown error"}`);
         }
+        if (this.repoRoot && me.result?.id) {
+          try {
+            const lockDir = resolve43(this.repoRoot, ".omnius", "telegram-runner-state");
+            mkdirSync65(lockDir, { recursive: true });
+            const lockFile = join127(lockDir, `bot-${me.result.id}.owner.lock`);
+            if (existsSync112(lockFile)) {
+              try {
+                const prior = JSON.parse(readFileSync92(lockFile, "utf8"));
+                const priorAlive = typeof prior.pid === "number" && prior.pid !== process.pid ? this.processIsAlive(prior.pid) : false;
+                if (priorAlive) {
+                  throw new Error(
+                    `Telegram bot @${prior.botUsername || me.result.username || "unknown"} is already being polled by pid ${prior.pid} (cwd ${prior.cwd || "?"}). Stop that instance or use a different bot token in this project.`
+                  );
+                }
+              } catch (e2) {
+                if (e2 instanceof Error && e2.message.startsWith("Telegram bot @")) throw e2;
+              }
+            }
+            writeFileSync59(
+              lockFile,
+              JSON.stringify({
+                pid: process.pid,
+                cwd: this.repoRoot,
+                botUsername: me.result.username,
+                botUserId: me.result.id,
+                ts: Date.now()
+              }, null, 2),
+              { encoding: "utf-8", mode: 384 }
+            );
+            this.telegramOwnerLockFile = lockFile;
+          } catch (e2) {
+            if (e2 instanceof Error && e2.message.startsWith("Telegram bot @")) throw e2;
+          }
+        }
         this.state = {
           active: true,
           botUsername: me.result?.username ?? "unknown",
@@ -613663,10 +613822,33 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`);
           }
           this.telegramSqliteDb = null;
         }
+        if (this.telegramOwnerLockFile) {
+          try {
+            if (existsSync112(this.telegramOwnerLockFile)) {
+              unlinkSync22(this.telegramOwnerLockFile);
+            }
+          } catch {
+          }
+          this.telegramOwnerLockFile = null;
+        }
         this.subAgents.clear();
         this.activeChatViews.clear();
         this.refreshActiveTelegramInteractionCount();
       }
+      /**
+       * Cheap liveness probe: kill(pid, 0) throws ESRCH when the process is dead
+       * and EPERM when it exists but we can't signal it (still alive from our POV).
+       */
+      processIsAlive(pid) {
+        if (!pid || !Number.isFinite(pid)) return false;
+        try {
+          process.kill(pid, 0);
+          return true;
+        } catch (e2) {
+          if (e2 && e2.code === "EPERM") return true;
+          return false;
+        }
+      }
       // ── Typing indicator ──────────────────────────────────────────────────
       /** Start sending "typing" indicator every 4 seconds */
       startTypingIndicator(chatId) {
@@ -648230,7 +648412,9 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
         ...settings.admin !== void 0 ? { telegramAdmin: settings.admin } : {},
         ...settings.mode !== void 0 ? { telegramMode: settings.mode } : {}
       };
-      if (settings.local) {
+      const projectHasOmnius = existsSync127(join143(repoRoot, ".omnius"));
+      const useProject = settings.local === true || settings.local === void 0 && projectHasOmnius;
+      if (useProject) {
         saveProjectSettings(repoRoot, payload);
       } else {
         saveGlobalSettings(payload);

package/npm-shrinkwrap.json

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

package/package.json

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