@ouro.bot/cli 0.1.0-alpha.820 → 0.1.0-alpha.822

package/changelog.json

@@ -1,6 +1,19 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.822",
+      "changes": [
+        "Suppress a proactive Telegram message that repeats a recent one apart from its clock reading.",
+        "Evict the repetition guard's oldest entry in insertion order, removing a comparison branch monotonic time could never take."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.821",
+      "changes": [
+        "Show a typing indicator while the Butler works a Telegram turn, and drop the honesty-announcing reply opener."
+      ]
+    },
     {
       "version": "0.1.0-alpha.820",
       "changes": [

package/deploy/unraid/sanctuary.ouro/bundle-meta.json

@@ -1,5 +1,5 @@
 {
-  "runtimeVersion": "0.1.0-alpha.820",
+  "runtimeVersion": "0.1.0-alpha.822",
   "bundleSchemaVersion": 3,
   "lastUpdated": "2026-09-03T00:00:00.000Z"
 }

package/deploy/unraid/sanctuary.ouro/psyche/TACIT.md

@@ -5,7 +5,9 @@
 - Keep approved household contact reactive or request-bound. Only Ari receives unrelated proactive household attention.
 - Treat an intentionally offline service as healthy when that matches the current desired state.
 - For Ari's whole-household status questions, read current evidence before answering and separate active work, waiting on Ari, snoozed wake times, intentionally quiet services, healthy systems, and other current issues. Do not narrate daemon, event-queue, provider-lane, or backend service internals; translate them into compact household outcomes only when they are currently relevant.
-- For household media questions, use the restricted catalog read when it is available. Answer like a tasteful steward of the shelf: pick, recommend, compare, or confirm from current evidence without volunteering an AI or `I cannot watch` disclaimer.
+- For household media questions, use the media tools when they are available and the restricted catalog read otherwise. Answer like a tasteful steward of the shelf: pick, recommend, compare, or confirm from current evidence without volunteering an AI or `I cannot watch` disclaimer.
+- Check shelf state before naming a title. Never suggest going to find something that is already here, and never name a title the current search did not return.
+- Do not open a reply by announcing its honesty. Say the true thing plainly; `Honest:`, `Honest answer:`, and `To be honest` add nothing and read as apology. Report a limit once, without ceremony, and never in place of an answer that the tools can actually give.
 - Never touch array/parity/disk configuration, permissions, network/security settings, or `/mnt/user` paths.
 - Never send server data off-box or enter credentials into another system.
 - When state is ambiguous, investigate safely, say what is known, and ask only if the answer changes the next safe move.

package/deploy/unraid/sanctuary.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0"?>
 <Container version="2">
   <Name>ouro-butler</Name>
-  <Repository>ghcr.io/ourostack/ouroboros-butler:0.1.0-alpha.820</Repository>
+  <Repository>ghcr.io/ourostack/ouroboros-butler:0.1.0-alpha.822</Repository>
   <Registry>https://github.com/ourostack/ouroboros/pkgs/container/ouroboros-butler</Registry>
   <Network>host</Network>
   <Shell>sh</Shell>

package/dist/heart/daemon/sanctuary-telegram-authority-service.js

@@ -237,6 +237,21 @@ class SanctuaryTelegramAuthorityService {
                     throw new Error("Sanctuary Telegram callback body is invalid");
                 }
             }
+            else if (requestMethod === "sendChatAction") {
+                // A typing indicator is ephemeral and carries no content, so it is admitted
+                // for chats the agent may already message — but only as "typing", and only
+                // with the two fields that action needs, so it cannot become a side channel.
+                if (!exactBody(body, ["chat_id", "action"])) {
+                    throw new Error("Sanctuary Telegram chat action is invalid");
+                }
+                if (body.action !== "typing") {
+                    throw new Error("Sanctuary Telegram chat action is invalid");
+                }
+                const actionChatId = String(body.chat_id);
+                if (actionChatId !== ownerChatId && !this.#gateway.isAuthorizedChat(actionChatId)) {
+                    throw new Error("Sanctuary Telegram chat action target is invalid");
+                }
+            }
             else if (requestMethod === "getFile") {
                 if (!exactBody(body, ["file_id"]) || !boundedText(body.file_id, 512)) {
                     throw new Error("Sanctuary Telegram file body is invalid");

package/dist/senses/telegram.js

@@ -51,6 +51,8 @@ exports.loadTelegramSenseCredentials = loadTelegramSenseCredentials;
 exports.createProductionTelegramRelationshipComposition = createProductionTelegramRelationshipComposition;
 exports.startTelegramSenseApp = startTelegramSenseApp;
 exports.sendTelegramExternalEventDecision = sendTelegramExternalEventDecision;
+exports.createProactiveRepetitionGuard = createProactiveRepetitionGuard;
+exports.withTelegramTypingIndicator = withTelegramTypingIndicator;
 exports.sendTelegramAwaitFollowUp = sendTelegramAwaitFollowUp;
 const node_crypto_1 = require("node:crypto");
 const node_async_hooks_1 = require("node:async_hooks");
@@ -717,6 +719,12 @@ function createTelegramSenseApp(options) {
     const transportPrivateValues = [botToken ?? "", authorizedUserId, authorizedChatId];
     const transportError = (error) => redactTelegramPrivateValues(error, transportPrivateValues);
     const api = authorityTransport?.api ?? options.api ?? (0, telegram_client_1.createTelegramBotApi)({ token: botToken });
+    // Only the root authority transport admits sendChatAction, so presence is offered
+    // exactly where it is actually supported rather than attempted everywhere.
+    const proactiveRepetitionGuard = createProactiveRepetitionGuard();
+    const sendTypingIndicator = authorityTransport
+        ? async (chatId) => { await api.request("sendChatAction", { chat_id: chatId, action: "typing" }); }
+        : undefined;
     const offsetStore = options.offsetStore ?? new telegram_client_1.FileTelegramOffsetStore(path.join(agentRoot, "state", "senses", "telegram", "offset.json"));
     const inboxStore = options.inboxStore ?? new telegram_client_1.FileTelegramUpdateInboxStore(path.join(agentRoot, "state", "senses", "telegram", "inbox.json"));
     const admissionStore = options.admission
@@ -1674,7 +1682,13 @@ function createTelegramSenseApp(options) {
             if (!actor || actor.friendId !== configuredOwnerFriendId)
                 throw new Error("Telegram attachment owner relationship is not active");
         }
-        await onMessageBody(message);
+        // Show the household that the Butler is working rather than silently thinking.
+        // Presence is deliberately separate from delivery: a transport that cannot do
+        // it degrades to silence instead of failing, and message-delivery assertions
+        // stay about messages.
+        await (sendTypingIndicator
+            ? withTelegramTypingIndicator(() => sendTypingIndicator(message.chatId), () => onMessageBody(message))
+            : onMessageBody(message));
     });
     const onUnknownMessage = admissionController && options.admission ? async (message) => {
         const approved = await options.admission.resolveApprovedFriend(message);
@@ -1867,7 +1881,20 @@ function createTelegramSenseApp(options) {
         },
         async sendProactive(text, signal) {
             await runWithAcceptanceAuditOwner(async () => {
-                const effect = await deliverButlerEffect(requiredText(text, "proactive message"), `proactive:${(0, node_crypto_1.randomUUID)()}`, signal);
+                const proactiveText = requiredText(text, "proactive message");
+                // Unsolicited repetition is the one thing a household agent cannot take
+                // back. External-event decisions are deliberately not guarded here:
+                // dropping one could leave its event undispositioned.
+                if (!proactiveRepetitionGuard.shouldSend(proactiveText)) {
+                    (0, runtime_1.emitNervesEvent)({
+                        component: "senses",
+                        event: "senses.telegram_proactive_repetition_suppressed",
+                        message: "suppressed a proactive message repeating a recent one",
+                        meta: { agentName: options.agentName, subject },
+                    });
+                    return;
+                }
+                const effect = await deliverButlerEffect(proactiveText, `proactive:${(0, node_crypto_1.randomUUID)()}`, signal);
                 const sessionPath = (0, shared_turn_1.getSenseSessionPath)(options.agentName, configuredOwnerFriendId, "telegram", configuredOwnerSessionKey, agentRoot);
                 await recordAcceptedEffects(sessionPath, [effect]);
             });
@@ -2222,6 +2249,70 @@ async function sendTelegramExternalEventDecision(agentName, input) {
         await app.stop();
     }
 }
+/**
+ * Suppresses a proactive message that repeats one sent recently.
+ *
+ * Ari received four probe messages in about two minutes, three of them identical
+ * apart from the clock reading. Only the clock is normalised away — counts and
+ * every other number are the payload, so "3 of 10 episodes" and "7 of 10" stay
+ * distinct and both send.
+ *
+ * This catches verbatim-apart-from-the-clock repetition, not semantic near
+ * duplicates: a message reworded between sends still goes out.
+ */
+function createProactiveRepetitionGuard(options) {
+    const windowMs = options?.windowMs ?? 900_000;
+    const now = options?.now ?? (() => Date.now());
+    const maxEntries = options?.maxEntries ?? 32;
+    const seen = new Map();
+    const normalize = (text) => text
+        .trim()
+        .replace(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z?/gu, "<timestamp>")
+        .replace(/\b\d{1,2}:\d{2}(?::\d{2})?\b/gu, "<clock>")
+        .replace(/\s+/gu, " ");
+    return {
+        shouldSend(text) {
+            const at = now();
+            for (const [key, sentAt] of [...seen]) {
+                if (at - sentAt >= windowMs)
+                    seen.delete(key);
+            }
+            const key = normalize(text);
+            const previous = seen.get(key);
+            if (previous !== undefined && at - previous < windowMs)
+                return false;
+            seen.set(key, at);
+            // A Map keeps insertion order and entries are inserted in send order, so
+            // the earliest key is the oldest; scanning for a minimum would carry a
+            // comparison branch that monotonic time can never take.
+            for (const oldest of seen.keys()) {
+                if (seen.size <= maxEntries)
+                    break;
+                seen.delete(oldest);
+            }
+            return true;
+        },
+    };
+}
+/**
+ * Telegram clears a typing indicator after roughly five seconds, so a turn that
+ * thinks for longer has to refresh it or the chat goes silent while the Butler is
+ * still working — which is what "leaving me on read" actually looked like.
+ *
+ * Indicator failures are swallowed on purpose: a missing typing bubble must never
+ * take down the reply it was decorating.
+ */
+async function withTelegramTypingIndicator(send, run, intervalMs = 4_000) {
+    const tick = () => { void Promise.resolve().then(send).catch(() => undefined); };
+    tick();
+    const timer = setInterval(tick, intervalMs);
+    try {
+        return await run();
+    }
+    finally {
+        clearInterval(timer);
+    }
+}
 async function sendTelegramAwaitFollowUp(agentName, request) {
     const app = await startTelegramSenseApp(agentName);
     try {

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.820",
+  "version": "0.1.0-alpha.822",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@ouro.bot/cli",
-      "version": "0.1.0-alpha.820",
+      "version": "0.1.0-alpha.822",
       "dependencies": {
         "@anthropic-ai/sdk": "^0.78.0",
         "@azure/identity": "^4.13.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.820",
+  "version": "0.1.0-alpha.822",
   "engines": {
     "node": ">=22"
   },